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