Хабрахабр / Комментарии к посту «Лямбда выражения теперь и в С++» в блоге «C++»

02.06.2010 08:56:46 Levsha100

Levsha100 — Wed, 02 Jun 2010 08:56:46 GMT

Скорее в лисп =)

22.10.2009 03:07:15 freetonik

freetonik — Thu, 22 Oct 2009 03:07:15 GMT

Передача n в лямбду в качестве аргумента, если я правильно понял.

27.09.2009 18:08:57 Ronin

Ronin — Sun, 27 Sep 2009 18:08:57 GMT

Все гораздо проще, название «С++»:
«С» — как дань предшественнику и основе языка;
"++" — как указание на усовершенствование.
А оператор ++ был и в Си.

09.08.2009 18:09:15 vk2

vk2 — Sun, 09 Aug 2009 18:09:15 GMT

альтернативный вариант: habrahabr.ru/blogs/macosxdev/66632/

ps. Запутанность С++ только могила исправит. Простите :)

02.08.2009 20:22:42 smilegs

smilegs — Sun, 02 Aug 2009 20:22:42 GMT

вот бы еще поддержку делегатов без извращений с шаблонами…

01.08.2009 17:07:31 michaelkl

michaelkl — Sat, 01 Aug 2009 17:07:31 GMT

Этак скоро C++ превратится в Perl или что-то подобное…
:)))

01.08.2009 08:59:26 Paul

Paul — Sat, 01 Aug 2009 08:59:26 GMT

Впервые слышу о таком. В книге Кернигана и Ричи уже есть про ++ и --.

01.08.2009 08:18:51 SSoft

SSoft — Sat, 01 Aug 2009 08:18:51 GMT

C++ проявился в 1985 году, на тот момент у Си не было оператора ++, его добавили позднее. Я не прав?

01.08.2009 02:57:30 redchrom

redchrom — Sat, 01 Aug 2009 02:57:30 GMT

Ты не понел, Си таким как был таким и остался, это Си++ мутирует. BTW си это тоже static scope язык, и сделать лексические замыкания не так сложно.

31.07.2009 20:19:24 amlet

amlet — Fri, 31 Jul 2009 20:19:24 GMT

Кое что узнал новое из твоего коммента. А именно что можно спокойно инициализировать статическую переменную при объявлении внутри класса, если она констрантна. Быстренько накатал программульку, скомпилил, работает! Никогда в голову не приходило, хотя программлю на C++ уже не первый день. Как говорится: «Век живи — век учись». Спасибо.

31.07.2009 18:04:00 Paul

Paul — Fri, 31 Jul 2009 18:04:00 GMT

Человеку, поставившему минус: Просьба ознакомиться с пунктами 6.5.2 и 6.5.3 стандарта языка Си (ISO/IEC 9899:1990). Ну или проверить компилятором.

31.07.2009 17:18:35 VoidEx

VoidEx — Fri, 31 Jul 2009 17:18:35 GMT

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

31.07.2009 17:10:58 Paul

Paul — Fri, 31 Jul 2009 17:10:58 GMT

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

В случае 3 static функции и переменные не являются членами какого-то класса, static ограничивает область доступности этих переменных и функций текущей единицей трансляции.

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

31.07.2009 16:56:44 Paul

Paul — Fri, 31 Jul 2009 16:56:44 GMT

++ есть и в Си.

31.07.2009 15:29:07 SSoft

SSoft — Fri, 31 Jul 2009 15:29:07 GMT

Нет.
++ из-за того, что в Си++ впервые появился такой оператор :), ну и потом ++ это инкремент, т.е. следующая версия. В Си++ появились классы, операторы new и delete. Насчет шаблонов не уверен… кажись они попозднее были.

31.07.2009 14:53:32 Nashev

Nashev — Fri, 31 Jul 2009 14:53:32 GMT

Я немножко не в курсе, поясните плиз:
* Инициализировать static-поле при декларации (случай 2 в Вашем списке) разве нельзя? Если можно — то он идентичен случаю 1

* В случае 3 — слово static делает объявленя приватными? Замысловато, однако. А почему в стандарте для этого не предлагается слово типа private?

* 4-ый случай — это как в Delphi объявление методов класса с помощью слова class? Интересно, почему тут оно объявляется словом static? Или они имеют ввиду, что метод — это типа ссылка на функцию, делают эту ссылку независимой от экземпляра, «статичной»?

