web-dev-qa-db-fra.com

Comment faire pour qu'une fonction retourne un pointeur sur une fonction? (C ++)

J'essaie de créer une fonction qui prend un caractère, puis renvoie un pointeur sur une fonction en fonction de ce qu'était le personnage. Je ne sais juste pas comment faire pour qu'une fonction renvoie un pointeur sur une fonction.

c++return-valuefunction-pointers
63
user98188
#include <iostream>
using namespace std;

int f1() {
    return 1;
}

int f2() {
    return 2;
}

typedef int (*fptr)();


fptr f( char c ) {
    if ( c == '1' ) {
        return f1;
    }
    else {
        return f2;
    }
}

int main() {
    char c = '1';
    fptr fp = f( c );
    cout << fp() << endl;
}
68
anon
int f(char) {
    return 0;
}

int (*return_f())(char) {
    return f;
}

Non, sérieusement, utilisez un typedef :)

95
erikkallen

Créez un typedef pour la signature de fonction:

typedef void (* FuncSig)(int param);

Déclarez ensuite votre fonction comme renvoyant FuncSig:

FuncSig GetFunction();
17
sean e

En C++ 11, vous pouvez utiliser des types de retour de fin pour simplifier la syntaxe, par exemple en assumant une fonction:

int c(int d) { return d * 2; }

Cela peut être renvoyé par une fonction (qui prend un double pour montrer que):

int (*foo(double e))(int)
{
    e;
    return c;
}

En utilisant un type de retour de fin, cela devient un peu plus facile à lire:

auto foo2(double e) -> int(*)(int)
{
    e;
    return c;
}
4
Superfly Jon

Syntaxe de retour de la fonction: 

return_type_of_returning_function (*function_name_which_returns_function)(actual_function_parameters) (returning_function_parameters)

Par exemple: considérez la fonction qui doit être renvoyée comme suit,

void* (iNeedToBeReturend)(double iNeedToBeReturend_par)
{
}

La fonction iNeedToBeReturend peut maintenant être renvoyée sous la forme

void* (*iAmGoingToReturn(int iAmGoingToReturn_par))(double)
{
   return iNeedToBeReturend;
}

Je me sentais très mal d'apprendre ce concept après 3 ans de vie en programmation professionnelle.

Bonus pour vous en attente du pointeur de la fonction de déréférencement.

Questions d'entrevue C++

Exemple de fonction qui retourne le pointeur de fonction est dlopen dans la bibliothèque dynamique en c ++

4
VINOTH ENERGETIC

Voici comment le faire sans utiliser de typedef:

int c(){ return 0; }

int (* foo (void))(){  //compiles
return c;
}
4
user2875784
typedef void (*voidFn)();

void foo()
{
}

voidFn goo(char c)
{
    if (c == 'f') {
        return foo;
    }
    else {
        //..
    }
    // ..
}
4
ralphtheninja

Consultez ce site - http://cdecl.org

Vous aide à convertir l'anglais en déclarations C et inversement!

Truc cool!

Ce lien décode l'exemple dans la réponse d'erikallen. int (* return_f ()) (char)

2
m-sharp

C'est le code pour afficher le retour d'un pointeur de fonction. Vous devez définir la "signature de fonction" pour retourner en premier:

int returnsOne() {
     return 1;
}

typedef int(*fp)();

fp returnsFPtoReturnsOne() {
    &returnsOne;
}

Dans votre cas spécifique:

fp getFunctionFor(char code) {
    switch (code) {
        case 'a': return &functionA;
        case 'b': return &functionB;
    }
    return NULL;
}
2
Thomas Jung

En supposant que int f(char) et ret_f qui renvoie &f.

Manières compatibles C++ 98/C++ 03:

  • Laid:

    int (*ret_f()) (char) { return &f; }

  • Avec typedef

    typedef int (sig) (char);

    sig * ret_f () {return & f; }

ou

typedef int (*sig_ptr)(char);

sig_ptr ret_f() { return &f; }

Depuis C++ 11, nous avons en outre:

  • type de retour arrière:

    auto ret_f() -> int(*)(char) { return &f; }

    ou

    auto ret_f() -> decltype(&f) { return &f; }

  • typedef avec using:

    using sig = int(char);

sig* ret_f() { return &f; }

    ou

    using sig_ptr = int (*)(char);

sig_ptr ret_f() { return &f; }

C++ 14 ajoute:

  • auto déduction:

    auto ret_f() { return &f; }
1
Jarod42

Le moyen le plus simple consiste à saisir le type de pointeur vers la fonction que vous souhaitez, puis à l'utiliser

typedef void (*fnptr_t)(int, int);
fptr_t myfunc(char *) { ....
1
Chris Dodd

Je préfère renvoyer des objets et appeler l'opérateur (). De cette façon, votre fonction peut retourner une interface et toutes les classes peuvent en hériter. Autrement dit, si vous utilisez C++ et non C.

Ensuite, vous pouvez utiliser la méthode du facteur paramétré pour renvoyer les objets en fonction de votre entrée.

1
stefaanv

Quelque chose comme ça

#include <iostream>

typedef char (*fn_ptr_t)(char);

char a_fn(char c)
{
  return c + 1;
}

char b_fn(char c)
{
  return c + 2;
}

fn_ptr_t
return_function(char c)
{
  fn_ptr_t result = 0;

  switch (c)
 {
    case 'a':
      result = a_fn;
      break;
    case 'b':
      result = b_fn;
      break;
 }

 return result;
}

int
main()
{
  fn_ptr_t fn = return_function('a');

  std::cout << "a(l) = " << (fn)('l') << std::endl;

  return 0;
}
0
Beano