10

I want to assign a function's address to a function pointer, but the function to be addressed returns a function pointer with the same signature as itself, causing it to recurse in a way that I can't write the return type at all, for the function pointer or even the function declaration itself...

I guess a way of simplifying the problem so it's not confusing:

How could I write a function declaration such, that it can return a pointer to itself (or any other function with the same signature)?

????? function(int a){
    // could be this function, or another with the same signature, 
    return arbitraryFunction;  
}

?????(*func)(int) = function;  // same problem as above

edit:

For now I have a solution, though I won't post it as an answer because it's aggressively ugly. It gets rid of the recursion by simply returning a raw void* pointer as the return type, and ends up taking the following form:

void* function(int parameter){
    return arbitraryFunction; // of the same signature
}

void*(*func)(int) = function; 
func = reinterpret_cast<void*(*)(int)>(func(42));  // sin

edit2:

It seems casting between function pointers and regular pointers is UB, so I can't use void* in this case...

To answer one of the comments, this is for passing control between multiple "main" loops in my program, with each loop getting it's own function. There's a lot of ways to do this, but returning function pointers (or NULL to terminate the program) mid-loop seemed like the simplest method, but I didn't anticipate that pointers to data and pointers to function addresses would be incompatable with each other. I think returning polymorphic function objects will end up being the more sane option in this case.

Improve this question
12
  • 1
    I guess you cannot do that, at least not easily. Commented Sep 27, 2015 at 15:17
  • I wonder if returning void* as the function's and function pointer's return type, will let me avoid the recursive declaration... Commented Sep 27, 2015 at 15:24
  • BTW, even Ocaml disallow that, unless you invoke ocamlc with -rectypes (for recursive types) Commented Sep 27, 2015 at 15:39
  • May you tell us the exact problem? There could be better solutions for it. Commented Sep 27, 2015 at 16:00
  • 1
    @Clairvoire This is impossible because type checker would have to check infinite types. That's a hard task even for simple type systems with equirecursive types. Obviously there's no such thing in C++. Though you can always wrap it into a struct. This is an equivalent of isorecursive types as now compiler may determine pack/unpack borders by the fact you've created/accessed your structure. Commented Sep 27, 2015 at 23:55

3 Answers 3

Reset to default
6

Don't use void*, because no guarantee that a void * can hold a function pointer. You can use void(*)() as a workaround:

typedef void(*void_func)();
typedef void_func (*func_type) (int);
void_func arbitraryFunction(int a) {
    // could be this function, or another with the same signature, 
    cout << "arbitraryFunction\n";
    return nullptr;  
}
void_func function(int a) {
    // could be this function, or another with the same signature, 
    return (void_func) arbitraryFunction;  
}
int main() {
    // your code goes here
    func_type f = (func_type) function(0);
    f(0);
    return 0;
}

LIVE

C99 [6.2.5/27]:

A pointer to void shall have the same representation and alignment requirements as a pointer to a character type. Similarly, pointers to qualified or unqualified versions of compatible types shall have the same representation and alignment requirements. All pointers to structure types shall have the same representation and alignment requirements as each other. All pointers to union types shall have the same representation and alignment requirements as each other. Pointers to other types need not have the same representation or alignment requirements.

C99 [6.3.2.3/8]:

A pointer to a function of one type may be converted to a pointer to a function of another type and back again; the result shall compare equal to the original pointer.

Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

it can't return void though, because func will need to match the function that returned it, which returns func
Note that converting a function pointer to a void* is UB and is neither required to be supported nor that its value is preserved while converting back and forth.
@PiotrSkotnicki I've fixed my answer.
@Clairvoire I've fixed my answer.
The OP was tagged C++, yet you quote the C99 standard. How can that possibly answer the question correctly?
5

The trick in C is to take advantage of the fact that any kind of function pointer can be cast to any other kind of function pointer:

#include <stdlib.h>
#include <stdio.h>

typedef void(*emptyfunc)(void);
typedef emptyfunc (*funcptr2)(int);

funcptr2 strategy(int m)
{
  printf("Strategy %d.\n", m);
  return (funcptr2)&strategy;
}

int main (void)
{
  const funcptr2 strategy2 = (funcptr2)strategy(1);
  const funcptr2 strategy3 = (funcptr2)strategy2(2);
  strategy3(3);

  return EXIT_SUCCESS;
}

Each pointer to a strategy is always in a type that can be called once, and the return value is put back into a form that can be called once again.

In C++, you would declare a function object:

class strategy {
  public:
  virtual const strategy& operator()(int) const = 0;
}

An instance of this class can be called like a function.

Improve this answer

4 Comments

How to return a reference of other function object from a member function?
@songyuanyao I’m not sure I understand the question, but one approach would be to make strategy an abstract base class and have subclasses that implement different strategies. Then you could return instances of those.
I mean in one of the subclasses, when you return another subclass, you have to keep the reference valid, by using global variable, etc.
You just need to declare the objects before you refer to them. They might be singletons. Alternatively, you could adjust the interface so that a meta-strategy is a higher-order function taking strategies as input.
1

I suspect what you are trying to do is a more complex version of something like this:

typedef MainLoop *MainLoop(); // not legal

extern MainLoop* main_loop_1();
extern MainLoop* main_loop_2();

MainLoop* main_loop_1()
{
    // do some work here
    return main_loop_2;
}

MainLoop* main_loop_2()
{
    // do some work here
    return main_loop_1;
}

int main()
{
    MainLoop f = main_loop_1;

    for (;;) {
      f = f();
    }
}

A workaround is to wrap the function pointer in a struct:

struct MainLoop {
    MainLoop (*function_ptr)(); // legal
};

extern MainLoop main_loop_1();
extern MainLoop main_loop_2();

MainLoop main_loop_1()
{
    // do some work here
    return {main_loop_2};
}

MainLoop main_loop_2()
{
    // do some work here
    return {main_loop_1};
}  

int main()
{
    MainLoop f{main_loop_1};

    for (;;) {
       f = f.function_ptr();
    }
}
Improve this answer

1 Comment

The problem in the question is the function-pointer analogue of declaring a linked list, and this answer is how you do it in both cases.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.