C h a p t e r 5 : P o i n t e r s
129 gets(s1); gets(s2); if(isalpha(*s1)) check(s1, s2, strcmp); else check(s1, s2, numcmp);
} return 0; void check(char *a, char *b, int (*cmp)(const char *, const char *))
{ printf("Testing for equality.\n"); if(!(*cmp)(a, b)) printf("Equal"); else printf("Not Equal");
} int numcmp(const char *a, const char *b)
{ if(atoi(a)==atoi(b)) return 0; else return 1;
}
In this program, if you enter a letter, strcmp( ) is passed to check( ). Otherwise,
numcmp( )
is used. Since check( ) calls the function that it is passed, it can use different comparison functions in different cases.
C's Dynamic Allocation Functions
Pointers provide necessary support for C/C++'s dynamic allocation system. Dynamic
allocation is the means by which a program can obtain memory while it is running.
As you know, global variables are allocated storage at compile time. Local variables use the stack. However, neither global nor local variables can be added during program execution. Yet there will be times when the storage needs of a program cannot be known ahead of time. For example, a program might use a dynamic data structure, such as a linked list or binary tree. Such structures are inherently dynamic in nature, growing or shrinking as needed. To implement such a data structure requires that a program be able to allocate and free memory.
130
C + + : T h e C o m p l e t e R e f e r e n c e
C++ actually supports two complete dynamic allocation systems: the one defined by C and the one specific to C++. The system specific to C++ contains several improvements over that used by C, and this approach is discussed in Part Two.
Here, C's dynamic allocation functions are described.
Memory allocated by C's dynamic allocation functions is obtained from the
heap—the region of free memory that lies between your program and its permanent storage area and the stack. Although the size of the heap is unknown, it generally contains a fairly large amount of free memory.
The core of C's allocation system consists of the functions malloc( ) and free( ).
(Most compilers supply several other dynamic allocation functions, but these two are the most important.) These functions work together using the free memory region to establish and maintain a list of available storage. The malloc( ) function allocates memory and the free( ) function releases it. That is, each time a malloc( ) memory request is made, a portion of the remaining free memory is allocated. Each time a
free( )
memory release call is made, memory is returned to the system. Any program that uses these functions should include the header file stdlib.h. (A C++ program may also use the C++-style header <cstdlib>.)
The malloc( ) function has this prototype: void *malloc(size_t number_of_bytes);
Here, number_of_bytes is the number of bytes of memory you wish to allocate. (The type size_t is defined in stdlib.h as, more or less, an unsigned integer.) The malloc( ) function returns a pointer of type void *, which means that you can assign it to any type of pointer. After a successful call, malloc( ) returns a pointer to the first byte of the region of memory allocated from the heap. If there is not enough available memory to satisfy the malloc( ) request, an allocation failure occurs and malloc( ) returns a null.
The code fragment shown here allocates 1,000 bytes of contiguous memory: char *p; p = malloc(1000); /* get 1000 bytes */
After the assignment, p points to the start of 1,000 bytes of free memory.
In the preceding example, notice that no type cast is used to assign the return value of malloc( ) to p. In C, a void * pointer is automatically converted to the type of the pointer on the left side of an assignment. However, it is important to understand that this automatic conversion does not occur in C++. In C++, an explicit type cast is needed when a void * pointer is assigned to another type of pointer. Thus, in C++, the preceding assignment must be written like this:
