C++ - Function declarations inside function scopes?

Question

I was going through C++11 standard draft a while ago and came across this one (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)
}

This had to do with default arguments to functions. What struck me was the fact that function declarations appeared at the function scope. Why is that? What is this feature used for?

Answer 1

Although I had no idea you can do this, I tested it and it works. I guess you may use it to forward-declare functions defined later, like below:

#include <iostream>

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

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

int main()
{
    f();
}

If you remove the forward declaration, the program won't compile. So in this way you can have some kind of scope-based forward declaration visibility.

Answer 2

Any function/variable declaration has its visibility and scope. For example, if in class, only class members can see to it. If in function only the function can have visibility to it, after we declare the variable or function.

We generally use data structures within function scope. But compiler's grammar rule is applicable to both, as function in itself has address and hence visibility is applicable to it as well.