10.3. Basic Types and Pointers¶

10.3.1. C99 Fixed-width Types¶

In systems programming, this sort of inconsistent definition can lead to serious mistakes. If an embedded microcontroller (such as a tiny wireless sensor monitoring a car’s velocity) needs to send data to a centralized controller, it would be beneficial for both devices to agree on the size of various types of data. To fix this, systems code typically uses explicitly named types. These types, defined in stdint.h, are shown in Table A.3.

The type name is constructed as intn_t or uintn_t, where the n is one of 8, 16, 32, or 64. For each size, there is a signed minimum (INTn_MIN), a signed maximum (INTn_MAX), and an unsigned maximum (UINTn_MAX). (The unsigned minimum is 0 for all sizes.) Note that INT32_MIN and INT64_MIN cannot be represented directly because of the way that C defines numeric constants. Instead, they have to be written in relation to the corresponding INTn_MAX values, but they are the values -2,147,483,648 and -9,223,372,036,854,775,808, respectively. Also observe that the large values need to be appended with U, LL, or ULL so that the C compiler will interpret the values correctly.

Code Listing A.5 illustrates a few key points about using these standard and fixed types. Lines 6 – 10 declare a char variable and print it both in ASCII (using %c) and as an integer value (in decimal, octal, and hexadecimal format). This code would work identically even if the declaration of the achar variable was changed to uint8_t, the 8-bit unsigned integer type. Lines 13 – 16 demonstrate the standard printing for an int type.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

/* Code Listing A.5:
   Using and printing various integer types
 */

/* Use char, printing it in 4 formats */
char achar = 'A'; 
printf ("achar has value %c (character)\n", achar);
printf ("achar has value %hhd (dec)\n", achar);
printf ("achar has value %hho (oct)\n", achar);
printf ("achar has value %04hhx (hex)\n\n", achar);

/* Use basic int type, printing value in 3 formats */
int intval = 42;
printf ("intval has value %d (dec)\n", intval);
printf ("intval has value %o (oct)\n", intval);
printf ("intval has value %04x (hex)\n\n", intval);

/* Use 32-bit signed integer, printing value */
int32_t i32val = 42;
printf ("i32val has value %d (dec)\n", i32val);
printf ("i32val has value %" PRId32 " (dec)\n", i32val);
printf ("i32val has value %" PRIo32 " (oct)\n", i32val);
printf ("i32val has value %04" PRIx32 " (hex)\n\n", i32val);

/* Use 64-bit unsigned integer, printing value */
uint64_t ui64val = 42;
printf ("ui64val has value %d (dec)\n", ui64val);
printf ("ui64val has value %lld (dec)\n", ui64val);
printf ("ui64val has value %" "lld" " (dec)\n", ui64val);
printf ("ui64val has value %" PRId64 " (dec)\n", ui64val);
printf ("ui64val has value %" PRIo64 " (oct\)\n", ui64val);
printf ("ui64val has value %04" PRIx64 " (hex)\n\n", ui64val);

The remaining lines (19 – 31) demonstrate similar handling using the fixed-width integer types. These format strings initially look rather confusing, because they exploit a feature of string constants that is often overlooked (or not taught) to those new to C: consecutive string constants are concatenated automatically by the compiler. For example, the code printf ("hello world"); is treated identically to printf ("hello "    "world"); by the compiler. (The several white spaces between the strings are ignored and used here only for effect.)

The format specifiers for these integer types are defined in the inttypes.h header. Within this file, there is a preprocessor definition that will translate PRId32 or PRIx64 into the appropriate character strings ("d" and "llx" in this case) from Table A.2 for the target machine. In general, the format specifier has the format PRIfn, where n is the size (8, 16, 32, or 64 bits) and f is the desired integer format (d or i for signed decimal, u for unsigned decimal, o for octal, x or X for hexadecimal). Consequently, the C compiler would treat lines 29 and 30 in Code Listing A.5 identically to line 28. The PRId64 is translated by the processor into "lld", so lines 29 and 30 literally become identical when the compiler begins to work with the code; the compiler then transparently concatenates the string constants to create the string shown in line 28. When compiling this code, observe that line 27 produces a warning, as the variable and the corresponding format specifier are specifying different sizes (64-bit for uint64_t and 32-bit for %d).

Bug Warning

---

The quotation marks around the C99 format strings is a common point of confusion that can lead to frustrating compiler errors. Specifically, note that there is a quote after the % character that begins the format specifier. This quote is necessary, as it terminates the string constant up to that point. Any additional characters that modify the format specifier (such as 0 to indicate leading zeros, a number to specify a fixed display width, or a - to indicate left-justification within that space) must appear before the quotation mark, as these are not part of the C99 format processing.

