Memory. Memory Topics. Passing by Value. Passing by Reference. Dynamic Memory Allocation. Passing a Pointer to a Pointer. Related Memory Functions

Transcription

1 Memory Memory Memory Topics Passing by Value Passing by Reference Dynamic Memory Allocation Passing a Pointer to a Pointer Related Memory Functions Memory file:///c /Documents%20and%20Settings/Jack%20Straub/My...hool%20Work/AdvancedC/Binders/040Memory/110Memory.html [3/29/2008 9:57:45 AM]

2 Memory Memory Passing by Value A copy of the value is passed. Memory file:///c /Documents%20and%20Settings/Jack%20Straub/My...20Work/AdvancedC/Binders/040Memory/120PassByValue.html [3/29/2008 9:57:45 AM]

3 Memory Memory Passing by Reference A pointer to the value is passed. Memory file:///c /Documents%20and%20Settings/Jack%20Straub/My%...ork/AdvancedC/Binders/040Memory/130PassByReference.html [3/29/2008 9:57:45 AM]

4 Memory Memory Dynamic Memory Allocation void *malloc( size_t size ); Allocates size bytes of memory on the heap. Memory must be released by calling free. MIGHT return NULL if size equals 0. Returns NULL on failure. void *calloc( size_t count, size_t size ); Allocates size * count bytes of memory on the heap. Convenient for allocating arrays. Memory initialized to binary 0. Memory must be released by calling free. MIGHT return NULL if size or count equal 0. Returns NULL on failure. Memory file:///c /Documents%20and%20Settings/Jack%20Straub/My...hool%20Work/AdvancedC/Binders/040Memory/140malloc.html [3/29/2008 9:57:45 AM]

5 Memory Memory Dynamic Memory Allocation void *realloc( void *old_ptr, size_t size ); Resizes (to size) memory indicated by old_ptr. If old_ptr equals 0 works like malloc. If size equals 0 old_ptr is freed and NULL is returned. Memory must be released (usually by calling free). MIGHT return a pointer to a new area. MIGHT return NULL if size or count equal 0. Returns NULL on failure. void free( void *ptr ); Frees the (previously allocated) memory indicated by ptr. Memory file:///c /Documents%20and%20Settings/Jack%20Straub/My...ool%20Work/AdvancedC/Binders/040Memory/150realloc.html [3/29/2008 9:57:46 AM]

6 Memory Memory Common Errors Forgetting to check for allocation failure. Reading from initialized memory. Forgetting to free memory. Freeing the same block of memory more than once. Reading/writing beyond the end of a memory block. Assumptions about zero-initialization, e.g.: A pointer initialized to binary 0 may be invalid. A floating point variable initialized to binary 0 may not be a valid number. Reallocating a position-dependent structure. Fragmenting memory (this is a concern, not really an error). Memory file:///c /Documents%20and%20Settings/Jack%20Straub/My...0Work/AdvancedC/Binders/040Memory/160CommonErrors.html [3/29/2008 9:57:46 AM]

7 Memory Memory Position Dependence (continued...) Memory file:///c /Documents%20and%20Settings/Jack%20Straub/My%.../AdvancedC/Binders/040Memory/170PositionDependence.html [3/29/2008 9:57:46 AM]

8 Memory Memory Position Dependence (continued) Memory file:///c /Documents%20and%20Settings/Jack%20Straub/My%.../AdvancedC/Binders/040Memory/180PositionDependence.html [3/29/2008 9:57:46 AM]

9 Memory Memory Passing a Pointer-to-Pointer Memory file:///c /Documents%20and%20Settings/Jack%20Straub/My%...rk/AdvancedC/Binders/040Memory/190PointerToPointer.html [3/29/2008 9:57:47 AM]

10 Memory Memory Related Memory Functions int memcmp( const void *ptr1, const void *ptr2, size_t len ); Compares the first len bytes in two blocks of memory; similar to strcmp. void *memcpy( void *dst, const void *src, size_t len ); Copies len bytes from src to dst. Returns dst. May not be safe if src and dst overlap. void *memmove( void *dst, const void *src, size_t len ); Copies len bytes from src to dst. Returns dst. Guaranteed safe if src and dst overlap. Memory file:///c /Documents%20and%20Settings/Jack%20Straub/My...School%20Work/AdvancedC/Binders/040Memory/200Misc.html [3/29/2008 9:57:47 AM]

