Можем ли мы иметь функции внутри функций в C++?

Я имею в виду что-то вроде:

int main() 
{
  void a() 
  {
      // code
  }
  a();

  return 0;
}

ОТВЕТЫ

Ответ 1

Модерн C++ - Да, с лямбдами!

В текущих версиях C++ (C++ 11, C++ 14 и C++ 17) у вас могут быть функции внутри функций в форме лямбды:

int main() {
    // This declares a lambda, which can be called just like a function
    auto print_message = [](std::string message) 
    { 
        std::cout << message << "\n"; 
    };

    // Prints "Hello!" 10 times
    for(int i = 0; i < 10; i++) {
        print_message("Hello!"); 
    }
}

Лямбда также может изменять локальные переменные посредством ** захвата по ссылке *. С помощью захвата по ссылке лямбда имеет доступ ко всем локальным переменным, объявленным в области лямбда. Он может изменять и изменять их в обычном режиме.

int main() {
    int i = 0;
    // Captures i by reference; increments it by one
    auto addOne = [&] () {
        i++; 
    };

    while(i < 10) {
        addOne(); //Add 1 to i
        std::cout << i << "\n";
    }
}

C++ 98 и C++ 03 - Не напрямую, но да со статическими функциями внутри локальных классов

C++ не поддерживает это напрямую.

Тем не менее, у вас могут быть локальные классы, и у них могут быть функции (non- static или static), так что вы можете получить это в некоторой степени, хотя это будет немного клуджем:

int main() // it int, dammit!
{
  struct X { // struct as good as class
    static void a()
    {
    }
  };

  X::a();

  return 0;
}

Однако я бы поставил под сомнение практику. Все знают (хорошо, теперь, когда вы это делаете, в любом случае :)) C++ не поддерживает локальные функции, поэтому они привыкли их не иметь. Однако они не используются для этого клуджа. Я потратил бы довольно много времени на этот код, чтобы убедиться, что он действительно только для локальных функций. Нехорошо.

Ответ 2

Для всех намерений и целей C++ поддерживает это через лямбды: 1

int main() {
    auto f = []() { return 42; };
    std::cout << "f() = " << f() << std::endl;
}

Здесь f является лямбда-объектом, который действует как локальная функция в main. Захваты могут быть определены, чтобы позволить функции получить доступ к локальным объектам.

За кулисами f - это функциональный объект (т.е. Объект типа, который предоставляет operator()). Тип объекта функции создается компилятором на основе лямбды.

1, так как C++ 11

Ответ 3

Локальные классы уже упомянуты, но вот способ позволить им проявиться еще больше как локальные функции, используя перегрузку operator() и анонимный класс:

int main() {
    struct {
        unsigned int operator() (unsigned int val) const {
            return val<=1 ? 1 : val*(*this)(val-1);
        }
    } fac;

    std::cout << fac(5) << '\n';
}

Я не советую использовать это, это просто забавный трюк (может сделать, но imho не должен).

2014 Обновление:

С появлением С++ 11 назад вы можете теперь иметь локальные функции, синтаксис которых немного напоминает JavaScript:

auto fac = [] (unsigned int val) {
    return val*42;
};

Ответ 4

Нет.

Что вы пытаетесь сделать?

обходной путь:

int main(void)
{
  struct foo
  {
    void operator()() { int a = 1; }
  };

  foo b;
  b(); // call the operator()

}

Ответ 5

Старый ответ: Вы можете, вроде как, но вы должны обмануть и использовать фиктивный класс:

void moo()
{
    class dummy
    {
    public:
         static void a() { printf("I'm in a!\n"); }
    };

    dummy::a();
    dummy::a();
}

Более новый ответ: более новые версии C++ также поддерживают лямбды, чтобы сделать это лучше/правильно. Смотрите ответы выше на странице.

Ответ 6

Нет, это не разрешено. Ни С++, ни С++ не поддерживают эту функцию по умолчанию, однако TonyK указывает (в комментариях), что есть расширения для компилятора GNU C, которые активируют это поведение в C.

Ответ 7

Вы не можете определить свободную функцию внутри другого в С++.

Ответ 8

Как уже упоминалось, вы можете использовать вложенные функции, используя расширения gnu-языка в gcc. Если вы (или ваш проект) привязаны к gcc toolchain, ваш код будет в основном переносимым в разных архитектурах, нацеленных на компилятор gcc.

