wake-up-neo.com

Wie kann man eine Funktion veranlassen, einen Zeiger auf eine Funktion zurückzugeben? (C ++)

Ich versuche, eine Funktion zu erstellen, die ein Zeichen annimmt und dann einen Zeiger auf eine Funktion zurückgibt, je nachdem, was das Zeichen war. Ich bin nur nicht sicher, wie eine Funktion einen Zeiger auf eine Funktion zurückgeben soll.

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

Nein, im Ernst, benutze ein typedef :)

95
erikkallen

Erstellen Sie ein typedef für die Funktionssignatur:

typedef void (* FuncSig)(int param);

Dann deklarieren Sie Ihre Funktion als Rückgabe von FuncSig:

FuncSig GetFunction();
17
sean e

In C++ 11 können Sie nachfolgende Rückgabetypen verwenden, um die Syntax zu vereinfachen, z. eine Funktion übernehmen:

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

Dies kann von einer Funktion zurückgegeben werden (die ein Double benötigt, um dies zu zeigen):

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

Bei Verwendung eines nachgestellten Rückgabetyps ist dies etwas einfacher zu lesen:

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

Syntax zur Rückgabe der Funktion: 

return_type_of_returning_function (*function_name_which_returns_function)(actual_function_parameters) (returning_function_parameters)

ZB: Betrachten Sie die Funktion, die zurückgegeben werden muss, wie folgt:

void* (iNeedToBeReturend)(double iNeedToBeReturend_par)
{
}

Jetzt kann die Funktion iNeedToBeReturend als zurückgegeben werden

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

Ich fühlte mich sehr schlecht, dieses Konzept nach 3 Jahren Berufsleben im Programmieren zu lernen.

Bonus für Sie, wenn Sie auf den Funktionszeiger für die Dereferenzierung warten.

C++ Interviewfragen

Beispiel für eine Funktion, die den Funktionszeiger zurückgibt, ist dlopen in dynamic library in c ++

4
VINOTH ENERGETIC

So geht's ohne 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

Schauen Sie sich diese Seite an - http://cdecl.org

Hilft Ihnen, Englisch in C-Deklarationen und zurück umzuwandeln!

Cooles Zeug!

Dieser Link entschlüsselt das Beispiel in erikallens Antwort. int (* return_f ()) (char)

2
m-sharp

Dies ist der Code, um die Rückkehr eines Funktionszeigers anzuzeigen. Sie müssen die "Funktionssignatur" definieren, um zuerst zurückzukehren:

int returnsOne() {
     return 1;
}

typedef int(*fp)();

fp returnsFPtoReturnsOne() {
    &returnsOne;
}

In Ihrem speziellen Fall:

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

Angenommen, int f(char) und ret_f, Was &f Zurückgibt.

Mit C++ 98/C++ 03 kompatible Methoden:

  • Hässlicher Weg:

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

  • Mit typedef

    typedef int (sig) (char);

    sig * ret_f () {return & f; }

oder

typedef int (*sig_ptr)(char);

sig_ptr ret_f() { return &f; }

Seit C++ 11 haben wir zusätzlich:

  • abschließender Rückgabetyp:

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

    oder

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

  • typedef mit using:

    using sig = int(char);

sig* ret_f() { return &f; }

    oder

    using sig_ptr = int (*)(char);

sig_ptr ret_f() { return &f; }

C++ 14 fügt hinzu:

  • auto Abzug:

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

Am einfachsten ist es, den gewünschten Zeigertyp einzugeben und diesen dann zu verwenden

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

Ich ziehe es vor, Objekte zurückzugeben und den Operator () anzurufen. Auf diese Weise kann Ihre Funktion eine Schnittstelle zurückgeben und alle Klassen können davon erben. Das heißt, wenn Sie C++ und nicht C verwenden.

Anschließend können Sie die parametrisierte Faktormethode verwenden, um die Objekte basierend auf Ihrer Eingabe zurückzugeben.

1
stefaanv

Etwas wie das

#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