è possibile in C o C++ creare una funzione all'interno di un'altra?

Question

Qualcuno potrebbe dirmi se questo è possibile in C o C++?

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

o qualcosa di simile, come ad es. una classe in una funzione?

grazie per le vostre risposte,

Answer 1

Wow, sono sorpreso che nessuno abbia detto di si! Le funzioni libere non possono essere annidate, ma i funtori e le classi in generale possono.

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

    int q = fun_b(); 
    ... 
} 

Si può dare il funtore un costruttore e trasmettere i riferimenti alle variabili locali per collegarlo al campo di applicazione locale. Altrimenti, può accedere ad altri tipi locali e variabili statiche. Le classi locali non possono essere argomenti ai template, però.

Answer 2

Non è possibile dichiarare una funzione all'interno di una funzione. È possibile, tuttavia, dichiarare una funzione all'interno di uno spazio dei nomi o all'interno di una classe in C++.

Answer 3

C++ non supporta le funzioni annidate, tuttavia è possibile utilizzare qualcosa come boost::lambda.

Answer 4

No, ma in C++ 0x è possibile http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions che potrebbe richiedere alcuni anni per supportare completamente. Lo standard non è completo al momento della stesura di questo documento.

operativa -Editazione-

Sì

Se è possibile utilizzare MSVC 2010. Ho eseguito il codice qui sotto con successo

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); 
} 

uscita

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

(ho scritto in >> c:\dev\loc\uniqueName.txt la sezione degli argomenti di lavoro del progetto e copia incollata questo risultato)

Answer 5

C - Sì per gcc as an extension.

C++ - No.

Answer 6

Non in serie C, ma gcc e clang li supportano come estensione. Vedi the gcc online manual.

Answer 7

Sebbene C e C++ proibiscano entrambe le funzioni annidate, alcuni compilatori supportano comunque (ad es., Se la memoria serve, gcc può, almeno con i flag corretti). Tuttavia, un functor annidato è molto più portatile.

Answer 8

Il termine che stai cercando è funzione nidificata. Né C standard né C++ standard consentono funzioni nidificate, ma GNU C lo consente come un'estensione. Ecco un buon wikipedia article sull'argomento.

Answer 9

Clang/Apple stanno lavorando su "blocchi", funzioni anonime in C! :-D

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

informazioni here e spec here, e ars technica ha a bit su di esso

Answer 10

Nessun funzioni annidate in C/C++, purtroppo.

Answer 11

No, e c'è almeno una ragione per cui complicherebbe le cose per consentirlo. In genere, è previsto che le funzioni annidate abbiano accesso all'ambito che racchiude. Ciò lo rende così che lo "stack" non può più essere rappresentato con una struttura di dati dello stack. Invece è necessario un albero completo.

Si consideri il seguente codice che in realtà compila in gcc come suggerisce 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; 
} 

ho messo quello che la maggior parte delle persone si aspettano di essere stampato, ma in realtà, questo viene stampato:

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

Si noti che l'ultima riga chiama la funzione "piazza", ma il " un "valore a cui accede è stato modificato durante la chiamata wrapper (4). Questo perché un frame "stack" separato non viene creato per ogni invocazione di "wrapper".

Si noti che questi tipi di funzioni annidate sono in realtà abbastanza comuni in altri linguaggi che li supportano come lisp e python (e anche versioni recenti di Matlab). Portano a funzionalità di programmazione funzionale molto potenti, ma precludono l'uso di uno stack per contenere frame di ambito locali.

Answer 12

È possibile nidificare un local class all'interno di una funzione, nel qual caso la classe sarà accessibile solo a tale funzione. Si potrebbe quindi scrivere la funzione nidificata come membro della classe locale:

#include <iostream> 

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

    return g(); 
} 

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

tenere a mente, però, che non è possibile passare una funzione definita in una classe locale per un algoritmo STL, come ad esempio 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 
} 

L'errore che si otterrebbe da gcc è "test.cpp: 18: Errore: nessuna funzione di corrispondenza per la chiamata a` sort (__ gnu_cxx :: __ normal_iterator>>, __gnu_cxx :: __ normal_iterator>>, f () :: G &) ' "

Answer 13

non è possibile creare una funzione all'interno di un'altra funzione in C++.

È possibile comunque creare un funtore classe locale:

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

in C++ 0x è possibile creare un'espressione lambda:

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

Answer 14

Come altre risposte hanno detto, di serie C e C++ fare non consente di definire le funzioni nidificate. (Alcuni compilatori potrebbero consentirlo come estensione, ma non posso dire di averlo visto usato).

È possibile dichiarare un'altra funzione all'interno di una funzione in modo che si può chiamare, ma la definizione di tale funzione deve esistere al di fuori della funzione corrente:

#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 dichiarazione funzione senza un esplicito 'linkage specificatore 'ha un collegamento extern.Pertanto, mentre la dichiarazione del nome foo nella funzione main() è impostata su main(), verrà collegata alla funzione foo() definita in un secondo momento nel file (o in un altro file, se è stato definito foo()).

Answer 15

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

Oppure lambda in C++ 0x.