Вложенные функции не позволяются, но почему прототипы вложенной функции позволяются? [C++]

Кстати, в C ++ 03 есть обходной способ определения локальных функций. Это требует злоупотребления функцией локального класса:

int main()
{
    struct Local
    {
        static string Some()
        {
            return "";
        }
    };
    std::cout << Local::Some() << std::endl;
}

Это соглашение C - как и многие другие - принятое C ++.

Возможность объявлять функцию внутри другой функции в C - это решение, которое большинство программистов, вероятно, сочтет прискорбным. и ненужное. В частности, с современным дизайном ООП, где определения функций сравнительно меньше, чем в C.

Если вы хотите иметь функции, которые существуют только в рамках другой функции, два варианта: boost :: lambda и C ++ 1x лямбда .

Относительно того, почему ваше объявление

void f() {
    void g(); g();
}

лучше, чем это

void g();
void f() {
    g();
}

Обычно хорошо, если вы сохраняете объявления как можно более локальными, чтобы в результате возникало как можно меньше конфликтов имен. Я говорю, что это спорно, является ли объявить функцию локально (таким образом) действительно повезло, так как я думаю, что это все-таки лучше обычный включать его заголовок, а затем перейти на «обычный» путь, который также является менее запутанным для людей не зная об этом. Иногда также полезно обойти теневую функцию

void f() {
    int g; 
    // oops, ::g is shadowed. But we can work around that
    {
        void g(); g();
    }
}

Конечно, в C ++ мы могли вызвать функцию g , используя its_namespace :: g () - но в старые времена C, это было бы невозможно, и эта вещь позволяла программисту по-прежнему получать доступ к функции. Также обратите внимание, что хотя синтаксически это не то же самое, семантически следующее также объявляет функцию в локальной области, которая на самом деле нацелена на другую область.

int main() {
    using std::exit;
    exit();
}

В качестве примечания: есть больше ситуаций, подобных этой, когда целевая область действия объявления - , а не область, в которой появляется это объявление. Как правило, объект, который вы объявляете, становится членом области в котором появляется объявление. Но это не всегда так. Рассмотрим, например, объявления друзей, где это происходит

struct X { friend void f() { std::cout << "WoW"; } };
int main() { void f(); f(); } // works!

Несмотря на то, что объявление функции (и определение!) f произошло в пределах X , сущность (сама функция ) стал членом охватывающего пространства имен.

есть и другие ситуации, подобные этой, где целевая область действия объявления - , а не область, в которой появляется это объявление. Как правило, объявляемая вами сущность становится членом области, в которой появляется объявление. Но это не всегда так. Рассмотрим, например, объявления друзей, где это происходит

struct X { friend void f() { std::cout << "WoW"; } };
int main() { void f(); f(); } // works!

Несмотря на то, что объявление функции (и определение!) f произошло в пределах X , сущность (сама функция ) стал членом охватывающего пространства имен.

есть и другие ситуации, подобные этой, где целевая область действия объявления - , а не область, в которой появляется это объявление. Как правило, объявляемая вами сущность становится членом области, в которой появляется объявление. Но это не всегда так. Рассмотрим, например, объявления друзей, где это происходит

struct X { friend void f() { std::cout << "WoW"; } };
int main() { void f(); f(); } // works!

Несмотря на то, что объявление функции (и определение!) f произошло в пределах X , сущность (сама функция ) стал членом охватывающего пространства имен.

Рассмотрим, например, объявления друзей, где это происходит

struct X { friend void f() { std::cout << "WoW"; } };
int main() { void f(); f(); } // works!

Несмотря на то, что объявление функции (и определение!) f произошло в пределах X , сущность (сама функция ) стал членом охватывающего пространства имен.

Рассмотрим, например, объявления друзей, где это происходит

struct X { friend void f() { std::cout << "WoW"; } };
int main() { void f(); f(); } // works!

Несмотря на то, что объявление функции (и определение!) f произошло в пределах X , сущность (сама функция ) стал членом охватывающего пространства имен.

Прототипы функций - это подсказки для компилятора. Они указывают, что функции реализованы где-то еще, если еще не обнаружены . Ничего лишнего.

Когда вы объявляете прототип, вы в основном говорите компилятору подождать, пока компоновщик его разрешит. В зависимости от того, где вы пишете прототип, применяются правила определения объема. Нет ничего технически неправильного в написании прототипа внутри вашей функции main () (хотя IMHO немного запутаннее), это просто означает, что функция известна только локально внутри main (). Если бы вы объявили прототип в верхней части исходного файла (или чаще в файле заголовка), прототип / функция были бы известны во всем исходном коде.

string foo()
{
  string ret = someString();  // Error
  return ret; 
}

int main(int argc,char**argv)
{
   string someString();
   string s = somestring(); // OK
   ...
}