Лямбда как goto - C/C++

	лирическое отступление
	Еще я мальчиком все думал: заведу себе зверька, а то их вон сколько скачет по полям-то. Возьму в товарищи разумного жирафа, муравьеда или просто кенгуру, я даже имя подыскал. Лямбда! Я назову его Лямбда! — Так думал я, но детство кончилось, а бедный муравьед и по сегодня остается невостребован и скачет, где скакал!

А правда, что модные программисты больше не используют олдс-кульную конструкцию вида:

do{ if (..) continue; } while(false);

а заменили её на лямбду:

#include <iostream>
#include <string>


int main(int argc, char* argv[])
{
    std::string str = "fdsa";
    int n = -1;

    [&]()
    {
        if ( str == "asdf" )
        {
            std::cout << 1 << std::endl;
            n = 1;
            return;
        }

        if ( str == "fdsa" )
        {
            std::cout << 2 << std::endl;
            n = 2;
            return;
        }

        n = 0;
        std::cout << "unknown" << std::endl;
    }();

    std::cout << "n=" << n << std::endl;

    return 0;
}

Здравствуйте, B0FEE664, Вы писали:

BFE>А правда, что модные программисты больше не используют олдс-кульную конструкцию вида

http://rsdn.ru/forum/cpp.applied/6336533

Здравствуйте, Qbit86, Вы писали:

BFE>>А правда, что модные программисты больше не используют олдс-кульную конструкцию вида
Q>http://rsdn.ru/forum/cpp.applied/6336533
А что, у IIFE большой оверхед?

Здравствуйте, B0FEE664, Вы писали:

меня бесит неконстантность n и str в этом примере. Ну и потом, маттерн-матчить так паттерн-матчить.

#include <iostream>
#include <string>

int main(int argc, char* argv[])
{
    const std::string str = "fdsa";

    const int n = 
            str == "asdf" ? 
        [](){
            std::cout << 1 << std::endl;
            return 1;
        }()
            : str == "fdsa" ?
        [](){
            std::cout << 2 << std::endl;
            return 2;
        }()
            :
        [](){
            std::cout << "unknown" << std::endl;
            return 0;
        }()
    ;

    std::cout << "n=" << n << std::endl;

    return 0;
}

утренняя наркомания

#include <iostream>
#include <string>

int main(int argc, char* argv[])
{
  const std::string str = "fdsa";

  const int n = 
    str == "asdf" ? 
      (( std::cout << 1 << std::endl), 1)
    : str == "fdsa" ?
      (( std::cout << 2 << std::endl), 2)
    :
      ((std::cout << "unknown" << std::endl), 0)
  ;

  std::cout << "n=" << n << std::endl;

  return 0;
}

Здравствуйте, antropolog, Вы писали:

A>меня бесит неконстантность n и str в этом примере.

Смысл как раз в том, что n — не константа. Вместо n может быть любой объект или множество объектов, переменных. Например, это может быть структура заполняемая по результатам разбора XML...

Здравствуйте, B0FEE664, Вы писали:

BFE>А правда, что модные программисты больше не используют олдс-кульную конструкцию вида:
BFE>

BFE>do{ if (..) continue; } while(false);
BFE>

BFE>а заменили её на лямбду:
BFE>

BFE>#include <iostream>
BFE>#include <string>


BFE>int main(int argc, char* argv[])
BFE>{
BFE>    std::string str = "fdsa";
BFE>    int n = -1;

BFE>    [&]()
BFE>    {
BFE>        if ( str == "asdf" )
BFE>        {
BFE>            std::cout << 1 << std::endl;
BFE>            n = 1;
BFE>            return;
BFE>        }

BFE>        if ( str == "fdsa" )
BFE>        {
BFE>            std::cout << 2 << std::endl;
BFE>            n = 2;
BFE>            return;
BFE>        }

BFE>        n = 0;
BFE>        std::cout << "unknown" << std::endl;
BFE>    }();

BFE>    std::cout << "n=" << n << std::endl;

BFE>    return 0;
BFE>}
BFE>

BFE>?

B0FEE664, а чем в таком исполнении это лучше обычного:


int main(int argc, char* argv[])
{
    std::string str = "fdsa";
    int n = -1;

    
    {////
        if ( str == "asdf" )
        {
            std::cout << 1 << std::endl;
            n = 1;
            
        }
        else
        if ( str == "fdsa" )
        {
            std::cout << 2 << std::endl;
            n = 2;
        }
        else
        {
            n = 0;
            std::cout << "unknown" << std::endl;
        };

    }////

    std::cout << "n=" << n << std::endl;

    return 0;
}

? или просто пример неудачный?

Мои ощущения от лямбд примерно соответствуют описаниям ужасов goto.
Только goto локальны, а лямбды соответствуют глобальным прыжкам.

Здравствуйте, se_sss, Вы писали:

_>Мои ощущения от лямбд примерно соответствуют описаниям ужасов goto.
_>Только goto локальны, а лямбды соответствуют глобальным прыжкам.

вы что-то путаете. лямбды дабт возможность только локальных прыжков (в пределах тела лямбды), тогда как goto -куда хочешь

Здравствуйте, _hum_, Вы писали:

__>Здравствуйте, se_sss, Вы писали:

_>>Мои ощущения от лямбд примерно соответствуют описаниям ужасов goto.
_>>Только goto локальны, а лямбды соответствуют глобальным прыжкам.

__>вы что-то путаете. лямбды дабт возможность только локальных прыжков (в пределах тела лямбды), тогда как goto -куда хочешь

