Restituisce il tipo di puntatore della funzione

Spesso trovo la necessità di scrivere funzioni che restituiscano i puntatori di funzione. Ogni volta che faccio, il formato di base che uso è:

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

Tuttavia questo può diventare ingombrante quando si ha a che fare con un gran numero di funzioni, quindi non mi piacerebbe dover dichiarare un typedef per ognuna (o per ogni class di funzioni)

Posso rimuovere typedef e dichiarare la variabile locale restituita nella funzione come: int (*test)(int a, int b); rendendo il corpo della funzione simile a questo:

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

ma poi non so cosa impostare per il tipo di ritorno della funzione. Ho provato:

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

ma ciò segnala un errore di syntax. Come posso dichiarare il tipo restituito per tale funzione senza dichiarare un typedef per il puntatore alla funzione. È ansible? Si noti inoltre che sono consapevole che sembra che sia più semplice dichiarare typedef, per ognuna delle funzioni, tuttavia, sono molto attento a strutturare il mio codice in modo che sia il più pulito e facile da seguire ansible. Il motivo per cui vorrei eliminare i typedefs è che vengono spesso utilizzati solo per dichiarare le funzioni di recupero e quindi sembrare ridondanti nel codice.

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

Questo fornisce la dichiarazione che hai richiesto. Inoltre, come nota ola1olsson , sarebbe opportuno inserire il void :

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

Questo dice che getFunc non può prendere alcun parametro, il che può aiutare a evitare errori come qualcuno che scrive involontariamente getFunc(x, y) invece di getFunc()(x, y) .

Probabilmente puoi fare qualcosa come:

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

ma dio, spero di non dover mai fare il debug del tuo codice ….

lascialo qui perché è un po ‘più complicato delle risposte già date, dato che richiede un puntatore a funzione

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

e restituisce un puntatore a funzione

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

 #include  int (*idputs(int (*puts)(const char *)))(const char *) { return puts; } int main(int argc, char **argv) { idputs(puts)("Hey!"); return 0; } 

Questo è un esempio stupido, ma è semplice e non dà errori. Si tratta solo di dichiarare funzioni statiche:

 #include  #include  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;} 

Mentre avvolgevo un codice C in classi C ++, avevo lo stesso desiderio del poster originale: restituire un puntatore a funzione da una funzione senza ricorrere al typedef del prototipo di puntatore a funzione. Ho riscontrato un problema con la correttezza di C ++ che ritenevo valesse la pena condividere, anche se è un po ‘fuori tema (C ++) ma si collega direttamente alla domanda originale: la syntax per restituire un puntatore a funzione C senza ricorrere a un typedef .

Il codice seguente definisce una class A che memorizza un puntatore a funzione e lo espone al mondo esterno tramite la chiamata get_f() . Questa è la funzione che dovrebbe restituire un puntatore a funzione senza typedef .

Il punto (che mi ha get_f() per un po ‘di tempo) era come dichiarare che get_f() era una funzione const , cioè non avrebbe alterato A

Il codice contiene 2 varianti: il primo utilizza un typedef per il prototipo del puntatore di funzione, mentre il secondo scrive tutto per intero. Il #if passa tra i due.

 #include  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 

L'output previsto / desiderato è:

 result = 3 

Il punto chiave è la posizione del qualificatore const nella riga:

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

Penso che tu abbia tre opzioni:

  1. Attacca con typedef. Alla fine della giornata, è il lavoro di typedef.
  2. Restituisci void * e lo lanci.
  3. Riconsiderare la tua architettura software. Forse potresti condividere con noi quello che stai cercando di ottenere e vedere se possiamo indicarti una direzione migliore.

Puoi scrivere il seguente codice (Funziona solo in C ++ 11 e versioni successive):

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

Oppure, se non ti piace la deduzione del tipo di reso automatico, puoi specificare il tipo alla fine della funzione (come sopra, solo in C ++ 11 e sopra):

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