¿es posible en C o C++ crear una función dentro de otra?

Question

¿Podría alguien decirme si esto es posible en C o C++?

void fun_a(); 
//int fun_b(); 
... 
main(){ 
    ... 
    fun_a(); 
    ... 
    int fun_b(){ 
    ... 
    } 
    ... 
} 

o algo similar, como p. una clase dentro de una función?

gracias por sus respuestas,

Answer 1

Guau, ¡me sorprende que nadie haya dicho que sí! Las funciones gratuitas no pueden anidarse, pero los funtores y las clases en general pueden hacerlo.

void fun_a(); 
//int fun_b(); 
... 
main(){ 
    ... 
    fun_a(); 
    ... 
    struct { int operator()() { 
    ... 
    } } fun_b; 

    int q = fun_b(); 
    ... 
} 

Puede darle al operador un constructor y pasar referencias a variables locales para conectarlo al ámbito local. De lo contrario, puede acceder a otros tipos locales y variables estáticas. Sin embargo, las clases locales no pueden ser argumentos para las plantillas.

Answer 2

No es posible declarar una función dentro de una función. Sin embargo, puede declarar una función dentro de un espacio de nombres o dentro de una clase en C++.

Answer 3

C++ no admite funciones anidadas, sin embargo, puede usar algo como boost::lambda.

Answer 4

No, pero en C++ 0x puede http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions, que puede tardar unos años más para ser totalmente compatible. El estándar no está completo en el momento de escribir esto.

operación -Editar-

Sí

Si puede utilizar MSVC 2010. Me corrió el código de abajo con éxito

void test() 
{ 
[]() { cout << "Hello function\n"; }(); 
auto fn = [](int x) -> int { cout << "Hello function (" << x << " :))\n"; return x+1; }; 
auto v = fn(2); 
fn(v); 
} 

salida

Hello function 
Hello function (2 :)) 
Hello function (3 :)) 

(I escribió en >> c:\dev\loc\uniqueName.txt la sección de argumentos de trabajo del proyecto y la copia pegaron este resultado)

Answer 5

C - Sí para gcc as an extension.

C++ - No.

Answer 6

No

en C estándar, pero gcc y clang apoyarlos como una extensión. Ver the gcc online manual.

Answer 7

Aunque C y C++ ambos prohíben las funciones anidadas, algunos compiladores las admiten de todos modos (por ejemplo, si la memoria sirve, gcc puede, al menos con los indicadores de la derecha). Un functor anidado es mucho más portátil.

Answer 8

El término que está buscando es función anidada. Ni el estándar C ni el C++ permiten funciones anidadas, pero GNU C lo permite como una extensión. Aquí hay un buen wikipedia article sobre el tema.

Answer 9

Clang/Apple están trabajando en 'bloques', funciones anónimas en C! :-D

^ (void) { printf("hello world\n"); }

información here y spec here y Ars Technica tiene a bit en él

Answer 10

No hay funciones anidadas en C/C++, por desgracia.

Answer 11

No, y hay al menos una razón por la que complicar las cosas permitirlo. Generalmente, se espera que las funciones anidadas tengan acceso al alcance adjunto. Esto lo hace para que la "pila" ya no se pueda representar con una estructura de datos de pila. En cambio, se necesita un árbol completo.

Considere el siguiente código que realmente se compila en gcc como sugiere KennyTM.

#include <stdio.h> 

typedef double (*retdouble)(); 

retdouble wrapper(double a) { 
    double square() { return a * a; } 

    return square; 
} 

int use_stack_frame(double b) { 
    return (int)b; 
} 

int main(int argc, char** argv) { 
    retdouble square = wrapper(3); 
    printf("expect 9 actual %f\n", square()); 
    printf("expect 3 actual %d\n", use_stack_frame(3)); 
    printf("expect 16 actual %f\n", wrapper(4)()); 
    printf("expect 9 actual %f\n", square()); 
    return 0; 
} 

he puesto lo que la mayoría de la gente espera para ser impreso, pero en realidad, esto se imprime:

expect 9 actual 9.000000 
expect 3 actual 3 
expect 16 actual 16.000000 
expect 9 actual 16.000000 

en cuenta que la última línea llama a la función "cuadrado", pero el " un "valor al que accede se modificó durante la llamada envoltura (4). Esto se debe a que no se crea un marco de "pila" separado para cada invocación de "envoltorio".

Tenga en cuenta que este tipo de funciones anidadas son bastante comunes en otros lenguajes que las admiten como lisp y python (e incluso versiones recientes de Matlab). Conducen a algunas capacidades de programación funcional muy poderosas, pero impiden el uso de una pila para contener marcos de ámbito local.

Answer 12

Puede anidar un local class dentro de una función, en cuyo caso la clase solo será accesible para esa función. A continuación, puede escribir su función anidada como un miembro de la clase local:

#include <iostream> 

int f() 
{ 
    class G 
    { 
    public: 
     int operator()() 
     { 
      return 1; 
     } 
    } g; 

    return g(); 
} 

int main() 
{ 
    std::cout << f() << std::endl; 
} 

tener en cuenta, sin embargo, que no se puede pasar una función definida en una clase local a un algoritmo STL, como sort().

int f() 
{ 
    class G 
    { 
    public: 
     bool operator()(int i, int j) 
     { 
      return false; 
     } 
    } g; 

    std::vector<int> v; 

    std::sort(v.begin(), v.end(), g); // Fails to compile 
} 

El error que se podrían obtener de GCC es "test.cpp: 18: Error: ninguna función coincidente para la llamada a` sort (__ __ gnu_cxx :: normal_iterator>>, __gnu_cxx :: __ normal_iterator>>, f () :: G &) ' "

Answer 13

no se puede crear una función dentro de otra función en C++.

Sin embargo, puede crear un funtor clase local:

int foo() 
{ 
    class bar 
    { 
    public: 
     int operator()() 
     { 
     return 42; 
     } 
    }; 
    bar b; 
    return b(); 
} 

en C++ 0x puede crear una expresión lambda:

int foo() 
{ 
    auto bar = []()->int{return 42;}; 
    return bar(); 
} 

Answer 14

Como han mencionado otras respuestas, estándar de C y C++ hacer no le permite definir funciones anidadas. (Algunos compiladores podrían permitirlo como una extensión, pero no puedo decir que lo haya visto usado).

Puede declarar otra función dentro de una función para que pueda ser llamado, pero la definición de esa función debe existir fuera de la función actual:

#include <stdlib.h> 
#include <stdio.h> 

int main(int argc, char* argv[]) 
{ 
    int foo(int x); 

    /*  
    int bar(int x) { // this can't be done 
     return x; 
    } 
    */ 

    int a = 3; 

    printf("%d\n", foo(a)); 

    return 0; 
} 


int foo(int x) 
{ 
    return x+1; 
} 

Una declaración de la función sin una explícita 'especificador de vinculación 'tiene un enlace extern.Entonces, mientras la declaración del nombre foo en la función main() tiene un alcance de main(), se vinculará a la función foo() que se define más adelante en el archivo (o en otro archivo si está definido foo()).

Answer 15

void foo() 
{ 
    class local_to_foo 
    { 
     public: static void another_foo() 
     { printf("whatevs"); } 
    }; 
    local_to_foo::another_foo(); 
} 

O lambda's en C++ 0x.