Zurückgebender Funktionszeigertyp

Oft finde ich die Notwendigkeit, Funktionen zu schreiben, die Funktionszeiger zurückgeben. Wann immer ich dies tue, verwende ich das grundlegende Format:

typedef int (*function_type)(int,int);

function_type getFunc()
{
   function_type test;
   test /* = ...*/;
   return test;
}

Dies kann jedoch umständlich werden, wenn es um eine große Anzahl von Funktionen geht, daher möchte ich nicht für jede (oder für jede Funktionsklasse) eine Typedef deklarieren müssen.

Ich kann die Typedef entfernen und die in der Funktion zurückgegebene lokale Variable wie folgt deklarieren:
int (*test)(int a, int b); den Funktionsrumpf so aussehen zu lassen:

{
     int (*test)(int a, int b);
     test /* = ...*/;
     return test;
}

aber dann weiß ich nicht, was ich für den Rückgabetyp der Funktion einstellen soll. Ich habe versucht:

int(*)(int,int) getFunc()
{
    int (*test)(int a, int b);
    test /* = ...*/;
    return test;
}

aber das meldet einen Syntaxfehler. Wie deklariere ich den Rückgabetyp für eine solche Funktion, ohne eine Typedef für den Funktionszeiger zu deklarieren? Ist es überhaupt möglich? Beachten Sie auch, dass ich mir bewusst bin, dass es sauberer zu sein scheint, Typedefs zu deklarieren, aber ich bin sehr darauf bedacht, meinen Code so sauber und einfach wie möglich zu strukturieren. Der Grund, warum ich die Typedefs eliminieren möchte, ist, dass sie oft nur verwendet werden, um die Abruffunktionen zu deklarieren und daher im Code redundant erscheinen.

int (*getFunc())(int, int) { … }

Damit erhalten Sie die von Ihnen angeforderte Erklärung. Wie ola1olsson feststellt, wäre es außerdem gut, es einzufügen void:

int (*getFunc(void))(int, int) { … }

Das sagt das getFunc darf keine Parameter annehmen, was helfen kann, Fehler zu vermeiden, z. B. durch versehentliches Schreiben getFunc(x, y) Anstatt von getFunc()(x, y).

Sie können wahrscheinlich so etwas tun:

int foo (char i) {return i*2;}

int (*return_foo()) (char c)
{
   return foo;
}

aber Gott, ich hoffe, ich muss deinen Code nie debuggen …

Ich lasse dies hier, da es etwas kniffliger war als die bereits gegebenen Antworten, da es einen Funktionszeiger benötigt

(int (__cdecl *)(const char *))

und gibt einen Funktionszeiger zurück

(int (__cdecl *)(const char *))

#include <stdio.h>

int (*idputs(int (*puts)(const char *)))(const char *) {
    return puts;
}

int main(int argc, char **argv)
{
    idputs(puts)("Hey!");

    return 0;
}

Beim Umhüllen von C-Code in C++-Klassen hatte ich den gleichen Wunsch wie das ursprüngliche Poster: Einen Funktionszeiger von einer Funktion zurückgeben, ohne darauf zurückzugreifen typedefDen Funktionszeiger-Prototypen erstellen. Ich habe ein Problem mit C++ const Korrektheit, von der ich dachte, dass sie es wert ist, geteilt zu werden, auch wenn sie ein wenig vom Thema abweicht (C++), aber sie bezieht sich direkt auf die ursprüngliche Frage: die Syntax zum Zurückgeben eines C-Funktionszeigers, ohne auf a zurückzugreifen typedef.

Der folgende Code definiert eine Klasse A die einen Funktionszeiger speichert und ihn der Außenwelt durch die aussetzt get_f() Anruf. Dies ist die Funktion, die einen Funktionszeiger ohne a zurückgeben sollte typedef.

Der Punkt (der mich einige Zeit ratlos machte) war, wie man das deklariert get_f() war ein const funktionieren, dh es würde sich nicht ändern A.

Der Code enthält 2 Varianten: Die erste verwendet einen Typedef für den Funktionszeiger-Prototyp, während die zweite alles vollständig ausschreibt. Das #if wechselt zwischen den beiden.

#include <iostream>

int my_f(int i)
{
  return i + 1;
}

#if 0 // The version using a typedef'ed function pointer

typedef int (*func_t)(int);

class A
{
public:
  A(func_t f) : m_f(f) {}
  func_t get_f() const { return m_f; }

private:
  func_t m_f;
};

int main(int argc, char *argv[])
{
  const A a(my_f);
  std::cout << "result = " << a.get_f()(2) << std::endl;
}

#else // The version using explicitly prototyped function pointer    

class A
{
public:
  A(int (*f)(int)) : m_f(f) {}
  int (*get_f() const)(int) { return m_f; }

private:
  int (*m_f)(int);
};

int main(int argc, char *argv[])
{
  const A a(my_f);
  std::cout << "result = " << a.get_f()(2) << std::endl;
}

#endif

Die erwartete/gewünschte Ausgabe ist:

result = 3

Der entscheidende Punkt ist die Position des const Qualifizierer in der Zeile:

int (*get_f() const)(int) { return m_f; }

Dies ist ein dummes Beispiel, aber es ist einfach und es gibt keine Fehler. Es geht nur darum, statische Funktionen zu deklarieren:

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

void * asdf(int);
static int * hjkl(char,float);

main() {
  int a = 0;
  asdf(a);
 }


void * asdf(int a) {return (void *)hjkl; }
static int * hjkl(char a, float b) {int * c; return c;}

Ich denke du hast drei Möglichkeiten:

1. Bleiben Sie bei typedef. Letztendlich ist es die Aufgabe von typedef.
2. Return void* und das Casting it.
3. Überdenken Sie Ihre Softwarearchitektur. Vielleicht können Sie uns mitteilen, was Sie zu erreichen versuchen, und sehen, ob wir Sie in eine bessere Richtung weisen können.

Sie können den folgenden Code schreiben (funktioniert nur in C++ 11 und höher):

//C++11
auto func(...) {
    int (*fptr)(...) ret = ...
    //Do sth.
    return ret;//C++11 compiler will automatically deduce the return type for you
}

Oder, wenn Sie die automatische Herleitung des Rückgabetyps nicht mögen, können Sie den Typ am Ende der Funktion angeben (wie oben, nur in C++ 11 und höher):

//C++11
auto func(...) -> int (*)(...) { /* Do sth. */ }