Changing Data Sizes
Sometimes, you want to reduce the memory taken by variables, or you need to increase the storage space of certain data types. Fortunately, the C language gives you the flexibility to modify sizes of data types. The two data modifiers, short and long, are introduced in the following two sections.
The short Modifier
A data type can be modified to take less memory by using the short modifier. For instance, you can apply the short modifier to an integer variable that is 32 bits long, which might reduce the memory taken by the variable to as little as 16 bits.
You can use the short modifier like this:
short x;
unsigned short y;
By default, a short int data type is a signed number. Therefore, in the short x; statement, x is a signed variable of short integer.
The long Modifier
If you need more memory to keep values from a wider range, you can use the long modifier to define a data type with increased storage space.
For instance, given an integer variable x that is 16 bits long, the declaration
long int x;
increases the size of x to 32 bits. In other words, after the modification, x is capable of holding a range of values from -2147483648 (that is, -231) to 2147483647 (that is, 231_1).
The ANSI standard allows you to indicate that a constant has type long by suffixing l or L to the constant. For instance:
long int x, y;
x = 123456789l;
y = 0xABCD1234L;
Here, the constants of the long int data type, 123456789l and 0xABCD1234L, are assigned to variables x and y, respectively.
Also, you can declare a long integer variable simply like this:
long x;
long int x;
Listing 9.2 contains a program that can print out the numbers of bytes for different modified data types.
TYPE
Listing 9.2. Modifying data with short and long.1: /* 09L02.c: Using short and long modifiers */
2: #include <stdio.h>
3:
4: main()
5: {
6: printf("The size of short int is: %d.\n",
7: sizeof(short int));
8: printf("The size of long int is: %d.\n",
9: sizeof(long int));
10: printf("The size of float is: %d.\n",
11: sizeof(float));
12: printf("The size of double is: %d.\n",
13: sizeof(double));
14: printf("The size of long double is: %d.\n",
15: sizeof(long double));
16: return 0;
17: }
I obtain the following output printed on the screen after I run the executable 09L02.exe from a DOS prompt:
C:\app> 09L02
The size of short int is: 2.
The size of long int is: 4.
The size of float is: 4.
The size of double is: 8.
The size of long double is: 10.
C:\app>
OUTPUT
In Listing 9.2, the sizeof operator and printf() function are used to measure the sizes of the modified data types and display the results on the screen.
For instance, lines 6 and 7 obtain the size of the short int data type and print out the number of the byte, 2, on the screen. From the output, you know that the short int data type is 16 bits (that is, 2 bytes) long on my machine.
ANALYSIS
Likewise, lines 8 and 9 find the size of the long int data type is 4 bytes (that is, 32 bits) long, which is the same length as the float data type obtained in lines 10 and 11.
Lines 12 and 13 obtain the size of the double data type, which is 8 bytes (that is, 64 bits) on my machine. Then, after being modified by the long modifier, the size of the double data type is increased to 10 bytes (that is, 80 bits), which is printed out by the printf() function in lines 14 and 15.
Adding h, l, or L to Format Specifiers
You can add h into the integer format specifier (like this: %hd, %hi, or %hu) to specify that the corresponding number is a short int or unsigned short int.
On the other hand, using %ld or %Ld specifies that the corresponding datum is long int. %lu or %Lu is then used for the long unsigned int data.
The program in Listing 9.3 shows the usage of %hd, %lu, and %ld.
TYPE
Listing 9.3. Using %hd, %ld, and %lu.1: /* 09L03.c: Using %hd, %ld, and %lu specifiers */
2: #include <stdio.h>
3:
4: main()
5: {
6: short int x;
7: unsigned int y;
8: long int s;
9: unsigned long int t;
10:
11: x = 0xFFFF;
12: y = 0xFFFFU;
13: s = 0xFFFFFFFFl;
14: t = 0xFFFFFFFFL;
15: printf("The short int of 0xFFFF is %hd.\n", x);
16: printf("The unsigned int of 0xFFFF is %u.\n", y);
17: printf("The long int of 0xFFFFFFFF is %ld.\n", s);
18: printf("The unsigned long int of 0xFFFFFFFF is %lu.\n", t);
19: return 0;
20: }
After the executable 09L03.exe is created and run from a DOS prompt, the following output is shown on the screen:
C:\app> 09L03
The short int of 0xFFFF is -1.
The unsigned int of 0xFFFF is 65535.
The long int of 0xFFFFFFFF is -1.
The unsigned long int of 0xFFFFFFFF is 4294967295
C:\app>
OUTPUT
There are four data types declared in Listing 9.3: the short int variable x, the unsigned int variable y, the long int variable s, and the unsigned long int variable t. The four variables are initialized in lines 6_9.
ANALYSIS
To display the decimal values of x, y, s, and t, the format specifiers %hd, %u, %ld, and %lu are used, respectively, in lines 15_18 to convert the corresponding hex numbers to decimal numbers. The output from the program in Listing 9.3 shows that values contained by x, y, s, and t have been correctly displayed on the screen.
