Почему лямбда-оператор вызова неявно const?

Question

Почему лямбда-оператор вызова неявно const?

У меня есть небольшое «лямбда-выражение» в функции ниже:

int main()
{
int x = 10;
auto lambda = [=] () { return x + 3; };
}

Ниже приведен «класс анонимного замыкания», сгенерированный для вышеуказанного лямбда-выражения.

int main()
{
int x = 10;

class __lambda_3_19
{
public: inline /*constexpr */ int operator()() const
{
return x + 3;
}

private:
int x;

public: __lambda_3_19(int _x) : x{_x}
{}

};

__lambda_3_19 lambda = __lambda_3_19{x};
}

«Operator ()» замыкания, сгенерированный компилятором, неявно const. Почему стандартный комитет сделал это const по умолчанию?

18

c++c++11 const function-call-operator lambda

Решение

Другие решения

Нашел это бумага Херб Саттер на open-std.org, который обсуждает этот вопрос.

Странная пара: захват по введенному значению const и причудливый изменяемый
Рассмотрим следующий пример: программист захватывает локальную переменную по значению и пытается изменить захваченное значение (которое является переменной-членом лямбда-объекта):
int val = 0;
auto x = [=]( item e ) // look ma, [=] means explicit copy
{ use( e, ++val ); }; // error: count is const, need ‘mutable’
auto y = [val]( item e ) // darnit, I really can’t get more explicit
{ use( e, ++val ); }; // same error: count is const, need ‘mutable’
Эта функция, кажется, была добавлена из опасения, что пользователь может не осознавать, что он получил копию, и, в частности, что, поскольку лямбды можно копировать, он может менять другую копию лямбды.

Приведенная выше цитата и пример указывают, почему Комитет по стандартам может быть сделали это const по умолчанию и требуется mutable изменить это.

18

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

0

Источник

Accepted Answer

От cppreference

Если только ключевое слово mutable был использован в лямбда-выражении, оператор вызова функции является квалифицированным const, и объекты, которые были захвачены копией, не модифицируются изнутри этого operator()

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

Я полагаю, что если вы напишите что-то

int x = 10;

auto lambda = [=] () mutable { x += 3; return x; };

const должен исчезнуть

— РЕДАКТИРОВАТЬ —

ОП точный

Я уже знал, что добавление mutable решит проблему. Вопрос в том, что я хочу понять причину, по которой лямбда по умолчанию остается неизменной.

Я не адвокат по языку, но это кажется мне очевидным: если вы делаете operator() не constВы не можете сделать что-то как

template <typename F>
void foo (F const & f)
{ f(); }

// ...

foo([]{ std::cout << "lambda!" << std::endl; });

Я имею в виду … если operator() не constВы не можете использовать лямбды, передавая их как const ссылка.

А когда это строго не нужно, должно быть недопустимое ограничение.

9