todas - if anidados c++

Simulando funciones anidadas en C++

Question

En C el siguiente código de trabajo considera que siempre uso gcc.

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

¿Cómo se puede lograr la misma funcionalidad de las funciones anidadas en C ++ en el compilador gcc? No importa si esto parece una pregunta para principiantes. Soy nuevo en este sitio.

Answer 1

AFAIK, las funciones anidadas no están permitidas en C ++.

Answer 2

Convierta su función en un funtor como sugiere Herb Sutter en este artículo

Answer 3

En C ++ puede lograr el mismo efecto por otros medios posibles. No hay implementaciones de funciones anidadas directas. Dos enlaces útiles:

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

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

Answer 4

La construcción que se acerca más a las funciones anidadas es 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 permite utilizar variables desde el ámbito externo (la [&] especifica para capturar automáticamente todas las variables del ámbito externo por referencia). Un lambda, que no utiliza ninguna variable del ámbito externo (use []) se puede convertir en un puntero de función del mismo tipo y, por lo tanto, se puede pasar a funciones que acepten un puntero de función.

Answer 5

Las funciones locales no están permitidas en C ++, pero las clases locales son y la función está permitida en las clases locales. Asi que:

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

En C ++ 0x, también tendría la opción de crear un functor usando la sintaxis lambda. Eso es un poco más complicado en C ++ 03, pero no está mal si no necesita capturar variables:

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

Answer 6

Puedes intentar usar boost :: phoenix (v2 es un subpaquete de spirit, v3 está en svn / trunk como su propio paquete y debería estar en 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 7

usar functor local

#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
...
}