Однако, если есть возможное требование, что вам может понадобиться скомпилировать код с другой инструментальной цепочкой, я бы держался подальше от таких расширений.

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

Но, как и все, они могут быть открыты для злоупотреблений.

Печально, что C/С++ не поддерживает такие функции, как стандарт. Большинство вариантов pascal и Ada do (почти все языки на Алголе). То же самое с JavaScript. То же самое с современными языками, такими как Scala. То же самое с почтенными языками, такими как Erlang, Lisp или Python.

И так же, как и с C/С++, к сожалению, Java (с которой я зарабатываю большую часть своей жизни) не делает.

Я упоминаю Java здесь, потому что вижу несколько плакатов, предлагающих использование классов и методов класса в качестве альтернативы вложенным функциям. И это также типичный обходной путь в Java.

Короткий ответ: Нет.

Это приводит к искусственной, ненужной сложности иерархии классов. При равных условиях идеальным является наличие иерархии классов (и ее охватывающих пространств имен и областей), представляющих фактический домен как можно более простой.

Вложенные функции помогают справиться с "private", сложностью внутри функции. Не имея этих средств, следует попытаться избежать распространения этой сложности "private" и в одну модель класса.

В программном обеспечении (и в любой инженерной дисциплине) моделирование - это вопрос компромиссов. Таким образом, в реальной жизни будут оправданы исключения из этих правил (или, скорее, рекомендации). Однако действуйте осторожно.

Ответ 9

Все эти трюки просто выглядят (более или менее) как локальные функции, но они не работают так. В локальной функции вы можете использовать локальные переменные суперфункций. Это своего рода полу-глобалы. Без этих трюков это можно сделать. Самый близкий лямбда-трюк от С++ 0x, но его закрытие связано во время определения, а не время использования.

Ответ 10

Вы не можете иметь локальные функции в C++. Однако в C++ 11 есть лямбды. Лямбды - это переменные, которые работают как функции.

Лямбда имеет тип std::function (на самом деле это не совсем верно, но в большинстве случаев можно предположить, что это так). Чтобы использовать этот тип, вам нужно #include <functional>. std::function является шаблоном, принимающим в качестве аргумента шаблона тип возвращаемого значения и типы аргумента, с синтаксисом std::function<ReturnType(ArgumentTypes). Например, std::function<int(std::string, float)> - это лямбда-выражение, возвращающее int и принимающее два аргумента, один std::string и один float. Наиболее распространенным является std::function<void()>, который ничего не возвращает и не принимает аргументов.

Как только лямбда объявлена, она вызывается так же, как и обычная функция, используя синтаксис lambda(arguments).

Чтобы определить лямбду, используйте синтаксис [captures](arguments){code} (есть другие способы сделать это, но я не буду здесь их упоминать). arguments - это аргументы, которые принимает лямбда, а code - это код, который должен выполняться при вызове лямбды. Обычно вы помещаете [=] или [&] качестве снимков. [=] означает, что вы перехватываете все переменные в области, в которой значение определяется значением, что означает, что они сохранят значение, которое они имели при объявлении лямбды. [&] означает, что вы захватываете все переменные в области видимости по ссылке, что означает, что они всегда будут иметь свое текущее значение, но если они будут удалены из памяти, программа потерпит крах. Вот некоторые примеры:

#include <functional>
#include <iostream>

int main(){
    int x = 1;

    std::function<void()> lambda1 = [=](){
        std::cout << x << std::endl;
    };
    std::function<void()> lambda2 = [&](){
        std::cout << x << std::endl;
    };

    x = 2;
    lambda1();    //Prints 1 since that was the value of x when it was captured and x was captured by value with [=]
    lambda2();    //Prints 2 since that the current value of x and x was captured by value with [&]

    std::function<void()> lambda3 = [](){}, lambda4 = [](){};    //I prefer to initialize these since calling an uninitialized lambda is undefined behavior.
                                                                 //[](){} is the empty lambda.

    {
        int y = 3;    //y will be deleted from the memory at the end of this scope
        lambda3 = [=](){
            std::cout << y << endl;
        };
        lambda4 = [&](){
            std::cout << y << endl;
        };
    }

    lambda3();    //Prints 3, since that the value y had when it was captured

    lambda4();    //Causes the program to crash, since y was captured by reference and y doesn't exist anymore.
                  //This is a bit like if you had a pointer to y which now points nowhere because y has been deleted from the memory.
                  //This is why you should be careful when capturing by reference.

    return 0;
}

