COHERENT manpages
This page displays the COHERENT manpage for pointer [C Language].
List of available manpages
Index
pointer -- C Language A pointer is an object whose value is the address of another object. The name ``pointer'' derives from the fact that its contents ``point to'' another object. A pointer may point to any type, complete or incomplete, including another pointer. It may also point to a function, or to nowhere. The term pointer type refers to the object of a pointer. The object to which a pointer points is called the referenced type. For example, an int * (``pointer to int'') is a pointer type; the referenced type is int. Constructing a pointer type from a referenced type is called pointer type derivation. The Null Pointer A pointer that points to nowhere is a null pointer. The macro NULL, which is defined in the header stdio.h, defines the null pointer. The null pointer is an integer constant with the value zero. It compares unequal to a pointer to any object or function. Declaring a Pointer To declare a pointer, use the indirection operator `*'. For example, the declaration int *pointer; declares that the variable pointer holds the address of an int-length object. Likewise, the declaration int **pointer; declares that pointer holds the address of a pointer whose contents, in turn, point to an int-length object. Failure to declare a function that returns a pointer will result in that function being implicitly declared as an int. This does not cause an error on microprocessors in which an int and a pointer have the same size; however, if you transport this code to a microprocessor in which an int consists of 16 bits and a pointer consists of 32 bits, the pointer will be truncated truncated to 16 bits and the program probably will fail. C allows pointers and integers to be compared or converted to each other without restriction. The COHERENT C compiler flags such conversions with the strict message integer pointer pun and comparisons with the strict message integer pointer comparison These problems should be corrected if you want your code to be portable to other computing environments. See C language for more information. Wild Pointers Pointers are omnipresent in C. C also allows you to use a pointer to read or write the object to which the pointer points; this is called pointer dereferencing. Because a pointer can point to any place within memory, it is possible to write C code that generates unpredictable results, corrupts itself, or even obliterates the operating system if running in unprotected mode. A pointer that aims where it ought not is called a wild pointer. When a program declares a pointer, space is set aside in memory for it. However, this space has not yet been filled with the address of an object. To fill a pointer with the address of the object you wish to access is called initializing it. A wild pointer, as often as not, is one that is not properly initialized. Normally, to initialize a pointer means to fill it with a meaningful address. For example, the following initializes a pointer: int number; int *pointer; . . . pointer = &number; The address operator `&' specifies that you want the address of an object rather than its contents. Thus, pointer is filled with the address of number, and it can now be used to access the contents of number. The initialization of a string is somewhat different than the initialization of a pointer to an integer object. For example, char *string = "This is a string." declares that string is a pointer to a char. It then stores the string literal This is a string in memory and fills string with the address of its first character. string can then be passed to functions to access the string, or you can step through the string by incrementing string until its contents point to the null character at the end of the string. Another way to initialize a pointer is to fill it with a value returned by a function that returns a pointer. For example, the code extern char *malloc(size_t variable); char *example; . . . example = malloc(50); uses the function malloc to allocate 50 bytes of dynamic memory and then initializes example to the address that malloc returns. Reading What a Pointer Points To The indirection operator `*' can be used to read the object to which a pointer points. For example, int number; int *pointer; . . . pointer = &number; . . . printf("%d\n", *pointer); uses pointer to access the contents of number. When a pointer points to a structure, the elements within the structure can be read by using the structure offset operator `->'. See the entry for operators for more information. Pointers to Functions A pointer can also contain the address of a function. For example, char *(*example)(); declares example to be a pointer to a function that returns a pointer to a char. This declaration is quite different from: char **different(); The latter declares that different is a function that returns a pointer to a pointer to a char. The following demonstrates how to call a function via a pointer: (*example)(arg1, arg2); Here, the `*' takes the contents of the pointer, which in this case is the address of the function, and uses that address to pass to a function its list of arguments. A pointer to a function can be passed as an argument to another function. The functions bsearch and qsort each take a function pointer as an argument. A program may also use arrays of pointers to functions. void * void * is the generic pointer; it replaces char * in that role. A pointer may be cast to void * and then back to its original type without any change in its value. void * is also aligned for any type in the execution environment. Please note that COHERENT's C compiler does not yet recognize the type void *. In Kernighan and Ritchie C, character pointers are equivalent to void *. To convert a program to use void *, rewrite the sources so that instances of char *foo(bar); is replaced by: VOID_T *foo(bar); Be sure that you do not replace legitimate char *s -- that is, pointers that actually point to character strings. Then put the code #if defined(__ANSI__) || defined(__GNUC__) typedef void VOID_T #else typedef char VOID_T #endif into an application-owned header file that is included by every source file. Pointer Conversion One type of pointer may be converted, or cast, to another. For example, a pointer to a char may be cast to a pointer to an int, and vice versa. The ANSI Standard states that any pointer can be cast to type void * and back again without its value being affected in any way. (Once again, please note that COHERENT's C compiler does not yet recognize the type void *.) Likewise, any pointer of a scalar type may be cast to its corresponding const or volatile version. The qualified pointers are equivalent to their unqualified originals. Pointers to different data types are compatible in expressions, but only if they are cast appropriately. Using them without casting produces a pointer-type mismatch. The translator should produce a diagnostic message when it detects this condition. Pointer Arithmetic Arithmetic may be performed on all pointers to scalar types, i.e., pointers to chars or int. Pointer arithmetic is quite limited and consists of the following: 1. One pointer may be subtracted from another. 2. An int or a long, either variable or constant, may be added to a pointer or subtracted from it. 3. The operators ++ or -- may be used to increment or decrement a pointer. No other pointer arithmetic is permitted. No arithmetic can be performed on pointers to non-scalar objects, e.g., pointers to functions. When an int or long is added to a pointer, it is first multiplied by the length of what the pointer is declared as pointing to. Thus, if a pointer to an int is incremented by two, it points down two more ints, not two more characters. The following program demonstrates this feature: char *pc = "Welcome"; int array[5] = { 1, 2, 3, 4, 5 }; int *pi = array; main() { pc += 2; /* pc points to 'l' */ pi += 2; /* pi points to 3 */ } See Also C language data formats operators, portability, Programming COHERENT ANSI Standard, §6.1.2.5, §6.2.2.1, §6.2.2.3, §6.3.2.2- 3, §6.5.4.1