* В фразе «приватную или протектную ты объявить где угодно не сможешь» — тут Вы имели ввиду «вызвать» а не «объявить», или я что-то не понял?

31.07.2009 14:41:22 Nashev

Nashev — Fri, 31 Jul 2009 14:41:22 GMT

habrahabr.ru/blogs/cpp/65798/#comment_1846042

31.07.2009 14:40:04 Nashev

Nashev — Fri, 31 Jul 2009 14:40:04 GMT

"++" в названии — это не столько объектно-ориентированность, сколько препроцессор, если я ничего не путаю.

31.07.2009 14:32:57 sse

sse — Fri, 31 Jul 2009 14:32:57 GMT

T4 — это ни черта не макросы lisp. t4 — просто текстовый шаблонизатор (в прямом смысле этого слова)/formatter/replacer, не более. Про семантику языка, AST и прочее он не знает.

31.07.2009 13:42:09 b0zz

b0zz — Fri, 31 Jul 2009 13:42:09 GMT

возможно, на истину в последней инстанции не претендую (относительно с++ и с# интерес сугубо созерцательный).

31.07.2009 12:36:09 xiWera

xiWera — Fri, 31 Jul 2009 12:36:09 GMT

вы путаете, t4 это для C#

31.07.2009 12:30:59 xiWera

xiWera — Fri, 31 Jul 2009 12:30:59 GMT

«никак не отражаются на лямбде» читать как «никак не отражаются на перменных вне оямбды»

31.07.2009 12:30:08 xiWera

xiWera — Fri, 31 Jul 2009 12:30:08 GMT

если по значению, то все что мы делаем с этими переменными внутри лямбды — никак не отражаются на лямбде

если по ссылке, то отражается.

Насчет замыканий. Было бы странно ожидать работоспособности такого кода:

boost::function func;

void f(){
int a = 3;
func = [&](){ a++; };
};

f();
func();

время жизни переменной a, по стандарту языка, кончилось по выходу из f(). Соответственно непонятно к какой перменной будет иметь доступ лямбда.

P.S. что собственно и описано в пропозале:

9… If one or more names in the effective capture set are preceded by &, the effect of invoking a closure object, or a copy, after the innermost block scope of the context of the lambda expression has been exited is undefined.

31.07.2009 12:27:47 b0zz

b0zz — Fri, 31 Jul 2009 12:27:47 GMT

интересно наблюдать, как с каждым витком развития в с++ пытаются запилить всё больше реально удобных фич lisp'a (буквально наднях читал про «генератор кода», т.н. t4 — по сути: попытка повторить макросы cl)

31.07.2009 12:12:18 shamaniac

shamaniac — Fri, 31 Jul 2009 12:12:18 GMT

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

31.07.2009 12:07:50 xiWera

xiWera — Fri, 31 Jul 2009 12:07:50 GMT

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

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

31.07.2009 11:58:22 shamaniac

shamaniac — Fri, 31 Jul 2009 11:58:22 GMT

Прошу прощения на самом деле я хотел написать

tr1::function f() {....}

Если вас волнует потеря памяти (я понимаю при работе с c++ это уже инстинкт =) то можно написать что-то вроде.
typedef tr1::function F;
pair f() {
shared_ptrptr(new int(0));
return make_pair([=ptr](){ return (*ptr)++;}, [=ptr](){ return (*ptr)--;});
}
Понятно что такое решение ни полраза не потокобезопасно. Но с другой стороны мы получили пару функций связанных одной переменной без необходимости хранить эту переменную где-то еще.

У нас наблюдается терменологическая путаница. Есть лямбда функции. Они в данном контексте не более чем функции без имени. Так сказать «syntactic sugar». Но часто вместе с лямбда функциями используются замыкания. Замыкания как я представляю нужны для того чтобы сохранить часть переменных для последующего использования внутри лямбда функции.

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

например
void f(vector* v) {
hash_setbig_hash_set;
// fill big_hash_set
stable_partition(v->begin(), v->end(), [&big_hash_set](int i) { return big_hash_set.count(i); }
…
}

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

void f(vector* v) {
hash_setbig_hash_set;
// fill big_hash_set
hash_set* big_hash_set_ptr = &big_hash_set;
stable_partition(v->begin(), v->end(), (int i) { return big_hash_set_ptr->count(i); }
…
}

С другой стороны та реализация которую предлагают в стандарт мне тоже нравится.

31.07.2009 11:34:19 xiWera

xiWera — Fri, 31 Jul 2009 11:34:19 GMT

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

31.07.2009 11:33:21 xiWera

xiWera — Fri, 31 Jul 2009 11:33:21 GMT

наверное ваш пример должен выглядеть так:

int f(){
int *ptr = new int(0);
return [=](){ return (*ptr)++ };
};

да вы тут потеряете память, но причем тут лямбда функции?

точно также можно написать без лямбды:

int f(){
int *ptr = new int(0);
return (*ptr)++;
};

31.07.2009 11:18:55 shamaniac

shamaniac — Fri, 31 Jul 2009 11:18:55 GMT

Что-то у нас не выходит осмысленного обсуждения. Я привожу пример который хочется записать одной строчкой а вы мне объясняете что я ничего не понимаю и с указателями так работать нельзя. То ли у меня не получается выражать свои мысли то ли у вас их понимать а может и то и другое. Я думаю стоит свернуть дискуссию и признать что вы во всем правы =).

31.07.2009 11:15:10 xiWera

xiWera — Fri, 31 Jul 2009 11:15:10 GMT

вы всегда так бесстрашно с сырыми указателями в с++ работаете? :)

я еще мощнее вам могу пример рассказать из с++

int *f(){
int val = 0;
return &val;
};

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

31.07.2009 11:10:49 shamaniac

shamaniac — Fri, 31 Jul 2009 11:10:49 GMT

void f() {
int* ptr = new int(0);
return [=](){return (*ptr)++;};
}

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

31.07.2009 11:06:20 xiWera

xiWera — Fri, 31 Jul 2009 11:06:20 GMT

как это мало знает? :)

