Constants, Variables, and Data Types

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. 2.1 C tokens and examples

7. Keywords and Identifiers • Every C word is classified as either a keyword or anidentifier. • 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. 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,32767+1,32767+10); printf("\n"); printf("Long integer values\n\n"); printf("%ld %ld %ld\n", 32767L,32767L+1,32767L+10); getch( ); }

14. Constants • char constantis aninteger, 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 threeoctaldigits(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:

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

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

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 beapplied 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; char c, line[1000];

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 longor unsigned) that can be added to a variable declaration as shown below:

43. Table 2.10 Storage Classes and Their Meaning

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; } }