Thread: Pointer to a function pointer

You mean you couldn't find the entire website dedicated to function pointers!?!

http://www.function-pointer.org/

Simple examples and "function returning array" is an oxymoron - there is no such thing.

Generally, we don't want to return an array from a C function.

A workaround would be to store the fuinction pointers in a struct, and return the (address of the) struct. E.g.

Code:

#define SIZE 3
struct myFuncPtrs
{
    char (*funcPtrs)[SIZE];
};



myFuncPtrs *fetchFunctions(int arg)
{
   static struct myFuncPtrs type1 = { ... };
   static struct myFuncPtrs type2 = { ... };  

   if (arg) 
      return &type1;
    else
      return &type2;
}

--
Mats

zacs7 linked to a website. Have you visited it?

It's quite easy with typedefs.
First one for a function pointer:

Code:

typedef void (fptr)(int, float, double/*, whatever*/);

fptr* p = &foo; /* This is a function pointer */
fptr* p2 = &foo2;
fptr* p3 = &foo3;

fptr* array[] = { p, p2, p3 };

And so on.
I didn't test it, but it should hopefully work!

Here is an example of a function returning a pointer to a function pointer [actually, a pointer to an array of function pointers]. Using typedef makes it much more manageable to do this.

Code:

#include <stdio.h>

typedef void (*funcptr)(void);

void f1(void);
void f2(void);

void f1()
{
        printf("Iam in f1 \n");
}

void f2()
{
        printf("Iam in f2 \n");
}


funcptr *fptRet()
{
  static funcptr arrFunPtr[2];

  arrFunPtr[0] = f1;
  arrFunPtr[1] = f2;
  
  return arrFunPtr;
}


int main()
{
  funcptr *pfptr;
  pfptr = fptRet();
  if (arrFunPtr != pfptr)
    printf("Didn't work\n");
  pfptr[1]();
  return 0;
}

I wouldn't recommend doing this sort of convuluted solution unless you have a really good reason, but that is a different story, I suppose.

--
Mats

Learn how to interpret function pointer typedefs and everything will become so much clearer. It simplifies syntax enormously.

If you insist on not listening to good advice, that is your choice. The syntax for function pointers is awkward. Trying to make it more awkward by using obscure things like function pointers returning pointers to function pointers without typedefs is lunacy - no sane programmer will want to read such code, and no sane programmer will want to write such. So stop asking for something no one wants to use.

typedefs is an EXCELLENT way to avoid all the hairy parenthesis that you will spend half a day figuring out which one belongs to what [it gets even better when you have several different arguments to the functions].

Have you considered why you don't actually find the solutions you are asking for?

--
Mats

You can't expect to find an example for every possible use of function pointers, you might actually have to learn how they work. Then apply the idea yourself, and I don't mean that in a harsh way.

Originally Posted by matsp

Here is an example of a function returning a pointer to a function pointer [actually, a pointer to an array of function pointers].

The good (or perhaps bad) old "array decays to a pointer to its first element" thing still applies here, so it really is a function returning a pointer to a function pointer

Originally Posted by rohit_second

Please don't use typedef in defining a function pointer,its confusing.

Personally, I find not using typedef for a function pointer even more confusing than using it.

Originally Posted by rohit_second

Please understand the question properly.......

I am asking for an example like,

Function returning a pointer to an array of function pointers.....not the entire array.

Also examples for....

pointer to a function pointer,

function pointer returning function pointer.

Regards,
R

Here ya go friend, I guess this is what you wanted. Have a nice day!

Code:

#include <stdio.h>

typedef char (*(*ComplexFuncPtrType)[5])(char);


char SomeFunc1(char a)
{
   return a;
}


//Here is the same function as below only it uses typedef instead
/*
ComplexFuncPtrType Func(ComplexFuncPtrType cfptVar)
{ 
   (*cfptVar)[0]=SomeFunc1;
    return cfptVar;  
}
*/


//6   4 2  1    PARAM    5   3        1         2    4     PARAM     3     5     
char (*(*Func(/*PARAM*/char (*(*ComplexFuncPtr)[5])(char)/*PARAM*/))[5])(char)
{    
  (*ComplexFuncPtr)[0]=SomeFunc1;
   return ComplexFuncPtr;
}
/*
PARAMETER of Func()
--------------------
(1)pointer, named ComplexFuncPtr, to
(2)an array of 5
(3)pointers to
(4)functions with char as parameter
(5)which return a char

Func()
----
(1)Function named Func
(2)which returns a pointer to
(3)an array of 5
(4)pointers to
(5)functions with char as parameter
(6)which return a char
*/

int main()
{
    char (*FuncArray[5])(char)={0};  //Array of 5 function pointers
    char (*(*pFuncArray)[5])(char)={0};  //Pointer to an array of 5 function pointers
    //FuncArray[0]=SomeFunc1;  //There are different paths in which to assign SomeFunc1
    pFuncArray = (ComplexFuncPtrType)Func((ComplexFuncPtrType) FuncArray);
    printf("&#37;c", (*(*pFuncArray)[0])('A') );
  
   /////////////////////MORE EXAMPLES////////////////////////////////////////////////
    int (*Funcptr)()=NULL;
    int (**ptrToFuncptr)()=&Funcptr;  //Pointer to a function pointer.

    int (*(*FuncptrReturn)())  ()=NULL;  //Pointer to a function returning a pointer to a function.
    getchar();
   
    return 0;
}