Simulation verschachtelter Funktionen in C ++

Question

In C funktioniert der folgende Code in GCC.

int foo( int foo_var )
{
 /*code*/
  int bar( int bar_var )  
  {
    /*code*/
    return bar_var;
  }
  return bar(foo_var);
}

Wie kann ich die gleiche Funktionalität verschachtelter Funktionen in C ++ mit dem GCC -Compiler erreichen? Machen Sie es nichts aus, wenn dies eine Anfängerfrage erscheint. Ich bin neu auf dieser Seite.

Answer 1

Verwandeln Sie Ihre Funktion in einen Fondor als Herb Sutter schlägt in diesem Artikel vor

Answer 2

Lokale Funktionen sind in C ++ nicht zulässig, aber lokale Klassen sind und Funktionen in lokalen Klassen zulässig. So:

int foo( int foo_var )
{
 /*code*/
  struct local 
  {
    static int bar( int bar_var )  
    {
      /*code*/
      return bar_var;
    }
  };
  return local::bar(foo_var);
}

In C ++ 0x hätten Sie auch die Möglichkeit, einen Funkartor mithilfe der Lambda -Syntax zu erstellen. Das ist in C ++ 03 etwas komplizierter, aber immer noch nicht schlecht, wenn Sie keine Variablen erfassen müssen:

int foo( int foo_var )
{
 /*code*/
  struct bar_functor
  {
    int operator()( int bar_var )  
    {
      /*code*/
      return bar_var;
    }
  } bar;
  return bar(foo_var);
}

Answer 3

Verwenden Sie den lokalen Funkor

#define lambda(return_type, function_body) \
struct { return_type operator () function_body }


int main ()
{
    lambda(int, (int x, int y) { return x > y ? x : y; } ) maxFunc;
    int m = maxFunc(1,2); //=> 2
    ...
}

Answer 4

Das Konstrukt, das verschachtelte Funktionen am nächsten kommt, ist das C ++ 11 Lambda.

void SomeFunction(int x)
{
    int var = 2;
    auto lambda = [&] (int param) -> int { return var + param; };

    printf("var + x = %d\n", lambda(x));
}

Lamdas ermöglichen es, Variablen aus dem äußeren Bereich zu verwenden (der [&] gibt an, alle Variablen automatisch aus dem äußeren Bereich durch Referenz zu erfassen). Eine Lambda, die keine Variablen aus dem äußeren Bereich verwendet (Verwendung []) kann in einen Funktionszeiger desselben Typs konvertiert werden und daher an Funktionen übergeben werden, die einen Funktionszeiger akzeptieren.

Answer 5

Sie könnten versuchen, Boost :: Phoenix zu verwenden (V2 ist ein Unterpackungsteil des Geistes, V3 ist in SVN/Trunk, da es ein eigenes Paket ist und in 1.47 sein sollte.

#include <boost/spirit/include/phoenix.hpp>
#include <boost/function.hpp>

using namespace boost::phoenix::arg_names;

int foo( int foo_var )
{
 /*code*/
  boost::function<int(int)> bar = _1 + 5;
  return bar(foo_var);
}

int main() {
return foo(1);
}

Answer 6

In C ++ können Sie mit anderen möglichen Mitteln den gleichen Effekt erzielen. Es gibt keine direkten verschachtelten Funktionsinformationen. Zwei hilfreiche Links:

http://www.respower.com/~earlye/programming/19990916.001.htm

http://www.devx.com/tips/tip/40841

Answer 7

Afaik, verschachtelte Funktionen sind in C ++ nicht erlaubt.

Answer 8

Ich weiß, dieser Thread ist alt. Aber eine C ++ 11 -Lösung wäre, Lambdas zu schreiben und sie anzurufen, wann immer