11 Memory Memory Memory Management Tools A variety of tools are available to assist in detecting and isolating memory leaks and similar problems, such as memory overruns, reading from uninitialized memory and freeing memory that has never been allocated; see the Linux Journal Article. Valgrind Rational Purify SmartHeap HeapAgent BoundsChecker Visual C++ (look for _CrtMemCheckpoint in your index) Dmalloc ccmalloc NJAMD YAMD mpatrol Insure++ See also Balancing a Binary Tree: Checking for Memory Leaks. Memory file:///c /Documents%20and%20Settings/Jack%20Straub/My...chool%20Work/AdvancedC/Binders/040Memory/210Tools.html [3/29/2008 9:57:47 AM]

12 Arrays and Pointers Arrays and Pointers Arrays and Pointers Topics Conversion to Pointer Array of Arrays Array of Pointers Multidimensional Arrays Arrays and Pointers file:///c /Documents%20and%20Settings/Jack%20Straub/My%2...C/Binders/050ArraysAndPointers/110ArraysAndPointers.html [3/29/2008 9:57:47 AM]

13 Arrays and Pointers Arrays and Pointers Conversion to Pointer An array identifier is converted to a pointer to the array's first element: When the identifier is used as an argument to a function; When the identifier is used in an expression. Exception: When an array identifier is used as the argument of the sizeof operator no conversion takes place; the result is the size of the entire array. static void funk( int *farg /* Could also use int farg[] */ ); int main( int argc, char **argv ) int arr[10] = 10, 20, 30, 40, 50 ; int *parr = arr; printf( "sizeof(arr) = %u, sizeof(parr) = %u\n", sizeof(arr), sizeof(parr) ); funk( arr ); return EXIT_SUCCESS; static void funk( int *farg ) printf( "sizeof(farg) = %u, *farg = %d\n", sizeof(farg), *farg ); sizeof(arr) = 40, sizeof(parr) = 4 sizeof(farg) = 4, *farg = 10 Arrays and Pointers file:///c /Documents%20and%20Settings/Jack%20Straub/My%2...Binders/050ArraysAndPointers/120ConversionToPointer.html [3/29/2008 9:57:48 AM]

14 Arrays and Pointers Arrays and Pointers Conversion to Pointer Given an array of some type: type arr[n]; the expression arr[inx] is converted to: *(arr + inx) Example: int main( int argc, char **argv ) int arr[10] = 10, 20, 30, 40, 50 ; printf( "arr[3] = %d, 3[arr] = %d\n", arr[3], 3[arr] ); return EXIT_SUCCESS; arr[3] = 40, 3[arr] = 40 Arrays and Pointers file:///c /Documents%20and%20Settings/Jack%20Straub/My%2...Binders/050ArraysAndPointers/130ConversionToPointer.html [3/29/2008 9:57:48 AM]

15 Arrays and Pointers Arrays and Pointers Array of Arrays Arrays and Pointers file:///c /Documents%20and%20Settings/Jack%20Straub/My%2...ncedC/Binders/050ArraysAndPointers/140ArrayOfArrays.html [3/29/2008 9:57:48 AM]

16 Arrays and Pointers Arrays and Pointers Array of Pointers continued... Arrays and Pointers file:///c /Documents%20and%20Settings/Jack%20Straub/My%2...edC/Binders/050ArraysAndPointers/150ArrayOfPointers.html [3/29/2008 9:57:48 AM]

17 Arrays and Pointers Arrays and Pointers Array of Pointers (continued) int main( int argc, char **argv ) char *carrp[2] = "big", "pony" ; int iarr1[4] = -1, -2, -3, -4 ; int iarr2[5] = 1, 2, 3, 4, 5 ; int *iarrp[2] = iarr1, iarr2 ; printf( "%s, %s\n", carrp[0], carrp[1] ); printf( "%d, %d\n", iarrp[0][0], iarrp[1][0] ); printf( "%d, %d\n", iarrp[0][3], iarrp[1][4] ); return EXIT_SUCCESS; big, pony -1, 1-4, 5 Arrays and Pointers file:///c /Documents%20and%20Settings/Jack%20Straub/My%2...edC/Binders/050ArraysAndPointers/160ArrayOfPointers.html [3/29/2008 9:57:49 AM]