One common task with working with C types is using the sizeof() operator [2] to examine the number of bytes allocated for a variable or a type. In the case of a type, sizeof() indicates how many bytes would be allocated for such a variable instance. Code Listing A.6 demonstrates the use of sizeof(), based off of the variable declarations in Code Listing A.5. As the value returned from sizeof() is considered to be of type size_t, the %zd format specifier is required when printing these values. On most systems, lines 7, 8, 12, and 13 will all produce the same size result (4), as int and int32_t are typically identical.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

/* Code Listing A.6:
   Using sizeof() for introspection of variable and type sizes
 */

/* Use sizeof to get the size of a variable name */
size_t size = sizeof (intval);
printf ("intval has size %zd\n", size);
printf ("i32val has size %zd\n", sizeof (i32val));
printf ("ui64val has size %zd\n\n", sizeof (ui64val));

/* Use sizeof to get the size of a variable type */
printf ("Primitive int type has size %zd\n", sizeof (int));
printf ("C99 int32_t type has size %zd\n", sizeof (int32_t));
printf ("C99 int64_t type has size %zd\n", sizeof (int64_t));
printf ("Primitive size_t type has size %zd\n", sizeof (size_t));

10.3.2. Pointer Basics¶

As this Appendix is intended as a re-introduction to C, readers are generally assumed to have had some prior exposure to key features of the language, including pointers. However, few concepts in programming cause as many problems or as much frustration as pointers; as such, we will reiterate the basic concept here, particularly as it relates to the preceding discussion on sizeof(). Later in this Appendix, we will also introduce some intermediate or advanced techniques of working with pointers. To start, we emphasize the following key idea:

A pointer is a variable that stores an address.

When a pointer variable is declared, its declaration generally indicates what type of data is stored at that address. This target type is generally included when discussing a pointer’s type, but it does not change the fact that the pointer stores an address. For instance, by declaring int *x = NULL;, we have declared the variable named x to be a pointer to an int. That is, we might write that x is an int*. It cannot be overstated that this statement is different from saying that x is an int. Part of what makes this subtly complex is that addresses are, fundamentally, integer values that have a particular meaning. Code Listing A.7 illustrates this confusion in a common manner.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

/* Code Listing A.7:
   A subtle segfault bug
 */

int ival = 10;
int *iptr = &ival; // iptr points to ival

*iptr = 0; // sets ival to 0
printf ("iptr = %p; *iptr = %d\n", iptr, *iptr);

iptr = 0; // makes iptr point to nowhere (i.e., NULL)
/* next line causes a segfault since iptr is now NULL */
printf ("iptr = %p; *iptr = %d\n", iptr, *iptr);

Lines 5 and 6 declare two variables, one (ival) has the type int and the other (iptr) has the type int*. The value of ival is initialized to 10, whereas the value of iptr is the address of ival (&ival). That is, iptr is initialized so that it points to ival. We might also say that iptr is an indirect reference to ival. Line 8 dereferences the pointer (i.e., follows the arrow to the data pointed to) and sets that portion of memory to 0; specifically, by dereferencing the pointer, line 8 is changing the value of ival from 10 to 0. As such, line 9 runs without error, printing the value of iptr (which is the address of ival) along with the new value of ival (because we are again dereferencing the pointer).

Line 11 is fundamentally different, however. Since line 11 is not dereferencing the pointer (note that there is no * on this line), it is changing the value of iptr itself. Recall from above that a pointer stores an address; if we change a pointer’s value, we are changing the memory address that we are pointing to. By setting iptr to 0, the pointer now points to address 0, which is nothingness. That is, iptr no longer points to ival; it is now a NULL pointer (NULL is literally the constant 0 in C!). As such, line 13 causes a segmentation fault, because it tries to deference a null pointer (*iptr).

A common misunderstanding about this example is that setting the pointer to NULL does not necessarily cause an error. Code Listing A.8 extends A.7, with the exception that a new line is added just before the final printf() statement. In Code Listing A.7, the code set iptr to 0 and immediately called printf(); in Code Listing A.8, line 7 occurs between these steps, setting iptr to point back to ival. In restoring iptr’s value to point to a valid location, Code Listing A.8 removes the segmentation fault that occurred in A.7. In short, setting a pointer’s value to NULL does not cause a segmentation fault; the fault only occurs once the pointer is dereferenced.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

/* Code Listing A.8:
   Restoring successful execution to Code Listing A.7
 */

iptr = 0; // makes iptr point to nowhere (i.e., NULL)

iptr = &ival; // makes iptr point to ival again

/* next line no longer segfaults */
printf ("iptr = %p; *iptr = %d\n", iptr, *iptr);

