Constants, Variables,

and Data Types

Constants, Variables, and
Data Types

Like any other language, C has its

own vocabulary and grammar. In
this chapter, we will discuss the
concepts of constants and
variables and their types as they
relate to C programming language.
Introduction

The type of an object determines the set

of values it can have and what
operations can be performed on it.
Variables and constants are the basic
data objects manipulated in a program.
Declarations list the Variables to be
used, and state what type they have and
perhaps what their initial values are.
Character Set

The characters that can be used to form

words, numbers and expressions
depend upon the computer on which the
program is run. However, a subset of
characters is available that can be used
on most personal, micro, mini and
mainframe computers.
Character Set

The characters in C are grouped into the

following categories:
1. Letters
2. Digits
3. Special characters
4. White spaces
The entire character set is given in
Table 2.1 （ page 23 ） .
C tokens

Fig. 2.1 C tokens and examples

 Keywords and Identifiers
Every C word is classified as either a keyword
or an identifier.
All keywords have fixed meanings and these
meanings cannot be changed. Keywords
serve as basic building blocks for program
statements.
The list of all keywords of ANSI C are listed in
Table 2.3(page 24).
All keywords must be written in lowercase.
Some compilers may use additional keywords
that must be identified from the C manual.
Identifiers refer to the names of variables,
functions and arrays. These are user-defined
names and consist of a sequence of letters
and digits, with a letter as a first character.
Both uppercase and lowercase letters are
permitted, although lowercase letters are
commonly used.
The underscore character is also permitted in
identifiers. It is usually used as a link between
two words in long identifiers.
 Constants

Constants in C refer to fixed values

that do not change during the
execution of a program. C supports
several types of constants as
illustrated in Fig. 2.2.
 Constants

See Page 25-26

 Constants

There are several constants in C,such as

integer constant, floating-point constant,
char constant, string constant,
enumeration constant.
Integer constant can be specified in
decimal, octal, and hexadecimal.1234 is a
decimal integer constant, 037 which has
prefix ‘0’ is an octal integer constant, and
0x1f or 0x1F which has prefix‘0x’is a
hexadecimal integer constant.
 Constants
/* exam2-3.c */
#include "stdio.h"
main( )
{
printf("Integer values\n\n");
printf("%d %d %d\n",32767,32767+1,32767+10);
printf("\n");
printf("Long integer values\n\n");
printf("%ld %ld %ld\n", 32767L,32767L+1,32767L+10);
getch( );
}
 Constants

char constant is an integer, written as

one character within single
quotes,such as ‘x’, including escape
sequences like \n. These escape
sequences look like two characters,
but represent only one.
 Constants

In addition, an arbitrary byte-sized bit patte

rn can be specified by‘\ooo’, where ooo is
one to three octal digits(0…7) or by‘\xhh’,
where hh is one or more hexadecimal digit
s (0…9,a…f or A…F).So we might write :

#define VTAB ‘\013’

/* ASCII vertical tab */
#define BELL ‘\007’
/* ASCII bell character */
 Constants

Or, in hexadecimal

#define VTAB ‘\xb’

/* ASCII vertical tab */

#define BELL ‘\x7’

/* ASCII bell character */

 Constants
The complete of escape sequences is:

\a Alert (bell) character \\ Backslash

\b Backspace \? Question mark
\f Form feed \‘ Single quote
\n Newline \” Double quote
\r Carriage return \ooo Octal number
\t Horizontal tab \xhh Hexadecimal
number
\v Vertical tab
 Constants

The character constant ‘\0’ represents

the character with value zero, the null
character.
A constant expression is an
expression that involves only
constants. Such expression may be
evaluated during compilation rather
than run-time, and accordingly may be
used in any place that a constant can
be occur.
 Constants

A string constant is a sequence of

zero or more characters surrounded
by double quotes, as in “it is a string”,
or“” /* the empty string */ . The quotes
are not the part of the string.
 Constants

Technically, a string constant is an array

of characters. The internal representation
of a string has a null character‘\0’at the
end, so the physical storage required is
one more than number of characters
written between the quotes.
 Constants

This representation means that there is

no limit to how long a string can be, but
programs must scan a string completely
to determine its length.
 Constants

Notice: ‘a’ is not the same as “a”. The

former is an integer, used to produce
the number value of the letter a in the
machine’s character set. The latter is an
array of characters that contains one
character (the letter a) and the null
character ( ‘\0’ ).
 Variable
In c, there are some restrictions on
the names of variables and
symbolic constants.
Names are made up of letters and
digits;the first character must be a
letter. The underscore “_” counts as
a letter; it is sometimes useful for
improving the readability of long
variable names.
 Variable

Don’t begin variable names with

underscore, however, since library
routines often use such names.
Upper case and lower case letters
are distinct, so x and X are two
different names. Traditional C
practice is to use lower case for
variable names, and all upper case
for symbolic constants.
 Variable

ANSI standard recognizes a length of

31 characters. However, length
should not be normally more than
eight characters, since only the first
eight characters are treated as
significant by many compilers. .
 Variable

We tend to use short names for local vari

ables, and longer names for external vari
ables. Usually the length of variable nam
es are less than 8 characters.

Keywords like if, else, int, float, etc. are

reserved: you can’t use them as variable
names.
 Data Types and Sizes

C language is rich in its data types. The

variety of data types available allow the
programmer to select the type appropriate to
the needs of the application as well as the
machine.
ANSI C supports three classes of data types:
1. Primary (or fundamental) data types
2. Derived data types
3. User-defined data types
 Data Types and Sizes