18 Arrays and Pointers Arrays and Pointers Multidimensional Arrays Arrays in C are row-major: The outermost index varies most quickly; Elements associated with the outermost index are stored in memory first; When a function parameter is declared as a multidimensional array you must declare the extent of each dimension except the first. static void funk( int arr[][5][7], int count ); int main( int argc, char **argv ) int iarr[3][5][7]; funk( iarr, 3 ); return EXIT_SUCCESS; static void funk( int arr[][5][7], int count ) int inx = 0; int jnx = 0; int knx = 0; int xxx = 0; /* To process an array most efficiently and avoid * unnecessary memory swapping, access the array in * order; that is, vary the rightmost index fastest. */ for ( inx = 0 ; inx < count ; ++inx ) for ( jnx = 0 ; jnx < 5 ; ++jnx ) for ( knx = 0 ; knx < 7 ; ++knx ) if ( xxx++ % 10 == 0 ) puts( "" ); printf( "%p ", &arr[inx][jnx][knx] ); 0x22cb30 0x22cb34 0x22cb38 0x22cb3c 0x22cb40 0x22cb44 0x22cb48 0x22cb4c 0x22cb50 0x22cb54 0x22cb58 0x22cb5c 0x22cb60 0x22cb64 0x22cb68 0x22cb6c 0x22cb70 0x22cb74 0x22cb78 0x22cb7c 0x22cb80 0x22cb84 0x22cb88 0x22cb8c 0x22cb90 0x22cb94 0x22cb98 0x22cb9c 0x22cba0 0x22cba4 0x22cba8 0x22cbac 0x22cbb0 0x22cbb4 0x22cbb8 0x22cbbc 0x22cbc0 0x22cbc4 0x22cbc8 0x22cbcc 0x22cbd0 0x22cbd4 0x22cbd8 0x22cbdc 0x22cbe0 0x22cbe4 0x22cbe8 0x22cbec 0x22cbf0 0x22cbf4 0x22cbf8 0x22cbfc 0x22cc00 0x22cc04 0x22cc08 0x22cc0c 0x22cc10 0x22cc14 0x22cc18 0x22cc1c 0x22cc20 0x22cc24 0x22cc28 0x22cc2c 0x22cc30 0x22cc34 0x22cc38 0x22cc3c 0x22cc40 0x22cc44 0x22cc48 0x22cc4c 0x22cc50 0x22cc54 0x22cc58 0x22cc5c 0x22cc60 0x22cc64 0x22cc68 0x22cc6c 0x22cc70 0x22cc74 0x22cc78 0x22cc7c 0x22cc80 0x22cc84 0x22cc88 0x22cc8c 0x22cc90 0x22cc94 0x22cc98 0x22cc9c 0x22cca0 0x22cca4 0x22cca8 0x22ccac 0x22ccb0 0x22ccb4 0x22ccb8 0x22ccbc 0x22ccc0 0x22ccc4 0x22ccc8 0x22cccc 0x22ccd0 file:///c /Documents%20and%20Settings/Jack%20Straub/M...s/050ArraysAndPointers/170MultidimensionalArrays.html (1 of 2) [3/29/2008 9:57:49 AM]

19 Arrays and Pointers Arrays and Pointers file:///c /Documents%20and%20Settings/Jack%20Straub/M...s/050ArraysAndPointers/170MultidimensionalArrays.html (2 of 2) [3/29/2008 9:57:49 AM]

20 Arrays and Pointers Arrays and Pointers Multidimensional Arrays The subscript operator is left-to-right associative: arr[n0][n1][n2] ==> *(arr[n0][n1] + n2) ==> *(*(arr[n0] + n1) + n2) ==> *(*(*(arr + n0) + n1) + n2) Arrays and Pointers file:///c /Documents%20and%20Settings/Jack%20Straub/My%2...ders/050ArraysAndPointers/180MultidimensionalArrays.html [3/29/2008 9:57:49 AM]

