Fonctions imbriquées en simulant C ++

Question

En C le code suivant fonctionne dans gcc.

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

Comment puis-je obtenir les mêmes fonctionnalités de fonctions imbriquées en C ++ avec le compilateur gcc? Ca ne me dérange pas si cela semble être une question de débutant. Je suis nouveau sur ce site.

Answer 1

Transformez votre fonction en tant que foncteur Herb Sutter suggère dans cet article

Answer 2

Fonctions locales ne sont pas autorisés en C ++, mais les classes locales sont et la fonction sont autorisés dans les classes locales. Donc:

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, vous aussi, vous avez la possibilité de créer un foncteur en utilisant la syntaxe lambda. C'est un peu plus compliqué en C ++ 03, mais quand même pas mal si vous ne avez pas besoin de variables de capture:

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

utiliser foncteur 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

Le produit de construction qui se rapproche le plus de fonctions imbriquées est le 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 permettent d'utiliser des variables du champ extérieur (les [&] Précise pour capturer automatiquement toutes les variables du champ d'application externe par référence). A lambda, qui n'utilise les variables de la portée extérieure (utilisation []) peut être converti en un pointeur de fonction de même type et peut donc être transmis à des fonctions d'acceptation d'un pointeur de fonction.

Answer 5

Vous pouvez essayer d'utiliser boost :: Phoenix (v2 est un sous-paquet d'esprit, v3 est dans svn / trunk comme son propre paquet et devrait être 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 6

En C ++ vous pouvez obtenir le même effet par d'autres moyens. Il n'y a pas de mise en oeuvre de fonction directe imbriquées. Deux liens utiles:

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

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

Answer 7

AFAIK, les fonctions imbriquées ne sont pas autorisés en C ++.

Answer 8

Je sais que ce fil est vieux. Mais un C ++ 11 solution serait de lambdas d'écriture et de les appeler à chaque fois voulu