C Function Pointer Assignment In C

On By In 1

A pointer is a value that designates the address (i.e., the location in memory), of some value. Pointers are variables that hold a memory location.

There are four fundamental things you need to know about pointers:

  • How to declare them (with the address operator '': )
  • How to assign to them ()
  • How to reference the value to which the pointer points (known as dereferencing, by using the dereferencing operator '': )
  • How they relate to arrays (the vast majority of arrays in C are simple lists, also called "1 dimensional arrays", but we will briefly cover multi-dimensional arrays with some pointers in a later chapter).

Pointers can reference any data type, even functions. We'll also discuss the relationship of pointers with text strings and the more advanced concept of function pointers.

Declaring pointers[edit]

Consider the following snippet of code which declares two pointers:


Lines 1-4 define a structure. Line 8 declares a variable which points to an , and line 9 declares a variable which points to something with structure MyStruct. So to declare a variable as something which points to some type, rather than contains some type, the asterisk () is placed before the variable name.

In the following, line 1 declares as a pointer to a long and as a long and not a pointer to a long. In line 2, is declared as a pointer to a pointer to an int.


Pointer types are often used as parameters to function calls. The following shows how to declare a function which uses a pointer as an argument. Since C passes function arguments by value, in order to allow a function to modify a value from the calling routine, a pointer to the value must be passed. Pointers to structures are also used as function arguments even when nothing in the struct will be modified in the function. This is done to avoid copying the complete contents of the structure onto the stack. More about pointers as function arguments later.


Assigning values to pointers[edit]

So far we've discussed how to declare pointers. The process of assigning values to pointers is next. To assign the address of a variable to a pointer, the or 'address of' operator is used.


Here, pPointer will now reference myInt and pKeyboard will reference dvorak.

Pointers can also be assigned to reference dynamically allocated memory. The malloc() and calloc() functions are often used to do this.

#include<stdlib.h>/* ... */structMyStruct*pKeyboard;/* ... */pKeyboard=malloc(sizeof*pKeyboard);

The malloc function returns a pointer to dynamically allocated memory (or NULL if unsuccessful). The size of this memory will be appropriately sized to contain the MyStruct structure.

The following is an example showing one pointer being assigned to another and of a pointer being assigned a return value from a function.

staticstructMyStructval1,val2,val3,val4;structMyStruct*ASillyFunction(intb){structMyStruct*myReturn;if(b==1)myReturn=&val1;elseif(b==2)myReturn=&val2;elseif(b==3)myReturn=&val3;elsemyReturn=&val4;returnmyReturn;}structMyStruct*strPointer;int*c,*d;intj;c=&j;/* pointer assigned using & operator */d=c;/* assign one pointer to another */strPointer=ASillyFunction(3);/* pointer returned from a function. */

When returning a pointer from a function, do not return a pointer that points to a value that is local to the function or that is a pointer to a function argument. Pointers to local variables become invalid when the function exits. In the above function, the value returned points to a static variable. Returning a pointer to dynamically allocated memory is also valid.

Pointer dereferencing[edit]

To access a value to which a pointer points, the operator is used. Another operator, the operator is used in conjunction with pointers to structures. Here's a short example.

intc,d;int*pj;structMyStructastruct;structMyStruct*bb;c=10;pj=&c;/* pj points to c */d=*pj;/* d is assigned the value to which pj points, 10 */pj=&d;/* now points to d */*pj=12;/* d is now 12 */bb=&astruct;(*bb).m_aNumber=3;/* assigns 3 to the m_aNumber member of astruct */bb->num2=44.3;/* assigns 44.3 to the num2 member of astruct */*pj=bb->m_aNumber;/* equivalent to d = astruct.m_aNumber; */

The expression is entirely equivalent to . They both access the element of the structure pointed to by . There is one more way of dereferencing a pointer, which will be discussed in the following section.

When dereferencing a pointer that points to an invalid memory location, an error often occurs which results in the program terminating. The error is often reported as a segmentation error. A common cause of this is failure to initialize a pointer before trying to dereference it.