Вы также можете захватить определенные переменные, указав их имена. Просто указав их имя, вы поймете их по значению, указав их имя с & перед тем, как захватите их по ссылке. Например, [=, &foo] будет захватывать все переменные по значению, кроме foo который будет захвачен по ссылке, а [&, foo] захватит все переменные по ссылке, кроме foo который будет захвачен по значению. Вы также можете захватывать только определенные переменные, например, [&foo] захватывает foo по ссылке и не захватывает другие переменные. Вы также можете перехватить переменные вообще без использования []. Если вы попытаетесь использовать переменную в лямбде, которую вы не захватили, она не скомпилируется. Вот пример:

#include <functional>

int main(){
    int x = 4, y = 5;

    std::function<void(int)> myLambda = [y](int z){
        int xSquare = x * x;    //Compiler error because x wasn't captured
        int ySquare = y * y;    //OK because y was captured
        int zSquare = z * z;    //OK because z is an argument of the lambda
    };

    return 0;
}

Вы не можете изменить значение переменной, которая была захвачена значением внутри лямбды (переменные, захваченные значением, имеют тип const внутри лямбды). Для этого вам нужно захватить переменную по ссылке. Вот пример:

#include <functional>

int main(){
    int x = 3, y = 5;
    std::function<void()> myLambda = [x, &y](){
        x = 2;    //Compiler error because x is captured by value and so it of type const int inside the lambda
        y = 2;    //OK because y is captured by reference
    };
    x = 2;    //This is of course OK because we're not inside the lambda
    return 0;
}

Кроме того, вызов неинициализированных лямбда-выражений является неопределенным поведением и обычно приводит к сбою программы. Например, никогда не делайте так:

std::function<void()> lambda;
lambda();    //Undefined behavior because lambda is uninitialized

Примеры

Вот код для того, что вы хотели сделать в своем вопросе, используя лямбды:

#include <functional>    //Don't forget this, otherwise you won't be able to use the std::function type

int main(){
    std::function<void()> a = [](){
        // code
    }
    a();
    return 0;
}

Вот более продвинутый пример лямбды:

#include <functional>    //For std::function
#include <iostream>      //For std::cout

int main(){
    int x = 4;
    std::function<float(int)> divideByX = [x](int y){
        return (float)y / (float)x;    //x is a captured variable, y is an argument
    }
    std::cout << divideByX(3) << std::endl;    //Prints 0.75
    return 0;
}

Ответ 11

Позвольте мне разместить здесь решение для С++ 03, которое я считаю максимально возможным. *

#define DECLARE_LAMBDA(NAME, RETURN_TYPE, FUNCTION) \
    struct { RETURN_TYPE operator () FUNCTION } NAME;

...

int main(){
  DECLARE_LAMBDA(demoLambda, void, (){ cout<<"I'm a lambda!"<<endl; });
  demoLambda();

  DECLARE_LAMBDA(plus, int, (int i, int j){
    return i+j;
  });
  cout << "plus(1,2)=" << plus(1,2) << endl;
  return 0;
}

(*) в мире С++ с использованием макросов никогда не считается чистым.

Ответ 12

Но мы можем объявить функцию внутри main():

int main()
{
    void a();
}

Несмотря на то, что синтаксис верен, иногда это может привести к "наиболее неприятному анализу":

#include <iostream>


struct U
{
    U() : val(0) {}
    U(int val) : val(val) {}

    int val;
};

struct V
{
    V(U a, U b)
    {
        std::cout << "V(" << a.val << ", " << b.val << ");\n";
    }
    ~V()
    {
        std::cout << "~V();\n";
    }
};

int main()
{
    int five = 5;
    V v(U(five), U());
}

= > нет выхода программы.

(Только предупреждение Clang после компиляции).

Самый неприятный синтаксис С++ снова

Ответ 13

Когда вы пытаетесь реализовать функцию в другом теле функции, вы должны получить эту error как недопустимое определение:

error C2601: 'a' : local function definitions are illegal
IntelliSense: expected a ';'

Так что не пытайтесь снова.