Блог

 #include <iostream>
int foo(int i)
{
    const auto a = [amp;i](){ i = 7; return i * i; };
    a();
    return i;
}
int main()
{
    std::cout << foo(42) << std::endl;
    return 0;
}
 

Это компилирует( g -std=c 11 -Wall -Wextra -Wpedantic main.cpp ) и возвращает 49 . Что меня удивляет, потому что, объявляя a объект constant , я ожидал i , что на него будут ссылаться как const intamp; . Очевидно, что это не так, почему?

Лямбда-выражения похожи на не-лямбда-выражения, за исключением того, что детали их реализации скрыты. Поэтому может быть проще объяснить, используя не-лямбда-функтор:

 #include <iostream>
int foo(int i)
{
    struct F {
      int amp;i;
      int operator()() const { i = 7; return i * i; }
    };
    const F a {i};
    a();
    return i;
}
int main()
{
    std::cout << foo(42) << std::endl;
    return 0;
}
 

F имеет int amp; ссылочный элемент i . const F невозможно изменить данные его экземпляра, но модификация i не является модификацией данных его экземпляра. Изменение данных его экземпляра приведет к повторной привязке i к другому объекту (что в любом случае запрещено).

 [amp;i](){ i = 7; return i * i; }
 

в основном эквивалентно

 class Lambda
{
public:
    Lambda(intamp; arg_i) : i(arg_i) {}

    auto operator() () const { i = 7; return i * i;}
private:
    intamp; i;
};
 

И тогда у вас есть:

 const Lambda a(i);
a();
 

И const Lambda не будет продвигать своего члена на const intamp; i; , но intamp; const i; что эквивалентно intamp; i; .

Когда вы вводите i его, он записывается как тип, которым он является.

Итак, внутренне он имеет intamp; . Значение const перед объявлением переменной замыкания ничего не меняет для лямбда-выражения.

У вас есть 2 варианта решения этой проблемы:

 const int i = 5;
auto b = [amp;i]() { i  ; }; //error on i  
 

Таким образом, a const intamp; будет захвачен.

Если вы не можете изменить i по каким-либо причинам, вы можете сделать это в c 14

 int i = 5;
auto b = [i = static_cast<const intamp;>(i)]() { i  ; }; //error on i  
 

Это приводит intamp; к преобразованию в a const intamp; и будет сохранено как таковое в лямбде. Хотя, как вы можете видеть, это намного более подробно.

В коде, который вы дали:

 int foo(int i)
{
    const auto a = [amp;i](){ i = 7; return i * i; };
    a();
    return i;
}
 

Вы не назначаете после инициализации своей постоянной лямбда-функции. Следовательно, const в данном контексте это мало что значит.

То, что вы объявили, поскольку const это не контекст вашей анонимной функции или лямбда-выражения и его параметров, а только ссылка на это лямбда-выражение : const auto a .

Следовательно, вы не можете изменить значение вашей ссылки на лямбда-выражение a , потому что оно равно const , но его параметр, передаваемый по ссылке, amp;i , может быть изменен в контексте лямбда-выражения.

Если я правильно понимаю, вопрос в том, почему вам разрешено мутировать i , даже если a is const и предположительно содержит ссылку на i as a member .

Ответ заключается в том, что по той же причине вам разрешено делать это с любым объектом — присвоение i не изменяет экземпляр lambda, оно изменяет объект, на который он ссылается.

Пример:

 class A
{
public:
    A(intamp; y) : x(y) {} 
    void foo(int a) const { x = a; } // But it's const?!
private:
    intamp; x;
};

int main()
{
    int e = 0;
    const A a(e);
    a.foo(99);
    std::cout << e << std::endl;
}
 

Это компилируется и выводит «99», потому foo что это не изменение члена a , это изменение e .
(Это немного сбивает с толку, но помогает понять, какие объекты изменяются, и не обращать внимания на то, как они называются.)

Эта «постоянная, но не совсем» природа const является очень распространенным источником путаницы и раздражения.

Именно так ведут себя указатели, где это, очевидно, не так:

 class A
{
public:
    A(int* y) : x(y) {} 
    void foo(int a) const { *x = a; } // Doesn't modify x, only *x (which isn't const).
private:
    int* x;
};