1. Constants, Variables, and Data Types

2. 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.

3. 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.

4. 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.

5. 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）.

6. C tokens
Fig C tokens and examples

7. 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.

8. Identifiers refer to the names of variables, functions and arrays
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.

10. 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.

11. Constants
See Page 25-26

12. 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.

13. Constants /* exam2-3.c */ #include "stdio.h" main( ) {
printf("Integer values\n\n");
printf("%d %d %d\n",32767, , );
printf("\n");
printf("Long integer values\n\n");
printf("%ld %ld %ld\n", 32767L,32767L+1,32767L+10);
getch( ); }

14. 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.

15. Constants
In addition, an arbitrary byte-sized bit pattern 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 digits (0…9,a…f or A…F).So we might write :
#define VTAB ‘\013’
/* ASCII vertical tab */
#define BELL ‘\007’
/* ASCII bell character */

16. Constants Or, in hexadecimal #define VTAB ‘\xb’
/* ASCII vertical tab */
#define BELL ‘\x7’
/* ASCII bell character */

17. 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

18. 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.

19. 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.

20. 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.

21. 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.

22. 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’ ).

23. 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.

24. 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.

25. 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. .

26. Variable
We tend to use short names for local variables, and longer names for external variables. Usually the length of variable names are less than 8 characters.
Keywords like if, else, int, float, etc. are
reserved: you can’t use them as variable names.

27. 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

28. 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.

29. Fig. 2.4 Primary data types in C

32. Primary data types and sizes
char
Range of values
–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

33. Data Types and Sizes
In addition, there are a number of qualifiers that can be applied to there basic types. Such as short, long, signed, unsigned.
short int sh; long int counter;
/*here int can be omitted.*/

34. char or signed char 8
–128 to 127
unsigned char
0 to 255
int or signed int 16
–32,768 to 32,767
unsigned int
0 to 65535
short int or
signed short int
unsigned short int
long int or
signed long int 32
–2,147,483,648 to 2,147,483,647
unsigned long int
0 to 4,294,967,295
float
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

35. Data Types and Sizes
Different type objects have different storage bits. So the range of the represented value are not same. short is often 16 bits, long 32 bits, and int either 16 or 32 bits. Each compiler is free to choose appropriate sizes for its own hardware, subject only to the restriction that shorts and ints are at least 16 bits, longs are at least 32 bits, and short is no longer than int, which is no longer than long.

36. 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.

37. 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.

38. Declarations All variables must be declared before use.
A variable can be used to store a value of any data type.

39. Declarations
A declaration specifies a type, and contains a list of one or more variables of that type:
int lower, upper, step;
char c, line[1000];
You can write it as :
int lower;
int upper;
int step;

40. 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.

41. The storage class is another qualifier (like long or unsigned) that can be added to a variable declaration as shown below:

43. Table 2.10 Storage Classes and Their Meaning
auto
Meaning
Local variable known only to the function in which it is declared. Default
is auto.
static
Local variable which exists and retains its value 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.

44. Assigning Values to Variables
A variable may also be initialized in its declaration.
char esc=‘\\’;
float eps=1.0e-5;
If the variable in question is not automatic, the initialization is done once only, conceptually before the program starts executing, and the initializer must be a constant expression.

45. Assigning Values to Variables
An explicitly initialized automatic variable is initialized each time the function or block it is entered; the initializer may be any expression.
External and static variables are initialized to zero or “”(for char array) by default.

46. Assigning Values to Variables
Automatic variables for which there is no explicit initializer have undefined values(i.e., garbage).
The qualifier const can be applied to the declaration 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 argument.

47. /* 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; } }