How to understand complicated function declarations?

Question

How to understand following complicated declarations?

char (*(*f())[])();

char (*(*X[3])())[5];

void (*f)(int,void (*)()); 

char far *far *ptr;

typedef void (*pfun)(int,float);

int **(*f)(int**,int**(*)(int **,int **));

EDIT : After people have cursed me, I am tagging this as homework question. :-)

Answer 1

Sounds like a job for the cdecl tool:

cdecl> explain char (*(*f())[])();
declare f as function returning pointer to array of pointer to function returning char

I looked around for an official homepage for the tool, but couldn't find one that seemed genuine. In Linux, you can typically expect your distribution of choice to include the tool, so I just installed it in order to generate the above sample.

Answer 2

You should be using cdecl tool. It should be available on most Linux distributions.

e.g. for this function, it will return you:

char (*(*f())[])(); - declare f as function returning pointer to array of pointer to function returning char

void (*f)(int,void (*)()); - prototype of function pointer f. f is a function that takes two parameters, the first one is int, and the second one is a function pointer for a function which returns void.

char far *far *ptr; - ptr is a far pointer to a far pointer (which points to some char/byte).

char (*(*X[3])())[5]; - X is an array of 3 pointers to function accepting an undeterminate number of arguments and returning a pointer to an array of 5 char.

typedef void (*pfun)(int,float); - declaring function pointer pfun. pfun is a fuctnion that takes two parameters, first one is int, second one is of float type. the function does not have a return value;

e.g.

void f1(int a, float b)
{ //do something with these numbers
};

Btw, complicated declarations as the last one are not seen often. Here is an example I just made up for this purpose.

int **(*f)(int**,int**(*)(int **,int **));

typedef int**(*fptr)(int **,int **);

int** f0(int **a0, int **a1)
{
    printf("Complicated declarations and meaningless example!\n");
    return a0;
}

int ** f1(int ** a2, fptr afptr)
{
    return afptr(a2, 0);
}

int main()
{
    int a3 = 5;
    int * pa3 = &a3;
    f = f1;
    f(&pa3, f0);

    return 0;
}

Answer 3

char far *far *ptr;

This is an obsolete Microsoft form, dating back to MS-DOS and very early Windows days. The SHORT version is that this is a far pointer to a far pointer to a char, where a far pointer can point anywhere in memory, as opposed to a near pointer which could only point anywhere in 64K data segment. You really don't want to know the details about Microsoft memory models for working around the utterly brain-dead Intel 80x86 segmented memory architecture.

typedef void (*pfun)(int,float);

This declares pfun as a typedef for a pointer to a procedure that takes an int and a float. You would normally use this in a function declaration or a prototype, viz.

float foo_meister(pfun rabbitfun)
{
  rabbitfun(69, 2.47);
}

Answer 4

As others have pointed out, cdecl is the right tool for the job.

If you want to understand that kind of declaration without help from cdecl, try reading from the inside out and right to left

Taking one random example from your list char (*(*X[3])())[5];
Start at X, which is the identifier being declared/defined (and the innermost identifier):

char (*(*X[3])())[5];
         ^

X is

X[3]
 ^^^

X is an array of 3

(*X[3])
 ^                /* the parenthesis group the sub-expression */

X is an array of 3 pointers to

(*X[3])()
       ^^

X is an array of 3 pointers to function accepting an unspecified (but fixed) number of arguments

(*(*X[3])())
 ^                   /* more grouping parenthesis */

X is an array of 3 pointers to function accepting an unspecified (but fixed) number of arguments and returning a pointer

(*(*X[3])())[5]
            ^^^

X is an array of 3 pointers to function accepting an unspecified (but fixed) number of arguments and returning a pointer to an array of 5

char (*(*X[3])())[5];
^^^^                ^

X is an array of 3 pointers to function accepting an unspecified (but fixed) number of arguments and returning a pointer to an array of 5 char.

Answer 5