лямбда функция живет в блоке кода :) ей доступны переменные «на стеке» из этого блока, по выходу из блока все прекрасно «со стека» уберется :)

лямбда функция переданная как параметр в другой блок — не имеет доступа к переменным текущего блока :) поэтому никаких проблем без сборщика мусора нет.

Вообще в старом с++ всё тоже самое можно было бы сделать «ручками» написав чтото типа

class MyLambda{
sometype &someval;
sometype &someval;
…
public:
MyLambda( &some, &some… );
void operator()( params )
};

но каждый раз это делать несколько задалбывает

31.07.2009 10:55:26 xiWera

xiWera — Fri, 31 Jul 2009 10:55:26 GMT

а какая разница заинлайнин он или нет? это какаято работа, .end() у нас в общем случае это не одна строка кода, смотрим к примеру для вектора:

end()
{ return iterator(this->_M_impl._M_finish); }

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

а если посмотреть в std::string::end() или еще какой-нибудь сложный контейнер?

31.07.2009 09:43:09 shamaniac

shamaniac — Fri, 31 Jul 2009 09:43:09 GMT

Хм компилятор который не заинлайнит container.end() в данном случае это что-то страшное =).
И да я рад возможности писать for_each с лямбдами, но опять же есть достаточно простые пути без него обойтись (даже на странном компиляторе =).

31.07.2009 09:38:47 xiWera

xiWera — Fri, 31 Jul 2009 09:38:47 GMT

оригинально конечно, вы что предпочитаете писать каждый раз

for( iter=container.begin();iter!=container.end(); ++iter){
//some code on *iter
};

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

end_iter=container.end()

потом вспоминать, что *iter тоже функция и лучше бы ее тоже отдельно взять:
elem &e= *iter;

не проще ли сразу:

std::for_each( container.begin(), container.end(), [&](){//some code here} );

? :)

31.07.2009 09:33:00 kyb27

kyb27 — Fri, 31 Jul 2009 09:33:00 GMT

хммм… в принципе, картина прояснилась. Спасибо.

31.07.2009 09:30:26 havoc_theory

havoc_theory — Fri, 31 Jul 2009 09:30:26 GMT

В лямбде нет ничего принципиально объектно-ориентированного. Так что логично было бы иметь такой же функционал и в плоском Си.

31.07.2009 09:21:35 shai_xylyd

shai_xylyd — Fri, 31 Jul 2009 09:21:35 GMT

что за язык это C/C++?

31.07.2009 09:20:27 shai_xylyd

shai_xylyd — Fri, 31 Jul 2009 09:20:27 GMT

C++ есть почти под всё, но почти под все он немного различается. Иначе не было бы https://developer.mozilla.org/En/C___Portability_Guide.