[C] Funktion, die Ihren eigenen Typ als Argument bekommt

[Peter F. (Gast)]

Hallo,

ich möchte eine Funktion deklarieren (oder am besten als typedef), die 
als Argumente eine Integer und einen Funktionszeiger auf genau so eine 
Funktion, wie sie selbst eine ist, akzeptiert.
Wenn ich schreibe

typedef int Func_t( int, Func_t* );

geht das ja nicht, weil der Typ Func_t noch nicht bekannt ist.

Aber so geht's auch nicht:

typedef int Func_t( int, int(*)() );

testfunc(int i, Func_t *f) {
     return 0;
}
Func_t *funcptr = testfunc;

Hier meckert der Compiler natürlich, dass *funcptr und testfunc nicht 
vom selben Pointer Typ sind.
Ich müsste casten:

Func_t *funcptr = (Func_t*)testfunc;

Kann man denn einen Typ basteln, der als (zweites) Argument einen Zeiger 
auf den eigenen Typ nimmt?

[Tom (Gast)]

Die Lösung für alle abstrusen Probleme in C ist "Das Problem in ein 
struct stecken, schon funktioniert es".

#include <stdio.h>

typedef struct Foo
{
    void (*call)(struct Foo, int);
} Foo;

void bar(Foo foo, int i)
{
    if (i <= 0)
        return;
    printf("%d\n", i);
    foo.call(foo, i-1);
}

int main(void)
{
    bar((Foo){bar}, 7);
    return 0;
}

[nocheinGast (Gast)]

Also in C kann man sowas doch mit dem Präprozessor zusammenbauen 
(vorausgesetzt ich hab überhaupt die Frage richtig verstanden):

#define tdef(Name, R, ...) \
    typedef R(*Name)(__VA_ARGS__, R(*)(__VA_ARGS__))
    
tdef(Funktion, int, char, int);


int f(char a, int b, int (*c)(char a, int b)) {
    return c(a, b);
}

int x(char a, int b) {
}

void y(char a, int b) {
}

int main() {
    Funktion fp = f;
    
    fp(1, 2, x);
    fp(1, 2, y);  // Fehler.
}

Ich hoffe, ich mach hier keinen Unsinn...

In C++ könnte man das mit einem Template lösen:

#include <functional>

template <typename R, typename... Args>
using Funktion = std::function<R (Args..., std::function<R (Args...)>)>; 

int f(char a, int b, std::function<int (char a, int b)> c) {
    return c(a, b);
}

int x(char a, int b) {
}

void y(char a, int b) {
}

int main() {
    Funktion<int, char, int> fp = f;
    
    fp(1, 2, x);
    fp(1, 2, y);  // Fehler.
}

[Peter F. (Gast)]

Tom schrieb:
> "Das Problem in ein
> struct stecken, schon funktioniert es".
Danke!
Das funktioniert, denn da erscheint das zweite "struct Foo" in einem 
anderen Block, wo es schon bekannt ist.

nocheinGast schrieb:
> Also in C kann man sowas doch mit dem Präprozessor zusammenbauen
Hm, ich glaube nicht, denn auch der Präprozessor muss ja Code 
generieren, den der Compiler als gültig ansieht.

nocheinGast schrieb:
> int f(char a, int b, int (*c)(char a, int b)) {
>     return c(a, b);
> }
Auch hier ist ja *c nicht vom selben Typ wie f.