21 Arrays and Pointers Arrays and Pointers Multidimensional Arrays Given an array: type arr[a0][a1][a2]; From the compiler's perspective, the address of element arr[n0][n1][n2] Is calculated using the formula: arr + (n0*a1*a2 + n1*a2 + n2) * sizeof(type) Note that the address is independent of A0. int main( int argc, char **argv ) int arr[3][5][7]; void *ptr = NULL; arr[1][2][4] = 17; ptr = (char *)arr + (1*5*7 + 2*7 + 4) * sizeof(int); printf( "%d, %d\n", arr[1][2][4], *(int *)ptr ); return EXIT_SUCCESS; Arrays and Pointers file:///c /Documents%20and%20Settings/Jack%20Straub/My%2...ders/050ArraysAndPointers/190MultidimensionalArrays.html [3/29/2008 9:57:50 AM]

22 Storage Classes and Type Qualifiers Storage Classes and Type Qualifiers Storage Classes and Type Qualifiers Topics Storage Classes Type Specifiers Storage Classes and Type Qualifiers file:///c /Documents%20and%20Settings/Jack%20Straub/My%...cedC/Binders/060ClassesAndTypes/110ClassesAndTypes.html [3/29/2008 9:57:50 AM]

23 Storage Classes and Type Qualifiers Storage Classes and Type Qualifiers Storage Classes auto extern register static typedef Storage Classes and Type Qualifiers file:///c /Documents%20and%20Settings/Jack%20Straub/My%2...ork/AdvancedC/Binders/060ClassesAndTypes/120Classes.html [3/29/2008 9:57:50 AM]

24 Storage Classes and Type Qualifiers Storage Classes and Type Qualifiers Automatic (auto) Storage Class Only variables declared within blocks may have this storage class. This is the default for variables declared within blocks, so the auto keyword is rarely seen. Storage for automatic variable is allocated every time the declaring block is entered. Storage Classes and Type Qualifiers file:///c /Documents%20and%20Settings/Jack%20Straub/My%...0Work/AdvancedC/Binders/060ClassesAndTypes/130Auto.html [3/29/2008 9:57:50 AM]

25 Storage Classes and Type Qualifiers Storage Classes and Type Qualifiers External (extern) Storage Class An extern declaration may occur anywhere, but is most often found in the global declaration area. extern is the default for globally declared variables extern is the default for functions. References to external variable and function names are resolved by the linker. For any extern variable: There must be one defining declaration; There may be many referencing declarations. For an external variable in any environment: A defining declaration is a global declaration that omits the extern keyword and gives the variable an initial value. A referencing declaration includes the extern keyword and does not give the variable an initial value. Defining declarations must occur in a source (.c) file. Referencing declarations should occur in a header (.h) file. The result of having two defining instances of a single external variable is undefined and environment dependent. Storage Classes and Type Qualifiers file:///c /Documents%20and%20Settings/Jack%20Straub/My%...ork/AdvancedC/Binders/060ClassesAndTypes/140Extern.html [3/29/2008 9:57:51 AM]

26 Storage Classes and Type Qualifiers Storage Classes and Type Qualifiers External (extern) Storage Class module.h #ifndef MODULE_H #define MODULE_H extern int factor_g; #endif module.c #include <module.h> int factor_g = 3; void funka( void )... source1.c #include <module.h> void funk1a( void ) int radius = 3 * factor_g;... source2.c #include <module.h> void funk2a( void ) int height = 3 * factor_g;... Storage Classes and Type Qualifiers file:///c /Documents%20and%20Settings/Jack%20Straub/My%...ork/AdvancedC/Binders/060ClassesAndTypes/150Extern.html [3/29/2008 9:57:51 AM]

27 Storage Classes and Types Storage Classes and Types static Storage Class Used in the global area static overrides the default storage class (extern) for a variable or function declaration. Used in a block static overrides the default storage class (auto) for a variable declaration. Storage for a static variable is allocated once. sourc1.c static int num_ = 3; static void print_err( void )... source2.c static double num_ = 2.4; static void print_err( void )... source3.c static char *num_ = "118"; static void print_err( int errnum )... source4.c static short num_ = "127"; static int print_err( char *error )... Storage Classes and Types file:///c /Documents%20and%20Settings/Jack%20Straub/My%...ork/AdvancedC/Binders/060ClassesAndTypes/160Static.html [3/29/2008 9:57:51 AM]