I suggest you to look at this answer: http://stackoverflow.com/questions/1448849/how-to-understand-complicated-function-declarations that should answer your initial questions too.

And yes, you may find complicated types, normally in header files of complex code. Usually involving function to pointers.

Answer 6

Forget about 1 and 2 - this is just theoretical.

3: This is used in the program entry function int main(int argc, char** argv). You can access a list of strings by using a char**. argv[0] = first string, argv[1] = second string, ...

Answer 7

Remo.D's answer for reading functions is a good suggestion. Here are some answers to the others.

One use-case for a pointer to a pointer is when you wish to pass it to a function that will modify the pointer. For example:

void foo(char **str, int len)
{
   *str = malloc(len);
}

Also, this could be an array of strings:

void bar(char **strarray, int num)
{
   int i;
   for (i = 0; i < num; i++)
     printf("%s\n", strarray[i]);
}

Typically, one shouldn't use declarations this complicated, although sometimes you do need types that are pretty complicated for things like function pointers. In those cases, it's much more readable to use typedefs for intermediate types; for example:

typedef void foofun(char**, int);
foofun *foofunptr;

Or, for your first example of "function returning pointer to array[] of pointer to function returning char", you might do:

typedef char fun_returning_char();
typedef fun_returning_char *ptr_to_fun;
typedef ptr_to_fun array_of_ptrs_to_fun[];
typedef array_of_ptrs_to_fun *ptr_to_array;
ptr_to_array myfun() { /*...*/ }

In practice, if you're writing anything sane, many of those things will have meaningful names of their own; for instance, these might be functions returning names (of some sort), so fun_returning_char could be name_generator_type, and array_of_ptrs_to_fun could be name_generator_list. So you could collapse it a couple of lines, and only define those two typedefs -- which are probably going to be useful elsewhere in any case.

Answer 8

x: function returning pointer to array[] of pointer to function returning char" - huh?

You have a function

That function returns a pointer.

That pointer points to an array.

That array is an array of function pointers(or pointers to functions)

Those functions returns char*.

 what's the use case for a pointer to a pointer?

One is to facilitate return values through arguments.

Lets say you have

int function(int *p)
  *p = 123;
   return 0; //success !
}

You call it like

int x;
function(&x);

As you can see, for function to be able to modify our x we have to pass it a pointer to our x.

What if x was not an int, but a char * ? Well, its still the same, we have to pass a pointer to that. A pointer to a pointer:

int function(char **p)
  *p = "Hello";
   return 0; //success !
}

You call it like

char *x;
function(&x); 

Answer 9

Read it out from the inside, similar to how you would solve equations such as {3+5*[2+3*(x+6*2)]}=0 - you'd start by solving what's inside () then [] and finally {}:

char (*(*x())[])()
         ^

This means that x is something.

char (*(*x())[])()
          ^^

x is a function.

char (*(*x())[])()
        ^

x returns a pointer to something.

char (*(*x())[])()
       ^    ^^^

x returns a pointer to an array.

char (*(*x())[])()
      ^

x returns a pointer to an array of pointers.

char (*(*x())[])()
     ^         ^^^

x returns a pointer to an array of pointers to functions

char (*(*x())[])()
^^^^

Meaning the array pointer returned by x points to an array of function pointers that point to functions that return a char.

But yeah, use cdecl. I used it myself to check my answer :).

If this is still confusing you (and it probably should), try to do the same thing on a piece of paper or in your favorite text editor. There's no way of knowing what it means just by looking at it.

Answer 10

Passing a pointer as an argument to a function lets that function change the contents of the variable pointed to, which can be useful for returning information by means other than the function return value. For example, the return value might already be used to indicate error/success, or you might want to return multiple values. The syntax for this in the calling code is foo(&var), which takes the address of var, i.e., a pointer to var.

So as such, if the variable whose contents you want the function to change is itself a pointer (e.g., a string), the parameter would be declared as a pointer to a pointer.

