Simulando le funzioni nidificate in c ++

Question

In C il seguente codice funziona in GCC.

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

Come posso ottenere la stessa funzionalità delle funzioni nidificate in C ++ con il compilatore GCC? Non importa se questa sembra una domanda per principianti. Sono nuovo in questo sito.

Answer 1

Trasforma la tua funzione in un funtore come Herb Sutter suggerisce in questo articolo

Answer 2

Le funzioni locali non sono consentite in C ++, ma le classi locali sono e la funzione è consentita nelle classi locali. Così:

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, avresti anche la possibilità di creare un funtor utilizzando la sintassi Lambda. È un po 'più complicato in C ++ 03, ma ancora non male se non è necessario catturare le variabili:

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

Usa il funtore locale

#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

Il costrutto che si avvicina alle funzioni nidificate è la lambda C ++ 11.

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

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

Lamdas consentono di utilizzare le variabili dall'ambito esterno ([&] specifica per catturare automaticamente tutte le variabili dall'ambito esterno per riferimento). Un lambda, che non utilizza alcuna variabile dall'ambito esterno (usa []) può essere convertito in un puntatore di funzione dello stesso tipo e può quindi essere passato alle funzioni che accettano un puntatore di funzione.

Answer 5

Potresti provare a usare Boost :: Phoenix (V2 è un sottopagzo di spirito, V3 è in SVN/trunk come il proprio pacchetto e dovrebbe essere in 1.47)

#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 ++ puoi ottenere lo stesso effetto con altri mezzi possibili. Non ci sono implementazioni di funzioni nidificate dirette. Due link utili:

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

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

Answer 7

Afaik, le funzioni nidificate non sono consentite in C ++.

Answer 8

So che questo thread è vecchio. Ma una soluzione C ++ 11 sarebbe quella di scrivere Lambdas e chiamarli ogni volta che lo desiderava