28 Storage Classes and Type Qualifiers Storage Classes and Type Qualifiers register Storage Class This storage class may be applied only to function parameters and block-level variables. register implies auto. You may not compute the address of a register variable. register is a "hint" to the compiler that a variable should be stored in a hardware register. The compiler may ignore the hint; it may limit the number of allowed register variables, and may limit the types of variables that can be stored in a register (int is always allowed). static void funk( void ) register int inx = 0; for ( inx = 0 ; inx < ; ++inx )... Storage Classes and Type Qualifiers file:///c /Documents%20and%20Settings/Jack%20Straub/My%2...rk/AdvancedC/Binders/060ClassesAndTypes/170Register.html [3/29/2008 9:57:51 AM]

29 Storage Classes and Type Qualifiers Storage Classes and Type Qualifiers typedef Storage Class This storage class specifier indicates that an identifier is a data type rather than a variable or a function. A typedef declaration never allocates storage. typedef int BOOL_t; Storage Classes and Type Qualifiers file:///c /Documents%20and%20Settings/Jack%20Straub/My%...rk/AdvancedC/Binders/060ClassesAndTypes/180Typedef.html [3/29/2008 9:57:52 AM]

30 Storage Classes and Type Qualifiers Storage Classes and Type Qualifiers const Type Qualifier Any variable or function parameter may be declared to be type const. This type qualifier tells the compiler that the value of a variable or parameter will not be changed. The compiler cannot guarantee that a const storage location will not be modified. With respect to pointers: const type *ptr; Declares a pointer to a constant type. (The storage indicated by ptr may or may not be const; in either case ptr may not be used to modify the storage.) type *const ptr; Declares a constant pointer to a (non-constant) type. (ptr may be used to modify whatever it points to, but ptr itself may not be changed.) int main ( int argc, char **argv ) char str[] = "go dog, go!"; const char *pcstr = str; char *const cpstr = str; char alpha = '\000'; *pcstr++ = 'A'; /* NOT ALLOWED */ alpha = *pcstr++; /* ALLOWED */ *cpstr = 'B'; /* ALLOWED */ *cpstr++ = 'B'; /* NOT ALLOWED */ return EXIT_SUCCESS; Storage Classes and Type Qualifiers file:///c /Documents%20and%20Settings/Jack%20Straub/My%...Work/AdvancedC/Binders/060ClassesAndTypes/200Const.html [3/29/2008 9:57:52 AM]

31 Storage Classes and Type Qualifiers Storage Classes and Type Qualifiers volatile Type Qualifier This type qualifier may be used with any variable declaration. A declaration of volatile tells the compiler that the value of the designated variable may change in unexpected way, and therefore is ineligible for certain types of optimization. volatile is used only in esoteric applications and you may very well never need it. void funk( void ) /* pregister is a pointer to a hardware register * that can change at any time. */ volatile short *pregister = (short *) ;... Storage Classes and Type Qualifiers file:///c /Documents%20and%20Settings/Jack%20Straub/My%2...rk/AdvancedC/Binders/060ClassesAndTypes/210Volatile.html [3/29/2008 9:57:52 AM]

32 Topics Functions Pointers to Functions Passing Returning file:///c /Documents%20and%20Settings/Jack%20Straub/My%20...cedC/Binders/070FunctionPointers/110FunctionPointers.html [3/29/2008 9:57:53 AM]

33 Functions The type of a function is the type of value it returns in conjunction with the number and type of its parameters. /* Function type: * function having int, char* and double parameters * and returning type unsigned int. */ unsigned funk( int, char*, double ); The return type of a function may be anything except: array; and function (A function may return a pointer to an array or a pointer to a function.) typedef unsigned FUNC_TYPE_t( int, char*, double ); typedef FUNC_TYPE_t *FUNC_TYPE_p_t; int[4] funk1( void ); /* NOT ALLOWED: returning array */ int *funk2( void ); /* ALLOWED: returning pointer to array */ FUNC_TYPE_t funk3( void ); /* NOT ALLOWED: returning function */ FUNC_TYPE_p_t funk4( void ); /* ALLOWED: returning pointer to function */ A function may be called or invoked by appending the function operator to the function name and enclosing arguments the number and type of which correspond to the type of the function. int funke( int, const char*, double ); int inx = funke( 5, "spot", 3.14 ); (continued...) file:///c /Documents%20and%20Settings/Jack%20Straub/My%2.../AdvancedC/Binders/070FunctionPointers/120Functions.html [3/29/2008 9:57:53 AM]