To return to the discussion of type sizes, a common misunderstanding arises when we combine the concepts of pointers and sizeof(). Recall two facts: sizeof() returns the number of bytes required for a variable of a particular type, and all pointers store addresses (and nothing else!). As such, calling sizeof() on a pointer will always return the same answer: the size of an address. From the perspective of sizeof(), pointer declarations are all identical. Code Listing A.9 demonstrates this fact. The variables ival and cval have distinct sizes (typically, 4 bytes for ival as an int and 1 byte for cval as a char). In contrast, iptr and cptr have different types, but they are the same size (8 bytes, assuming this code runs on a 64-bit CPU architecture). As such, the assertions on lines 17 and 18 are both true.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

/* Code Listing A.9:
   Using sizeof() with pointers produces different results from basic types
 */

int ival = 10;
int *iptr = &ival;
printf ("Size of ival = %zd\n", sizeof (ival));
printf ("Size of iptr = %zd\n", sizeof (iptr));
printf ("Size of *iptr = %zd\n\n", sizeof (*iptr));

char cval = 'a';
char *cptr = &cval;
printf ("Size of cval = %zd\n", sizeof (cval));
printf ("Size of cptr = %zd\n", sizeof (cptr));
printf ("Size of *cptr = %zd\n", sizeof (*cptr));

assert (sizeof (int *) == sizeof (char *));
assert (sizeof (int) != sizeof (char));
assert (sizeof (*iptr) != sizeof (*cptr));

Lastly, observe that sizeof() can be called successfully on pointer dereferences, as shown in lines 9 and 15. In this case, the size returned is the number of bytes for the referenced type, not the pointer. Line 9 will print that the size is 4, as that is the typical size for an int (which is the type of *iptr, also known as ival). Line 15 will print that the size is 1, given that *cptr (also known as cval) is a char. Consequently, the assertion on line 19 holds, as sizeof(*iptr) gets the size of an int, whereas sizeof(*cptr) is the size of a char.

Given that a pointer is a variable that stores an address, an intuitive follow-up question is whether or not a pointer can store the address of a pointer. The answer is yes, and this is common in a variety of circumstances that we will examine later in this Appendix. Code Listing A.10 illustrates an example of using pointers to pointers. Line 6 starts by declaring iptr (abbreviation of “integer pointer”) as an int* and making it point to ival. Line 7 takes this a step farther, making pptr (“pointer pointer”) be a pointer to a pointer to an int (int**), and initializing it to point to iptr; this initialization is correct, as pptr is pointing to an int*. Line 8 introduces the use of void with a pointer structure; specifically, the declaration indicates the vptr (“void pointer”) is a pointer to a pointer to a pointer to something, but the type of that something is unknown.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

/* Code Listing A.10:
   Multiple layers of indirection with pointers to pointers
 */

int ival = 10;
int *iptr = &ival;
int **pptr = &iptr;
void ***vptr = (void***) &pptr; // this is okay

/* Multiple layers of redirection to the same place */
printf ("%d = %d = %d\n", ival, *iptr, **pptr);
// NOT ALLOWED: printf ("%d\n", ***vptr);

/* The size of any pointer is always the same */
assert (sizeof (iptr) == sizeof (pptr));
assert (sizeof (iptr) == sizeof (vptr));

/* Just for the full, ridiculous effect */
assert (sizeof (char*) == sizeof (int******));
assert (sizeof (void*) == sizeof (double***));

Figure 10.3.4 illustrates the relationship of the pointers as declared in lines 5 – 8. Line 11 prints the value 10 multiple times by dereferencing the pointers as needed. Specifically, line 11 starts by printing ival directly, and the value of ival is 10. Then, the value of ival is printed again by dereferencing iptr; since iptr is an int* and the value of iptr is &ival, dereferencing it once (as *iptr) ends up at the int variable ival. Similarly, the value of ival is printed one more time, as pptr is dereferenced twice (**pptr); the first dereference * follows the arrow from pptr to iptr and the second * follows the arrow from iptr to ival.

Figure 10.3.4: The pointer structure of Code Listing A.10

The comment on line 12 indicates that we cannot simply dereference vptr three times to get the same value. The problem is that dereferencing requires knowing the type that we are pointing to. The void pointer type—regardless of how many layers of indirection are present—serves the same purpose in C as the Object class in Java; it acts as a catch-all type for passing around pointers. We could successfully dereference vptr by first casting it (i.e., by using ***((int***)vptr)).

Lines 14 – 20 highlight another key insight about pointers: All pointers have the same size. It is a very common misunderstanding to think that the type of the pointer (int* vs. char*) has some influence on the size of the pointer. This is not true. All pointers are allocated exactly the amount of space required to store an address on the target architecture. The pointer’s type is only important for dereferencing the pointer. Note that the assertion on line 20 also holds. A common misunderstanding is that void* either has no size or it points to nothing; neither statement is true (unless the pointer is specifically initialized to NULL, then the latter is true). The void* type means that we have a pointer variable and its size is the same as any other pointer, but we do not know the size of what it is pointing to. We can cast a void* to be any other type of pointer; doing so would indicate how to use the bytes being pointed to when dereferencing the pointer.