C++ - Dichiarazioni di funzioni all'interno degli ambiti di funzione?

Question

stavo attraversando C++11 standard draft qualche tempo fa e sono imbattuto in questo uno (in §8.3.6, p 204).:

void g(int = 0, ...); // OK, ellipsis is not a parameter so it can follow 

// a parameter with a default argument 
void f(int, int); 
void f(int, int = 7); 
void h() { 
    f(3); // OK, calls f(3, 7) 
    void f(int = 1, int); // error: does not use default 
    // from surrounding scope 
} 
void m() { 
    void f(int, int); // has no defaults 
    f(4); // error: wrong number of arguments 
    void f(int, int = 5); // OK 
    f(4); // OK, calls f(4, 5); 
    void f(int, int = 5); // error: cannot redefine, even to 
    // same value 
} 
void n() { 
    f(6); // OK, calls f(6, 7) 
} 

questo ha avuto a che fare con argomenti di default alle funzioni. Ciò che mi ha colpito è il fatto che le dichiarazioni di funzione sono apparse nell'ambito della funzione. Perché? A cosa serve questa caratteristica?

Answer 1

Sebbene non avessi idea di poterlo fare, l'ho testato e funziona. Credo che si può usare per le funzioni definite in seguito al futuro dichiarare, come di seguito:

#include <iostream> 

void f() 
{ 
    void g(); // forward declaration 
    g(); 
} 

void g() 
{ 
    std::cout << "Hurray!" << std::endl; 
} 

int main() 
{ 
    f(); 
} 

Se si rimuove la dichiarazione in avanti, il programma non verrà compilato. In questo modo è possibile avere una sorta di visibilità delle dichiarazioni anticipate basate sull'ambito.

Answer 2

Qualsiasi dichiarazione di funzione/variabile ha la sua visibilità e portata. Ad esempio, se in classe, solo i membri della classe possono vederlo. Se in funzione solo la funzione può avere visibilità, dopo aver dichiarato la variabile o la funzione.

Generalmente utilizziamo strutture dati nell'ambito della funzione. Ma la regola grammaticale del compilatore è applicabile ad entrambi, poiché la funzione in sé ha un indirizzo e quindi anche la visibilità è applicabile ad esso.