34 Functions (continued) The name of a function may be assigned to a pointer of the appropriate type, in which case the function name is converted to the address of the function. int funke( int, const char*, double ); int (*fp1)( int, const char*, double ) = funke; /* ALLOWED */ int (*fp2)( const char*, double ) = funke; /* NOT ALLOWED */ char *fp3 = funke; /* NOT ALLOWED */ The name of a function may be used as an argument to another function provided its type matches the type of the corresponding function parameter; in this case the name of the function is converted to the address of the function. int funke( int parm1, int (*parm2)( int, const char*, double ) ); int funkf( int, const char*, double ); void funkg( int, const char*, double ); int inx = funke( 5, funkf ); /* ALLOWED */ int jnx = funke( 5, funkg ); /* NOT ALLOWED */ The name of a function may not be used as the operand of the sizeof operator. The address of a function may not be converted to a void pointer. int funke( int, const char*, double ); size_t inx = sizeof(funke); /* NOT ALLOWED */ void *ptr = funke; /* NOT ALLOWED */ file:///c /Documents%20and%20Settings/Jack%20Straub/My%2.../AdvancedC/Binders/070FunctionPointers/130Functions.html [3/29/2008 9:57:53 AM]

35 Interpreting Declarations: the Right to Left Rule 1. Find the identifier. 2. Move to the right identifying operators and types until you hit a right parenthesis, an equal sign, or the end of the expression. (Note: a left parenthesis at this point denotes the start of the function operator; the matching right parenthesis is the end of the function operator, not a stopping point.) 3. Move to the left of the identifier, interpreting types and operators until you hit the beginning of the expression, or a left parenthesis. 4. Continue to the right where you left off. int inx = 0; ^ inx is... ^ an int int *pinx = NULL; ^ pinx is... ^ a pointer... ^ to an int int funk( void ); ^ funk is... ^------^ a function ^ returning int int (*funk)( void ); ^ funk is... file:///c /Documents%20and%20Settings/Jack%20Straub/M...C/Binders/070FunctionPointers/140RightToLeftRule.html (1 of 2) [3/29/2008 9:57:54 AM]

36 ^ a pointer... ^------^ to a function... ^ returning int (continued...) file:///c /Documents%20and%20Settings/Jack%20Straub/M...C/Binders/070FunctionPointers/140RightToLeftRule.html (2 of 2) [3/29/2008 9:57:54 AM]

37 Interpreting Declarations: the Right to Left Rule (continued) void (*signal(int sig, void (*func)(int)))(int); ^ signal is... ^ ^ a function... ^ returning a pointer... ^---^ to a function... ^ returning void More specifically: void (*signal(int sig, void (*func)(int)))(int); ^ signal is... ^ ^ a function... ^ whose first parameter is an int... ^ and whose second parameter... ^ is a pointer... ^---^ to a function... ^ that has one int parameter... ^ and returns void ^ the return type of signal is a pointer... ^---^ to a function... ^ that has one int parameter... ^ and returns void file:///c /Documents%20and%20Settings/Jack%20Straub/My%2...cedC/Binders/070FunctionPointers/150RightToLeftRule.html [3/29/2008 9:57:54 AM]

38 A Better Way "Signal is a function that returns... [a pointer to a function with an int parameter that return void]... Signal has [an int parameter]... and a parameter which is... [a pointer to a function with an int parameter that return void] /* Type: function with an int parameter * that returns void. */ typedef void SIGNAL_PROC_t( int ); /* Type: pointer to a function with an * int parameter that returns void. */ typedef SIGNAL_PROC_t *SIGNAL_PROC_p_t; SIGNAL_PROC_p_t signal( int, SIGNAL_PROC_p_t ); (continued...) file:///c /Documents%20and%20Settings/Jack%20Straub/My%...dvancedC/Binders/070FunctionPointers/160ABetterWay.html [3/29/2008 9:57:54 AM]

39 A Better Way (continued) /* Instead of this */ struct test_descriptor int args[10]; int num_args; int result; int (*test_proc)( int *args, int num_args ); ; static int test01( int *args, int num_args ); static int test02( int *args, int num_args );... static int test20( int *args, int num_args ); /* Try this */ typedef int TEST_PROC_t( int *args, int num_args ); typedef TEST_PROC_t *TEST_PROC_p_t; struct test_descriptor int args[10]; int num_args; int result; TEST_PROC_p_t test_proc; ; static TEST_PROC_t test01; static TEST_PROC_t test02;... static TEST_PROC_t test20; file:///c /Documents%20and%20Settings/Jack%20Straub/My%...dvancedC/Binders/070FunctionPointers/170ABetterWay.html [3/29/2008 9:57:54 AM]

