C++ 0x стиль кодирования лямбд

Здесь я вижу новое правило стандарта кодирования! ;)

Это немного надумано, но чтобы подчеркнуть «преимущество» явного, рассмотрим следующее:

void foo (std::vector<int> v, int x1)
{
  int sum = 0;
  std::for_each (v.begin ()
    , v.end ()
    , [&](int xl) { sum += x1; } 
}

Я специально выбрал для этого плохие имена и т. Д., Но это просто для иллюстрации сути. Если бы мы использовали явный список захвата, то приведенный выше код не скомпилировался бы, но в настоящее время он будет компилироваться.

В очень строгой среде (критичной с точки зрения безопасности) я могу видеть такое правило как часть стандарта кодирования.

Я бы пошел с явными списками захвата, когда это вообще возможно, когда вы хотите захватить много переменных тогда (вы, вероятно, делаете что-то не так и) вы можете использовать захват всех [&] список захвата.

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

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

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

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

Я еще не использовал лямбда-выражения C ++ (кроме как копаться в бета-версии VC10), но я бы пошел с последним большую часть времени

std::for_each(xs.begin(), xs.end(), [&](int x) { sum += x });

Мои рассуждения? Почему бы не сделать это? Это удобно. Оно работает. И это проще в обслуживании. Мне не нужно обновлять список захвата, когда я изменяю тело лямбды. Почему я должен открыто говорить о том, что компилятор знает лучше меня? Компилятор может определить список захвата на основе того, что фактически используется.

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

Это не похоже на выбор, который вы должны сделать при разработке обычной функции.

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

Я читаю следующую ссылку, чтобы лучше понять лямбда-выражение C ++. Стиль кодирования, используемый в примерах, довольно изящный, и я могу следовать ему: http://uint32t.blogspot.com/2009/05/using-c0x-lambda-to-replace-boost-bind.html