Не путаю. Это ощущения.
От того, что я внезапно оказываюсь в теле функции, в которой я на самом деле не нахожусь, но зато там расположено тело лямбды.
И кстати, goto — именно локален (в пределах функции). Для глобальных переходов есть setjump() longjump(). Не приходилось пользоваться

Здравствуйте, _hum_, Вы писали:

__>? или просто пример неудачный?

Ну, может пример не удачный.
Вот, например, спрашивают как из двух циклов выйти. Ответ прост: до цикла вписать строку [&](){, в точке выхода написать return, а месте выхода закрыть открытую скобку с помощью строки }(); вот так:

    [&]()
    {
        while(1)
        {
          for(int i = 0; i < 100; i++)
          {
            if(i == 77)
            {
              std::cout << "77! go out!" << std::endl;
              return;
            }
          }
        }
    }();

Здравствуйте, se_sss, Вы писали:

_>Здравствуйте, _hum_, Вы писали:

__>>Здравствуйте, se_sss, Вы писали:

_>>>Мои ощущения от лямбд примерно соответствуют описаниям ужасов goto.
_>>>Только goto локальны, а лямбды соответствуют глобальным прыжкам.

__>>вы что-то путаете. лямбды дабт возможность только локальных прыжков (в пределах тела лямбды), тогда как goto -куда хочешь

_>И кстати, goto — именно локален (в пределах функции).

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

Здравствуйте, B0FEE664, Вы писали:

BFE>Здравствуйте, _hum_, Вы писали:

__>>? или просто пример неудачный?

BFE>Ну, может пример не удачный.
BFE>Вот, например, спрашивают как из двух циклов выйти. Ответ прост: до цикла вписать строку [&](){, в точке выхода написать return, а месте выхода закрыть открытую скобку с помощью строки }(); вот так:
BFE>

BFE>    [&]()
BFE>    {
BFE>        while(1)
BFE>        {
BFE>          for(int i = 0; i < 100; i++)
BFE>          {
BFE>            if(i == 77)
BFE>            {
BFE>              std::cout << "77! go out!" << std::endl;
BFE>              return;
BFE>            }
BFE>          }
BFE>        }
BFE>    }();
BFE>

это тоже не совсем удачный, ибо можно

bool bFound = false;

while(!bFound)
{
        for(int i = 0; (i < 100) && (!bFound); i++)
        {
            if(i == 77)
            {
                std::cout << "77! go out!" << std::endl;
                bFound = true;
            }
        }
}

Здравствуйте, _hum_, Вы писали:

__>это тоже не совсем удачный, ибо можно
__>

__>bool bFound = false;

__>while(!bFound)
__>{
__>        for(int i = 0; (i < 100) && (!bFound); i++)
__>        {
__>            if(i == 77)
__>            {
__>                std::cout << "77! go out!" << std::endl;
__>                bFound = true;
__>            }
__>        }
__>}
__>

~~А ещё можно исключение подбросить и поймать~~
Такой код сложнее читать и он потенциально менее эффективен.

BFE>Такой код сложнее читать и он потенциально менее эффективен.
Решил посоревноваться в оптимизациях с компилятором?

Здравствуйте, dr. Acula, Вы писали:

BFE>>Такой код сложнее читать и он потенциально менее эффективен.
DA>Решил посоревноваться в оптимизациях с компилятором?

нет. В данном вопросе мне важнее удобство чтения.

Здравствуйте, B0FEE664, Вы писали:

BFE>А правда, что модные программисты больше не используют олдс-кульную конструкцию вида:
BFE>а заменили её на лямбду:

Да, правда. Только я ещё и имя этой лямбде даю.
А олдскульная конструкция это бред, готофобия ради готофобии.

Здравствуйте, B0FEE664, Вы писали:

BFE>Здравствуйте, _hum_, Вы писали:

__>>это тоже не совсем удачный, ибо можно
__>>

__>>bool bFound = false;

__>>while(!bFound)
__>>{
__>>        for(int i = 0; (i < 100) && (!bFound); i++)
__>>        {
__>>            if(i == 77)
__>>            {
__>>                std::cout << "77! go out!" << std::endl;
__>>                bFound = true;
__>>            }
__>>        }
__>>}
__>>

BFE>~~А ещё можно исключение подбросить и поймать~~
BFE>Такой код сложнее читать и он потенциально менее эффективен.

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

upd. кстати, в качестве принципиального отличия выхода по флагу от выхода по прыжку можно рассматривать отсутствие у первого гарантии того, что если в каком-то месте стоит код bFound = true, то цикл будет прерван (в отличие от return, break)

Здравствуйте, B0FEE664, Вы писали:

BFE>Такой код сложнее читать и он потенциально менее эффективен.

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

Здравствуйте, B0FEE664, Вы писали:

BFE>нет. В данном вопросе мне важнее удобство чтения.

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

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

Здравствуйте, T4r4sB, Вы писали:

TB>Да, правда. Только я ещё и имя этой лямбде даю.
TB>А олдскульная конструкция это бред, готофобия ради готофобии.

этой лямбде имя ну совсем ненужно, оно исполяется сразу на месте и больше нигде

	От:	B0FEE664
	Дата:	21.04.16 14:07
	Оценка:	17 (3) +1

От:	Qbit86	https://twitter.com/qbit86
Дата:	21.04.16 14:25
Оценка:

	От:	B0FEE664
	Дата:	21.04.16 15:34
	Оценка:

	От:	antropolog
	Дата:	22.04.16 02:30
	Оценка:

	От:	B0FEE664
	Дата:	22.04.16 09:02
	Оценка: