C has a concept of 'data types' which are used to define a
variable before its use. The definition of a variable will assign
storage for the variable and define the type of data that will be held
in the location.
The value of a variable can be changed any time.
C has the following basic built-in datatypes.
Please note that there is not a boolean data type. C does not have
the traditional view about logical comparison, but thats another story.
int - data type
is used to define integer numbers.
{
int Count;
Count = 5;
}
float - data type
float is used to define floating point numbers.
{
float Miles;
Miles = 5.6;
}
double - data type
double is used to
define BIG floating point numbers. It reserves twice the storage for the
number. On PCs this is likely to be 8 bytes.
{
double Atoms;
Atoms = 2500000;
}
char - data type
char defines characters.
{
char Letter;
Letter = 'x';
}
Modifiers
The data types explained above have the following modifiers.
- short
- long
- signed
- unsigned
modifiers define the amount of storage allocated to the
variable. The amount of storage allocated is not cast in stone. ANSI has
the following rules:
short int <= int <= long int
float <= double <= long double
What this means is that a 'short int' should assign less than or the
same amount of storage as an 'int' and the 'int' should be less or the
same bytes than a 'long int'. What this means in the real world is:
Type Bytes Range
---------------------------------------------------------------------
short int
2 -32,768 -> +32,767
(32kb)
unsigned short int 2 0 -> +65,535 (64Kb)
unsigned int
4 0 -> +4,294,967,295
( 4Gb)
int 4 -
2,147,483,648 -> +2,147,483,647 ( 2Gb)
long int 4 -2,147,483,648 -> +2,147,483,647 ( 2Gb)
signed char 1 -128 -> +127
unsigned char 1 0 -> +255
float 4
double 8
long double 12
These figures only apply to todays generation of PCs. Mainframes and
midrange machines could use different figures, but would still comply
with the rule above.
You can find out how much storage is allocated to a data type by using the sizeof operator discussed in Operator Types Session.
Here is an example to check size of memory taken by various datatypes.
int main()
{
printf("sizeof(char) == %d\n", sizeof(char));
printf("sizeof(short) == %d\n", sizeof(short));
printf("sizeof(int) == %d\n", sizeof(int));
printf("sizeof(long) == %d\n", sizeof(long));
printf("sizeof(float) == %d\n", sizeof(float));
printf("sizeof(double) == %d\n", sizeof(double));
printf("sizeof(long double) == %d\n", sizeof(long double));
printf("sizeof(long long) == %d\n", sizeof(long long));
return 0;
}
Qualifiers
A type qualifier is used to refine the declaration of a variable, a function, and parameters, by specifying whether:
The value of a variable can be changed.
The value of a variable must always be read from memory rather than from a register
Standard C language recognizes the following two qualifiers:
The const qualifier is used to tell C that the variable value can not change after initialisation.
const float pi=3.14159;
Now pi cannot be changed at a later time within the program.
Another way to define constants is with the #define preprocessor which has the advantage that it does not use any storage
The volatile qualifier declares a data type that can have its value
changed in ways outside the control or detection of the compiler (such
as a variable updated by the system clock or by another program). This
prevents the compiler from optimizing code referring to the object by
storing the object's value in a register and re-reading it from there,
rather than from memory, where it may have changed. You will use this
qualifier once you will become expert in "C". So for now just proceed.
What are Arrays:
We have seen all baisc data types. In C language it is possible to
make arrays whose elements are basic types. Thus we can make an array of
10 integers with the declaration.
int x[10];
The square brackets mean subscripting; parentheses are used only for
function references. Array indexes begin at zero, so the elements of x
are:
Thus Array are special type of variables which can be used to store
multiple values of same data type. Those values are stored and accessed
using subscript or index.
Arrays occupy consecutive memory slots in the computer's memory.
x[0], x[1], x[2], ..., x[9]
If an array has n elements, the largest subscript is n-1.
Multiple-dimension arrays are provided. The declaration and use look like:
int name[10] [20];
n = name[i+j] [1] + name[k] [2];
Subscripts can be arbitrary integer expressions. Multi-dimension
arrays are stored by row so the rightmost subscript varies fastest. In
above example name has 10 rows and 20 columns.
Same way, arrays can be defined for any data type. Text is usually
kept as an array of characters. By convention in C, the last character
in a character array should be a `\0' because most programs that
manipulate character arrays expect it. For example, printf uses the `\0'
to detect the end of a character array when printing it out with a
`%s'.
Here is a program which reads a line, stores it in a buffer, and prints its length (excluding the newline at the end).
main( ) {
int n, c;
char line[100];
n = 0;
while( (c=getchar( )) != '\n' ) {
if( n < 100 )
line[n] = c;
n++;
}
printf("length = %d\n", n);
}
Array Initialization
As with other declarations, array declarations can include an optional initialization
Scalar variables are initialized with a single value
Arrays are initialized with a list of values
The list is enclosed in curly braces
int array [8] = {2, 4, 6, 8, 10, 12, 14, 16};
The number of initializers cannot be more than the number of
elements in the array but it can be less in which case, the remaining
elements are initialized to 0.if you like, the array size can be
inferred from the number of initializers by leaving the square brackets
empty so these are identical declarations:
int array1 [8] = {2, 4, 6, 8, 10, 12, 14, 16};
int array2 [] = {2, 4, 6, 8, 10, 12, 14, 16};
An array of characters ie string can be initialized as follows:
char string[10] = "Hello";