40 Usually point to a block of memory containing information about how to invoke a function. May not be used in pointer arithmetic. file:///c /Documents%20and%20Settings/Jack%20Straub/My%20...cedC/Binders/070FunctionPointers/180FunctionPointers.html [3/29/2008 9:57:55 AM]

41 Using typedef int TEST_PROC_t( void ); typedef TEST_PROC_t *TEST_PROC_p_t; typedef struct test_desc_s const char *description; TEST_PROC_p_t proc; TEST_DESC_t, *TEST_DESC_p_t; static TEST_PROC_t test01; static TEST_PROC_t test02; static TEST_PROC_t test03; static TEST_DESC_t all_tests_[] = "This is test #1", test01, "This is test #2", test02, "This is test #3", test03 ; static num_tests_ = sizeof(all_tests_)/sizeof(*all_tests_); int main( int argc, char **argv ) int result = EXIT_SUCCESS; TEST_DESC_p_t test = all_tests_; int inx = 0; for ( inx = 0 ; inx < num_tests_ && result == EXIT_SUCCESS ; ++inx ) printf( "%s... ", test[inx].description ); if ( test[inx].proc() ) printf( "SUCCESS\n" ); else printf( "FAILURE\n" ); result = EXIT_FAILURE; return result; static int test01( void ) return 1; static int test02( void ) file:///c /Documents%20and%20Settings/Jack%20Straub/My...ders/070FunctionPointers/190UsingFunctionPointers.html (1 of 2) [3/29/2008 9:57:55 AM]

42 return 1; static int test03( void ) return 1; $./a This is test #1... SUCCESS This is test #2... SUCCESS This is test #3... SUCCESS file:///c /Documents%20and%20Settings/Jack%20Straub/My...ders/070FunctionPointers/190UsingFunctionPointers.html (2 of 2) [3/29/2008 9:57:55 AM]

43 Passing static int sensitive_sort( const void*, const void* ); static int insensitive_sort( const void*, const void* ); static char *names_[] = "TOM", "dick", "harry" ; static size_t num_names_ = sizeof(names_)/sizeof(*names_); int main( int argc, char **argv ) int result = EXIT_SUCCESS; int (*sort)( const void*, const void* ) = NULL; if ( argc!= 2 ) usage(); result = EXIT_FAILURE; else if ( strcmp( argv[1], "case-sensitive" ) ) sort = sensitive_sort; else if ( strcmp( argv[1], "case-insensitive" ) ) sort = insensitive_sort; else usage(); result = EXIT_FAILURE; if ( result == EXIT_SUCCESS ) qsort( names_, num_names_, sizeof(char*), sort ); print_names(); return result; /* perform a case-sensitive comparison of two names */ static int sensitive_sort( const void *name1, const void *name2 ) file:///c /Documents%20and%20Settings/Jack%20Straub/My...rs/070FunctionPointers/200PassingFunctionPointers.html (1 of 2) [3/29/2008 9:57:55 AM]

44 ... /* perform a case-insensitive comparison of two names */ static int insensitive_sort( const void *name1, const void *name2 )... file:///c /Documents%20and%20Settings/Jack%20Straub/My...rs/070FunctionPointers/200PassingFunctionPointers.html (2 of 2) [3/29/2008 9:57:55 AM]

45 Returning static void log_stderr( const char *,... ); static void log_syslog( const char *,... ); static void (*set_log( int argc, char **argv ))( const char *,... ); int main( int argc, char **argv ) int result = EXIT_SUCCESS; void (*log)( const char*,... ) = set_log( arg, argv ); funk1( log );... return result; static void (*set_log( int argc, char **argv ))( const char *,... ) void (*log)( const char*,... ) = log_syslog; if ( argc > 1 && strcmp( argv[1], "-debug" ) == 0 ) log = log_stderr; return log; file:///c /Documents%20and%20Settings/Jack%20Straub/My%20...ers/070FunctionPointers/210ReturningFunctionPointers.html [3/29/2008 9:57:56 AM]