To determine and test the limits of common data types in C.

There are several data types available for you to manipulate in C:

Each data type can be a signed or unsigned quantity. The sign of a quantity is simply whether or not it includes negative values. For example, let's look at an unsigned 4-bit quantity:

So, in a 4-bit quantity, you've got 16 distinct values. It is considered 4-bit because we are dealing with the binary values– what the computer deals with. If we were dealing with an 8-bit quantity, there would be 8 bits for use in counting.

Actually, to determine the number of unique states, you'd use the following: 2^n

Where n is the number of bits you are dealing with. In this case: 4-bits = 2^4 = 16

The values in the above table are all unsigned quantities, in that they are only the positive representation. To play with signed quantities, we use the leftmost bit (the Most Significant Bit (MSB)) as the sign– where 0 is positive and 1 is negative.

In this case, we now have the following values:

To obtain the negative bit representation of a number, we perform an operation known as two's complement:

6 = 0110 
6 - 1 = 5 ---> 0110 - 0001 = 0101
Then invert (turn 0's to 1's, and 1's to 0's): 0101 ---> 1010

As you can see, we still have all 16 distinct states, but they are now represented in positive and negative values. The range of 4-bit signed integers here is -8 to +7, where the range of 4-bit unsigned integers is 0 to 15.

Now, you may be wondering why this is relevant– basically, the ranges of things like integers aren't a fixed absolute value from system to system.

This could result in some calculation problems if a program is written expecting integers to be 32-bit values and the host system treats integers as 16-bit values.

It is important to know what these values are on any system you program on. Guess what you get to determine and experiment with in this Case Study :)

Checking the values: limits.h

#include <stdio.h>
 
int main()
{
	unsigned int a, x;
	signed short int b, y;
 
	a = 0; // zero not letter "O"
	b = 0;
	x = a - 1;
	y = b - 1;
 
	printf("unsigned int before: %u \t after: %u\n", a, x);
	printf("signed short int before: %hd \t after: %hd\n", b, y);
 
	return(0);
}

Testing the limits:

Now let's run it.

Time for some modifications.

Save, exit, and recompile dtype.c

This assignment has activities which you should tend to- document/summarize knowledge learned on your Opus.

As always, the class mailing list and class IRC channel are available for assistance, but not answers.