The primary data types and their

extensions are discussed in this
section. The user-defined data types
are defined in the next section while
the derived data types such as arrays,
functions, structures and pointers are
discussed as and when they are
encountered.
Fig. 2.4 Primary data types in C
 Primary data types and sizes

Data types Range of values

char –128 to 127
int –32,768 to 32,767
float 3.4e–38 to 3.4e+e38
double 1.7e–308 to 1.7e+308
 Data Types and Sizes

In addition, there are a number of qu

alifiers that can be applied to there b
asic types. Such as short, long, sign
ed, unsigned.
short int sh; long int counter;
/*here int can be omitted.*/
char or signed char 8 –128 to 127
unsigned char 8 0 to 255
int or signed int 16 –32,768 to 32,767
unsigned int 16 0 to 65535
short int or
signed short int 8 –128 to 127
unsigned short int 8 0 to 255
long int or
signed long int 32 –2,147,483,648 to
2,147,483,647
unsigned long int 32 0 to 4,294,967,295
float 32 3.4E – 38 to 3.4E + 38
double 64 1.7E – 308 to 1.7E + 308
long double 80 3.4E – 4932 to 1.1E + 4932
 Data Types and Sizes

Different type objects have different stora

ge bits. So the range of the represented v
alue are not same. short is often 16 bits, l
ong 32 bits, and int either 16 or 32 bits. E
ach compiler is free to choose appropriate
sizes for its own hardware, subject only to
the restriction that shorts and ints are at le
ast 16 bits, longs are at least 32 bits, and
short is no longer than int, which is no lon
ger than long.
 Data Types and Sizes

The qualifier signed or unsigned

may be applied to char or any
integer.

Unsigned numbers are always

positive or zero, and obey the laws
of arithmetic modulo 2n,where n is
the number of bits in the type.
 Data Types and Sizes

So, for instance, if chars are 8 bits,

unsigned char variables have values
between 0 to 255, while signed chars have
values between –128 and 127. Whether
plain chars are signed or unsigned is
machine-dependent, but printable
characters are always positive.
Look at the limits.h and float.h to get a
reference.
 Declarations

All variables must be declared before

use.
A variable can be used to store a
value of any data type.
 Declarations
A declaration specifies a type, and contai
ns a list of one or more variables of that t
ype:
int lower, upper, step;
char c, line[1000];
You can write it as :
int lower;
int upper;
int step;
char c, line[1000];
Declaration of Storage Class

Variables in C can have not only data

type but also storage class that provides
information about their location and
visibility. The storage class decides the
portion of the program within which the
variables are recognized.
The storage class is another qualifier
(like long or unsigned) that can be
added to a variable declaration as
shown below:
 Table 2.10 Storage Classes and Their Meaning

Storage
Meaning
class
Local variable known only to the function in which
auto
it is declared. Default
is auto.

Local variable which exists and retains its value

static
even after the control is
transferred to the calling function.
extern Global variable known to all functions in the file.
register Local variable which is stored in the register.
Assigning Values to Variables

A variable may also be initialized in its d

eclaration.
char esc=‘\\’;
float eps=1.0e-5;

If the variable in question is not automati

c, the initialization is done once only, co
nceptually before the program starts exe
cuting, and the initializer must be a cons
tant expression.
Assigning Values to Variables

An explicitly initialized automatic variable

is initialized each time the function or blo
ck it is entered; the initializer may be any
expression.

External and static variables are initialize

d to zero or “”(for char array) by default.
Assigning Values to Variables
Automatic variables for which there is no e
xplicit initializer have undefined values(i.e.,
garbage).
The qualifier const can be applied to the d
eclaration of any variable to specify that its
value will not be changed. It is can also be
used with array arguments, to indicate that
the function does not change that array arg
ument.
/* ex1-3.c */
#include <stdio.h>
/*print Fahrenheit-Celsius table for fahr=0,20,…,300*/
main( )
{float fahr,celsius;
int lower,upper,step;
lower=0; /* lower limit of temperature table */
upper=300; /* upper limit */
step=20; /* step size*/
fahr=lower;
while (fahr<=upper)
{ celsius=5.0/9.0*(fahr-32);
printf(“%3.0f %6.1f\n”,fahr,celsuis);
fahr=fahr+step; }
}
 Defining Symbolic Constants
The 4th version of the temperature converter(ex1-
5.c):
#include <stdio.h>
/*print Fahrenheit-Celsius table for fahr=0,20,…,300
*/
#define LOWER 0 /* lower limit of table */
#define UPPER 300 /* upper limit of table */
#define STEP 20 /* step size */
main( )
{ int fahr;
for (fahr=LOWER; fahr<=UPPER; fahr=fahr+STEP)
printf(“%d %6.1f\n”,fahr,(5.0/9.0)*(fahr-32));
}
 Defining Symbolic Constants
A #define line defines a symbolic name or sy
mbolic constant to be a particular string of c
haracters:
#define name replacement text
thereafter, any occurrence of name (not in qu
otes and not part of another name) will be re
placed by the corresponding replacement te
xt.
The name has the same form as a variable n
ame:a sequence of letters and digits that be
gins with a letter.
 Defining Symbolic Constants

The replacement text can be any sequence

of characters; it is not limited to numbers.
Notice: symbolic constant differs from
variable, symbolic constant can not be
assigned again in the program. Usually
symbolic constants name are written in
upper case so then can be readily
distinguished from lower case variable
names. And there is no semicolon at the
end of a #define line.