C is known for giving you just enough rope to hang yourself, and pointer dereferencing is a prime example. You are quite free to write code that accesses memory outside that which you have explicitly requested from the system. And many times, that memory may appear as available to your program due to the vagaries of system memory allocation. However, even if 99 executions allow your program to run without fault, that 100th execution may be the time when your "memory pilfering" is caught by the system and the program fails. Be careful to ensure that your pointer offsets are within the bounds of allocated memory!

The declaration is used to declare a pointer of some nonspecified type. You can assign a value to a void pointer, but you must cast the variable to point to some specified type before you can dereference it. Pointer arithmetic is also not valid with pointers.

Pointers and Arrays[edit]

Up to now, we've carefully been avoiding discussing arrays in the context of pointers. The interaction of pointers and arrays can be confusing but here are two fundamental statements about it:

  • A variable declared as an array of some type acts as a pointer to that type. When used by itself, it points to the first element of the array.
  • A pointer can be indexed like an array name.

The first case often is seen to occur when an array is passed as an argument to a function. The function declares the parameter as a pointer, but the actual argument may be the name of an array. The second case often occurs when accessing dynamically allocated memory. Let's look at examples of each. In the following code, the call to calloc() effectively allocates an array of struct MyStruct items.

floatKrazyFunction(structMyStruct*parm1,intp1size,intbb){intix;//declaring an integer variable//for(ix=0;ix<p1size;ix++){if(parm1[ix].m_aNumber==bb)returnparm1[ix].num2;}return0.0f;}/* ... */structMyStructmyArray[4];#define MY_ARRAY_SIZE (sizeof(myArray)/sizeof(*myArray))floatv3;structMyStruct*secondArray;intsomeSize;intix;/* initialization of myArray ... */v3=KrazyFunction(myArray,MY_ARRAY_SIZE,4);/* ... */secondArray=calloc(someSize,sizeof(myArray));for(ix=0;ix<someSize;ix++){secondArray[ix].m_aNumber=ix*2;secondArray[ix].num2=.304*ix*ix;}

Pointers and array names can pretty much be used interchangeably. There are exceptions. You cannot assign a new pointer value to an array name. The array name will always point to the first element of the array. In the function above, you could however assign a new value to parm1, as it is just a pointer to the first element of myArray. It is also valid for a function to return a pointer to one of the array elements from an array passed as an argument to a function. A function should never return a pointer to a local variable, even though the compiler will probably not complain.

When declaring parameters to functions, declaring an array variable without a size is equivalent to declaring a pointer. Often this is done to emphasize the fact that the pointer variable will be used in a manner equivalent to an array.

/* two equivalent function definitions */intLittleFunction(int*paramN);intLittleFunction(intparamN[]);

Now we're ready to discuss pointer arithmetic. You can add and subtract integer values to/from pointers. If myArray is declared to be some type of array, the expression , where j is an integer, is equivalent to . So for instance in the above example where we had the expression secondArray[i].num2, we could have written that as or more simply .

Note that for addition and subtraction of integers and pointers, the value of the pointer is not adjusted by the integer amount, but is adjusted by the amount multiplied by the size (in bytes) of the type to which the pointer refers. One pointer may also be subtracted from another, provided they point to elements of the same array (or the position just beyond the end of the array). If you have a pointer that points to an element of an array, the index of the element is the result when the array name is subtracted from the pointer. Here's an example.

structMyStructsomeArray[20];structMyStruct*p2;intidx;./* array initialization .. */.for(p2=someArray;p2<someArray+20;++p2){if(p2->num2>testValue)break;}idx=p2-someArray;

You may be wondering how pointers and multidimensional arrays interact. Let's look at this a bit in detail. Suppose A is declared as a two dimensional array of floats () and that pf is declared a pointer to a float. If pf is initialized to point to A[0][0], then *(pf+1) is equivalent to A[0][1] and *(pf+D2) is equivalent to A[1][0]. The elements of the array are stored in row-major order.

floatA[6][8];float*pf;pf=&A[0][0];*(pf+1)=1.3;/* assigns 1.3 to A[0][1] */*(pf+8)=2.3;/* assigns 2.3 to A[1][0] */

Let's look at a slightly different problem. We want to have a two dimensional array, but we don't need to have all the rows the same length. What we do is declare an array of pointers. The second line below declares A as an array of pointers. Each pointer points to a float. Here's some applicable code:

floatlinearA[30];float*A[6];A[0]=linearA;/* 5 - 0 = 5 elements in row */A[1]=linearA+5;/* 11 - 5 = 6 elements in row */A[2]=linearA+11;/* 15 - 11 = 4 elements in row */A[3]=linearA+15;/* 21 - 15 = 6 elements */A[4]=linearA+21;/* 25 - 21 = 4 elements */A[5]=linearA+25;/* 30 - 25 = 5 elements */*A[3][2]=3.66;/* assigns 3.66 to linearA[17]; */*A[3][-3]=1.44;/* refers to linearA[12]; negative indices are sometimes useful. But avoid using them as much as possible. */

We also note here something curious about array indexing. Suppose myArray is an array and idx is an integer value. The expression myArray[idx] is equivalent to idx[myArray]. The first is equivalent to *(myArray+idx), and the second is equivalent to *(idx+myArray). These turn out to be the same, since the addition is commutative.

Pointers can be used with preincrement or post decrement, which is sometimes done within a loop, as in the following example. The increment and decrement applies to the pointer, not to the object to which the pointer refers. In other words, *pArray++ is equivalent to *(pArray++).

longmyArray[20];long*pArray;inti;/* Assign values to the entries of myArray */pArray=myArray;for(i=0;i<10;++i){*pArray++=5+3*i+12*i*i;*pArray++=6+2*i+7*i*i;}

Pointers in Function Arguments[edit]

Often we need to invoke a function with an argument that is itself a pointer. In many instances, the variable is itself a parameter for the current function and may be a pointer to some type of structure. The ampersand character is not needed in this circumstance to obtain a pointer value, as the variable is itself a pointer. In the example below, the variable , a pointer, is a parameter to function , and is passed as an argument to . The second parameter to is an int. Since in function , is a pointer to an int, the pointer must first be dereferenced using the * operator, hence the second argument in the call is . The third parameter to function is a pointer to a long. Since is itself a pointer to a long, no ampersand is needed when it is used as the third argument to the function.

intFunctOne(structSomeStruct*pValue,intiValue,long*lValue){/* do some stuff ... */return0;}intFunctTwo(structsomeStruct*pStruct,int*mValue){intj;longAnArray[25];long*pAA;pAA=&AnArray[13];j=FunctOne(pStruct,*mValue,pAA);returnj;}

Pointers and Text Strings[edit]

Historically, text strings in C have been implemented as arrays of characters, with the last byte in the string being a zero, or the null character '\0'. Most C implementations come with a standard library of functions for manipulating strings. Many of the more commonly used functions expect the strings to be null terminated strings of characters. To use these functions requires the inclusion of the standard C header file "string.h".

A statically declared, initialized string would look similar to the following:

staticconstchar*myFormat="Total Amount Due: %d";

The variable can be viewed as an array of 21 characters. There is an implied null character ('\0') tacked on to the end of the string after the 'd' as the 21st item in the array. You can also initialize the individual characters of the array as follows:


An initialized array of strings would typically be done as follows:


The initialization of an especially long string can be split across lines of source code as follows.

staticchar*longString="Hello. My name is Rudolph and I work as a reindeer ""around Christmas time up at the North Pole. My boss is a really swell guy."" He likes to give everybody gifts.";

The library functions that are used with strings are discussed in a later chapter.

Pointers to Functions[edit]

C also allows you to create pointers to functions. Pointers to functions can get rather messy. Declaring a typedef to a function pointer generally clarifies the code. Here's an example that uses a function pointer, and a void * pointer to implement what's known as a callback. The function invokes a caller supplied function with caller data. Note that really doesn't know anything about what refers to.

typedefint(*MyFunctionType)(int,void*);/* a typedef for a function pointer */#define THE_BIGGEST 100intDoSomethingNice(intaVariable,MyFunctionTypeaFunction,void*dataPointer){intrv=0;if(aVariable<THE_BIGGEST){/* invoke function through function pointer (old style) */rv=(*aFunction)(aVariable,dataPointer);}else{/* invoke function through function pointer (new style) */rv=aFunction(aVariable,dataPointer);};returnrv;}typedefstruct{intcolorSpec;char*phrase;}DataINeed;intTalkJive(intmyNumber,void*someStuff){/* recast void * to pointer type specifically needed for this function */DataINeed*myData=someStuff;/* talk jive. */return5;}staticDataINeedsillyStuff={BLUE,"Whatcha talkin 'bout Willis?"};/* ... */DoSomethingNice(41,&TalkJive,&sillyStuff);

Some versions of C may not require an ampersand preceding the argument in the call. Some implementations may require specifically casting the argument to the type, even though the function signature exacly matches that of the typedef.

Function pointers can be useful for implementing a form of polymorphism in C. First one declares a structure having as elements function pointers for the various operations to that can be specified polymorphically. A second base object structure containing a pointer to the previous structure is also declared. A class is defined by extending the second structure with the data specific for the class, and static variable of the type of the first structure, containing the addresses of the functions that are associated with the class. This type of polymorphism is used in the standard library when file I/O functions are called.

A similar mechanism can also be used for implementing a state machine in C. A structure is defined which contains function pointers for handling events that may occur within state, and for functions to be invoked upon entry to and exit from the state. An instance of this structure corresponds to a state. Each state is initialized with pointers to functions appropriate for the state. The current state of the state machine is in effect a pointer to one of these states. Changing the value of the current state pointer effectively changes the current state. When some event occurs, the appropriate function is called through a function pointer in the current state.

Practical use of function pointers in C[edit]

Function pointers are mainly used to reduce the complexity of switch statement. Example with switch statement:

#include<stdio.h>intadd(inta,intb);intsub(inta,intb);intmul(inta,intb);intdiv(inta,intb);intmain(){inti,result;inta=10;intb=5;printf("Enter the value between 0 and 3 : ");scanf("%d",&i);switch(i){case0:result=add(a,b);break;case1:result=sub(a,b);break;case2:result=mul(a,b);break;case3:result=div(a,b);break;}}intadd(inti,intj){return(i+j);}intsub(inti,intj){return(i-j);}intmul(inti,intj){return(i*j);}intdiv(inti,intj){return(i/j);}

Without using a switch statement:

#include<stdio.h>intadd(inta,intb);intsub(inta,intb);intmul(inta,intb);intdiv(inta,intb);int(*oper[4])(inta,intb)={add,sub,mul,div};intmain(){inti,result;inta=10;intb=5;printf("Enter the value between 0 and 3 : ");scanf("%d",&i);result=oper[i](a,b);}intadd(inti,intj){return(i+j);}intsub(inti,intj){return(i-j);}intmul(inti,intj){return(i*j);}intdiv(inti,intj){return(i/j);}

Function pointers may be used to create a struct member function:

typedefstruct{int(*open)(void);void(*close)(void);int(*reg)(void);}device;intmy_device_open(void){/* ... */}voidmy_device_close(void){/* ... */}voidregister_device(void){/* ... */}devicecreate(void){devicemy_device;my_device.open=my_device_open;my_device.close=my_device_close;my_device.reg=register_device;my_device.reg();returnmy_device;}

Use to implement this pointer (following code must be placed in library).

staticstructdevice_data{/* ... here goes data of structure ... */};staticstructdevice_dataobj;typedefstruct{int(*open)(void);void(*close)(void);int(*reg)(void);}device;staticstructdevice_datacreate_device_data(void){structdevice_datamy_device_data;/* ... here goes constructor ... */returnmy_device_data;}/* here I omit the my_device_open, my_device_close and register_device functions */devicecreate_device(void){devicemy_device;my_device.open=my_device_open;my_device.close=my_device_close;my_device.reg=register_device;my_device.reg();returnmy_device;}

Examples of pointer constructs[edit]

Below are some example constructs which may aid in creating your pointer.

inti;// integer variable 'i'int*p;// pointer 'p' to an integerinta[];// array 'a' of integersintf();// function 'f' with return value of type integerint**pp;// pointer 'pp' to a pointer to an integerint(*pa)[];// pointer 'pa' to an array of integerint(*pf)();// pointer 'pf' to a function with return value integerint*ap[];// array 'ap' of pointers to an integerint*fp();// function 'fp' which returns a pointer to an integerint***ppp;// pointer 'ppp' to a pointer to a pointer to an integerint(**ppa)[];// pointer 'ppa' to a pointer to an array of integersint(**ppf)();// pointer 'ppf' to a pointer to a function with return value of type integerint*(*pap)[];// pointer 'pap' to an array of pointers to an integerint*(*pfp)();// pointer 'pfp' to function with return value of type pointer to an integerint**app[];// array of pointers 'app' that point to pointers to integer valuesint(*apa[])[];// array of pointers 'apa' to arrays of integersint(*apf[])();// array of pointers 'apf' to functions with return values of type integerint***fpp();// function 'fpp' which returns a pointer to a pointer to a pointer to an intint(*fpa())[];// function 'fpa' with return value of a pointer to array of integersint(*fpf())();// function 'fpf' with return value of a pointer to function which returns an integer


The sizeof operator is often used to refer to the size of a static array declared earlier in the same function.

To find the end of an array (example from wikipedia:Buffer overflow):

/* better.c - demonstrates one method of fixing the problem */#include<stdio.h>#include<string.h>intmain(intargc,char*argv[]){charbuffer[10];if(argc<2){fprintf(stderr,"USAGE: %s string\n",argv[0]);return1;}strncpy(buffer,argv[1],sizeof(buffer));buffer[sizeof(buffer)-1]='\0';return0;}

To iterate over every element of an array, use

#define NUM_ELEM(x) (sizeof (x) / sizeof (*(x)))for(i=0;i<NUM_ELEM(array);i++){/* do something with array[i] */;}

Note that the operator only works on things defined earlier in the same function. The compiler replaces it with some fixed constant number. In this case, the was declared as an array of 10 char's earlier in the same function, and the compiler replaces with the number 10 at compile time (equivalent to us hard-coding 10 into the code in place of ). The information about the length of is not actually stored anywhere in memory (unless we keep track of it separately) and cannot be programmatically obtained at run time from the array/pointer itself.

Often a function needs to know the size of an array it was given -- an array defined in some other function. For example,

/* broken.c - demonstrates a flaw */#include<stdio.h>#include<string.h>#define NUM_ELEM(x) (sizeof (x) / sizeof (*(x)))intsum(intinput_array[]){intsum_so_far=0;inti;for(i=0;i<NUM_ELEM(input_array);i++)// WON'T WORK -- input_array wasn't defined in this function.{sum_so_far+=input_array[i];};return(sum_so_far);}intmain(intargc,char*argv[]){intleft_array[]={1,2,3};intright_array[]={10,9,8,7,6,5,4,3,2,1};intthe_sum=sum(left_array);printf("the sum of left_array is: %d",the_sum);the_sum=sum(right_array);printf("the sum of right_array is: %d",the_sum);return0;}

Unfortunately, (in C and C++) the length of the array cannot be obtained from an array passed in at run time, because (as mentioned above) the size of an array is not stored anywhere. The compiler always replaces sizeof with a constant. This sum() routine needs to handle more than just one constant length of an array.

There are some common ways to work around this fact:

  • Write the function to require, for each array parameter, a "length" parameter (which has type "size_t"). (Typically we use sizeof at the point where this function is called).
  • Use of a convention, such as a null-terminated string to mark the end of the array.
  • Instead of passing raw arrays, pass a structure that includes the length of the array (such as ".length") as well as the array (or a pointer to the first element); similar to the or classes in C++.
/* fixed.c - demonstrates one work-around */#include<stdio.h>#include<string.h>#define NUM_ELEM(x) (sizeof (x) / sizeof (*(x)))intsum(intinput_array[],size_tlength){intsum_so_far=0;inti;for(i=0;i<length;i++){sum_so_far+=input_array[i];};return(sum_so_far);}intmain(intargc,char*argv[]){intleft_array[]={1,2,3,4};intright_array[]={10,9,8,7,6,5,4,3,2,1};intthe_sum=sum(left_array,NUM_ELEM(left_array));// works here, because left_array is defined in this functionprintf("the sum of left_array is: %d",the_sum);the_sum=sum(right_array,NUM_ELEM(right_array));// works here, because right_array is defined in this functionprintf("the sum of right_array is: %d",the_sum);return0;}

It's worth mentioning that sizeof operator has two variations: (for instance: or ) and (for instance: or ).

External Links[edit]

Pointer a pointing variable b. Note that b stores number, whereas a stores address of b in memory (1462)
The pointer points to the variable .

Previous:14.2 Dynamic Memory Allocation
Up:14 Storage Class and Scope
Next:14.4 Summary
Previous Page:14.2.2 Dynamic Arrays
Next Page:14.3.1 Function Pointers as Returned Values

14.3 Pointers to Functions

We saw earlier that functions have a storage class and scope, similar to variables. In C, it is also possible to define and use function pointers, i.e. pointer variables which point to functions. Function pointers can be declared, assigned values and then used to access the functions they point to. Function pointers are declared as follows:

Here, is declared as a pointer to a function that returns type, and is a pointer to a function that returns . The interpretation is as follows for the first declaration: the dereferenced value of , i.e. followed by indicates a function, which returns integer type. The parentheses are essential in the declarations. The declaration without the parentheses: declares a function that returns an integer pointer.

We can assign values to function pointer variables by making use of the fact that, in C, the name of a function, used in an expression by itself, is a pointer to that function. For example, if and are declared as follows:

the names of these functions, and , are pointers to those functions. We can assign them to pointer variables:

The functions can now be accessed, i.e. called, by dereferencing the function pointers:

Function pointers can be passed as parameters in function calls and can be returned as function values. Use of function pointers as parameters makes for flexible functions and programs. An example will illustrate the approach. Suppose we wish to sum integers in a specified range from x to y. We can easily implement a function to do so:

The file contains prototypes for all the functions written in . Next, suppose we wish to sum squares of integers from x to y. We must write another function to do so: Function returns the integer square of . The constructions of the two functions and are identical. In both cases, we cumulatively add either the integers themselves or squares of the integers. A function , which returns the value of the integer argument, can be used in to make the functions truly identical. Here is a modified function that uses : The two sum functions, and , are now identical except for the functions used in the cumulative sum expressions. In one case, we use , in the other case, . It is clear that a single more flexible generic sum function can be written by passing a function pointer, , as an argument with a value pointing to the appropriate function to use. The cumulative sum expression would then take the form: Here is the implementation:

Finally, we can improve the generic sum function by using a pointer to a function that updates the integer using a specified step size:

The function pointed to by takes two arguments, an integer to be updated and the step size. The generic function can now be used to sum applied to integers , which are updated by . The pointer variable, can point to any function that processes an integer and returns an integer. Similarly, can point to any function that returns an updated integer value.

Let us now write a program that reads starting and ending integers as well as step size until . For each set of data read, the program first computes and prints the sum of integers using , and sum of squares using . These two sums are in steps of one, since that is how the functions are written. Next, the program uses the above generic sum function to compute sums of integers and squares in specified step sizes. Figure 14.17 shows the program.

The update function used is , which merely returns plus the step size. The program source files, and , are compiled separately and linked together. A sample run of the program is shown below:

Sample Session:

For each set of input data, the output first shows sums of integers and squares in steps of one, and then in specified steps.

Previous:14.2 Dynamic Memory Allocation
Up:14 Storage Class and Scope
Next:14.4 Summary
Previous Page:14.2.2 Dynamic Arrays
Next Page:14.3.1 Function Pointers as Returned Values


Leave a Reply

Your email address will not be published. Required fields are marked *