C Tokens

.
 Tokens
• A token in C can be defined as the smallest
individual element of the C programming
language that is meaningful to the compiler.
• It is the basic component of a C program.
• One or more characters are grouped together
to form basic elements of c known as Tokens
 Keywords
• The keywords are pre-defined or reserved words in a
programming language. Each keyword is meant to perform a
specific function in a program. Keywords can’t be used as
variable names You cannot redefine keywords. However, you can
specify the text to be substituted for keywords before
compilation by using C preprocessor directives. C language
supports 32 keywords which are given below:
• auto double int struct
break else long switch
case enum register typedef
char extern return union
const float short unsigned
continue for signed void
default goto sizeof volatile
do if static while
 Rules for Keywords
• All the keywords are lower case letters.Thus
int is a keyword but Int and INT are not.
• Keywords are also called as reserved words.
• All the keywords have pre-defined
meanings.They cannot be redefined or used in
other contexts.
• Keywords are reserved ,that is,we cannot use
them as identifiers
 Identifiers
• A C Identifier is a name given to a variable,function,or any other
user defined item.
• RULES FOR IDENTIFIERS
• An identifier can include letters (a-z or A-Z), and digits (0-9).
• An identifier cannot include special characters except the ‘_’
underscore.
• Spaces are not allowed while naming an identifier.
• An identifier can only begin with an underscore or letters.
• We cannot name identifiers the same as keywords because they
are reserved words to perform a specific task. For example, printf,
scanf, int, char, struct, etc. If we use a keyword’s name as an
identifier the compiler will throw an error.
• The identifier must be unique in its namespace.
• C language is case-sensitive so, ‘name’ and ‘NAME’ are different
identifiers.
 Constants
• What is a constant in C?
• As the name suggests, a constant in C is a variable that
cannot be modified once it is declared in the program.
We can not make any change in the value of the
constant variables after they are defined.
• How to Define Constant in C?
• We define a constant in C language using
the const keyword. Also known as a const type qualifier,
the const keyword is placed at the start of the variable
declaration to declare that variable as a constant.
• Syntax to Define Constant
• const data_type var_name = value;
 Integer Constants
• Integer constants are whole numbers without
any decimal point. They can be represented in
different number systems:
• Decimal: A number in base 10 (e.g., 10, 0, -25).
• Octal: A number in base 8, starting with a 0
(e.g., 012 is the octal for decimal 10).
• Hexadecimal: A number in base 16, starting with
0x or 0X (e.g., 0x1A is the hexadecimal for
decimal 26).
Real Constants or Floating Point constants
• Real constants are numbers with a fractional part or in
scientific notation.
• Decimal notation: E.g., 10.5, -3.14, 0.001.
• Exponential (Scientific) notation: E.g., 3.2e5 (which means
3.2×1053.2 \times 10^53.2×105).
• Rules:
• Must have a decimal point (e.g., 5.0) or be in exponential
form.
• Use suffixes to specify the type:
– f or F for float (e.g., 3.14f)
– l or L for long double (e.g., 3.14L)
 Character Constants
• Character constants are single characters enclosed in single quotes.
• Example: 'a', '1', '$‘
• Rules:
• Only one character is allowed inside the single quotes.
• The value of a character constant is the ASCII value of the character.
For example, 'A' has the value 65 in ASCII.
• Escape sequences can be used for special characters:
– '\n' for newline
– '\t' for tab
– '\0' for null
– '\‘ for a single quote
– '\b' for backspace
 String Constants
• String constants are sequences of characters enclosed in
double quotes.
• Example: "Hello", "C programming".
• Rules:
• A string constant is always null-terminated, meaning there
is an extra '\0' character automatically added to the end of
the string.
• String constants can be assigned to character arrays or
used in functions like printf.
• A string can include escape sequences, like "\n" for a new
line.
 Variables
• In programming, we often need a named
storage location to store the data or values.
Using variables, we can store the data in our
program and access it afterward.
• Syntax:data_type variable_name;
• Ex: int age;
• float salary;
• char grade;
Cont….
 Data types
• The datatypes are used to inform the type of value
that can be stored in a variable.
• Syntax : datatype var1, var2….varn;
• Ex : int first , second, sum ;
• C has basic 4 datatypes
• Int
• Char
• Float
• double
 Int Data type
• int stands for integer, which is a data type used to
represent whole numbers (both positive and
negative).
• Syntax: int variable_name;
• Example:int age = 25; int count = -10;
• Explanation:
• int typically uses 4 bytes of memory (though this can
vary based on the system), and it can store values in
the range of -2,147,483,648 to 2,147,483,647 (for a
32-bit system).
 Char Data type
• char stands for character, used to store
individual characters.
• Syntax: char variable_name;
• Example: char initial = 'A';
char grade = 'B';
• Explanation:
• char typically uses 1 byte of memory and can
store values from 0 to 255, representing ASCII
characters.
 float
• float is used to store floating-point numbers,
which are numbers with a decimal point.
• Syntax: float variable_name;
• Example: float pi = 3.14;
float temperature = -4.5;
• Explanation:
• float typically uses 4 bytes of memory and can
represent numbers with about 6-7 decimal
places of precision.
 double