#include <stdio.h>

char *some_defined_string = "Hello, " ; 
char *alloc_string() { return "World" ; } //pretend that it's dynamically allocated

int point_me_to_the_strings(char **str1, char **str2, char **str3)
{
    *str1 = some_defined_string ;
    *str2 = alloc_string() ;
    *str3 = "!!" ;

    if (str2 != 0) {
        return 0 ; //successful
    } else {
        return -1 ; //error
    }
}

main()
{
    char *s1 ; //uninitialized
    char *s2 ;
    char *s3 ;

    int success = point_me_to_the_strings(&s1, &s2, &s3) ;

    printf("%s%s%s", s1, s2, s3) ;
}

Note that main() does not allocate any storage for the strings, so point_me_to_the_strings() does not write to str1, str2, and str3 as it would if they were passed as pointers to chars. Rather, point_me_to_the_strings() changes the pointers themselves, making them point to different places, and it can do this because it has pointers to them.

Answer 11

It appears that your actual question is this:

What's the use case for a pointer to a pointer?

A pointer to a pointer tends to show up when you have an array of some type T, and T itself is a pointer to something else. For example,

• What's a string in C? Typically, it's a char *.
• Would you like an array of strings from time to time? Sure.
• How would you declare one? char *x[10]: x is an array of 10 pointers to char, aka 10 strings.

At this point, you might be wondering where char ** comes in. It enters the picture from the very close relationship between pointers arithmetic and arrays in C. An array name, x is (almost) always converted to a pointer to it's first element.

• What's the first element? A char *.
• What's a pointer to the first element? A char **.

In C, array E1[E2] is defined to be equivalent to *(E1 + E2). Usually, E1 is the array name, let's say x, which automatically converted to a char **, and E2 is some index, say 3. (This rule also explains why 3[x] and x[3] are the same thing.)

Pointers to pointers also show up when you want a dynamically allocated array of some type T, which is itself a pointer. To start with, let's pretend we don't know what type T is.

• If we want a dynamically allocated vector of T's, what type do we need? T *vec.
• Why? Because we can perform pointer arithmetic in C, any T * can serve as the base of a contiguous sequence of T's in memory.
• How do we allocate this vector, say of n elements? vec = malloc(n * sizeof(T));

This story is true for absolutely any type T, and so it's true for char *.

• What's the type of vec if T is char *? char **vec.

Pointers to pointers also show up when you have a function that needs to modify an argument of type T, itself a pointer.

• Look at the declaration for strtol: long strtol(char *s, char **endp, int b).
• What's this all about? strtol converts a string from base b to an integer. It wants to tell you how far into the string it got. It could perhaps return a struct containing both a long and a char *, but that's not how it's declared.
• Instead, it returns its second result by passing in the address of a string which it modifies before returning.
• What's a string again? Oh yeah, char *.
• So what's an address of a string? char **.

If you wander down this path long enough, you can also run into T *** types, although you can almost always restructure the code to avoid them.

Finally, pointers to pointers appear in certain tricky implementations of linked lists. Consider the standard declaration of a doubly-linked list in C.

struct node {
    struct node *next;
    struct node *prev;
    /* ... */
} *head;

This works fine, although I won't reproduce the insertion/deletion functions here, but it has a little problem. Any node can be removed from the list (or have a new node inserted before it) without reference the head of the list. Well, not quite any node. This isn't true of the first element of the list, where prev will be null. This can be moderately annoying in some kinds of C code where you work more with the nodes themselves than with the list as a concept. This is a reasonably common occurrence in low-level systems code.

What if we rewrite node like this:

struct node {
    struct node *next;
    struct node **prevp;
    /* ... */
} *head;

In each node, prevp points not at the previous node, but at the previous nodes's next pointer. What about the first node? It's prevp points at head. If you draw out a list like this (and you have to draw it out to understand how this works) you'll see that you can remove the first element or insert a new node before the first element without explicitly referencing head by name.