• double is used to store floating-point numbers
with double precision.
• Syntax: double variable_name;
• Example: double e = 2.718281828459;
double distance = 123456.789;
• Explanation:
• double typically uses 8 bytes of memory and
can represent numbers with about 15-16
decimal places of precision.
 Qualifiers/Modifiers
• Qualifiers or Modifiers are keywords,used to alter the basic
datatypes based on the size and sign.
• The qualifiers that can be applied to the basic datatypes are
• Signed: A modifier that allows both positive and negative
integer values.
• Unsigned: A modifier that restricts a variable to only hold
positive values (including zero)
• Short: A modifier that reduces the storage size of an integer
• Long: A modifier that increases the storage size of an integer
to accommodate larger values
 Syntax and ex for Modifiers
• Synatx:<modifier> <basic data type>
<var1>,<var2>,….<varn>;

• Ex: short int a,b,c;

Long int d;
 Qualifiers for the int data type
• All the qualifiers I,e, signed ,unsigned ,short and
long can be applied to the integer
variable.Declaration is int a;
• 1) signed int Ex:signed int num = -50;
• 2) unsigned int Ex: unsigned int a = 400000000;
• 3) short int ex: short int a = 10;
• 4) long int ex: int a =10; or long int a=10
Long long int b=99999999999999999;
 Qualifiers for char data type
• The qualifiers that can be prefixed to char data
type are signed and unsigned .
• The qualifiers long and short may not be
applied to char data type.
• The char variable stores any +ve and –ve
integer between -128 to +127.
• Ex for Signed : char ch; (note same as signed char ch;)
• Ex for unsigned: unsigned char ch;
Qualifiers for float and double data type
• The float data type occupies 4 bytes in
memory
• The long double variable occupies minimum
10 bytes of memory
• (note 1 Byte = 8 bits)
• Ex for long double : long double d = 1.5e2520;
 Declaration of Variables
• Syntax: data_type variable_name;
• data_type: This defines the type of data the variable will hold, like int, float,
char, etc.
• variable_name: This is the name of the variable

• Examples:Declaring an integer variable: int age;

• int is the data type, and age is the variable name.
• Declaring a character variable:char grade;
• char is the data type, and grade is the variable name for storing a single
character.
• Declaring a floating-point variable:float height;
• float is the data type, and height is the variable name for storing decimal values.
• Declaring multiple variables of the same type:int x, y, z;
• Declares three integer variables x, y, and z
 Assigning values to variables
• Once variable is been declared next step is to
assign a value to the variable,The process of
assigning a value to the variable is called as
initialization.
• Assigning a value to variable can be done in 2
ways
• 1)Using Assignment Operator
• 2)Reading data from keyboard
 1)Using Assignment Operator
• Variables declared can be initialized using an
assignment operator “=“.
• Syntax: data_type variabl_name = constant;
• Ex : int x =10; 1)
>>>>Int x; 2)
X = 10;
>>>>Int x,y,z; 3)
X=y=z=10;
 ex
• #include <stdio.h>

• int main() {
• // Variable declarations
• int age; // Integer declaration
• float height; // Float declaration
• char grade; // Character declaration

• // Assigning values to the variables

• age = 20; // Assigning value to 'age'
• height = 5.9; // Assigning value to 'height'
• grade = 'A'; // Assigning value to 'grade'

• // Printing the values of the variables

• printf("Age: %d\n", age); // %d is used for int
• printf("Height: %.1f\n", height); // %.1f is used for float (one decimal place)
• printf("Grade: %c\n", grade); // %c is used for char

• return 0;
• }
 Reading data from keyboard
• One more way of assigning values to variables
is to input data from keyboard using scanf
function
• Syntax:scanf(“format string”,&var1,var2,…&varn);
• Ex: int x;
printf(“enter the value of x”);
scanf(“%d”, &x);
(note here x is only declared but not
initialized .once the value is been entered by the
user then value will be assigned)
 Defining symbolic constants

• In C, symbolic constants are used to define constant values that remain

unchanged throughout the program.
• To define a symbolic constant, you typically use the #define preprocessor
directive
• Every preprocessor must start with # and should not contain semi colon
• The preprocessor directive is divided into 3 categories:
• 1)Macro Substitution Directives
• 2)file inclusion directives
• 3)Conditional compilation directives
• (macro: macros are a type of preprocessor directive used to define
constants, functions, or code fragments. They are defined using the
#define directive.)
 Simple macro substitution
• Simple macro substitution will replace all the
occurrences of an identifier with the string
from the position of definition to the end of
the program.
• Ex: #define PI 3.14
 Macros with arguments
• General form : #define identifier(arg1,arg2,
….argn) <substitution value>
• The subsequent occurrence of macros with
arguments is known as macro call
• Ex: #define sum(a,b) a+b
z=sum(x,y)
z=x+y;
 Defining variable as a constant
• By using constant type qualifier we r saying
compiler that this value is going to remain
constant
• Ex: int const x=10;
 THANKYOU

•Any Questions ??