[SOLVED][C++ boost] Доступ к членам лямбда-аргументов.

Serpent555

  struct S

  {

    int p;

  };



  vector<S> v;



  sort(v.begin v.end _1.p);  

For some operators, the requirements on return types prevent them to be overloaded to create lambda functors. These operators are ->., ->, new, new[], delete, delete[] and ?: (the conditional operator).

doublemother

          std::vector<S> v;

          v.push_backS){7});

          v.push_backS){12});

          v.push_backS){1});

          v.push_backS){13});

          std::sort(v.begin v.end [](S a, S b){return a.p < b.p; });

          std::for_each(v.begin v.end [](S a){std::cout << a.p << std::endl;});

agent007new

        std::sort

	(

		v.begin

		v.end

		boost::bind

		(

			std::less<int>

			boost::bind(&S::p, _1

			boost::bind(&S::p, _2)

		)

	);  

agent007new

  

	std::sort

	(

		v.begin

		v.end

		boost::bind(&S::p, _1) < boost::bind(&S::p, _2)

	);

Werdna

Serpent555

doublemother

Лично мне так очень часто не хватает в старом добром С++ просто локальных функций, не говоря уже о лямбдах.

struct S 

{

        int p;

};



class L 

{               

        private:

                std::vector<S> v;

                void sortThis

                {       

                        struct Compare

                        { 

                                bool operator  (S a, S b) { return a.p < b.p; }

                        } cmp;

                        std::sort(v.begin v.end cmp);

                }

        public: 

                L     

                {       

                        v.push_backS){7});

                        v.push_backS){12});

                        v.push_backS){1});

                        v.push_backS){13});

                        sortThis;

                } 

                void print

                { 

                        std::for_each(v.begin v.end [](S a){std::cout << a.p << std::endl;});

                }

};



int main

{       

        L l;

        l.print;

}

agent007new

Что приобретается от таких замороченных конструкций?

Werdna

Лично мне так очень часто не хватает в старом добром С++ просто локальных функций, не говоря уже о лямбдах. Так и не понял до сих пор, чего они им не угодили?

Werdna

По-моему, не особо замороченнее, чем обычный оператор, зато гораздо короче

 [](S a, S b){return a.p < b.p; } 

agent007new

Werdna

agent007new

Maurog

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

doublemother

boost::bind(&S::p, _1) < boost::bind(&S::p, _2)

doublemother

по стандарту локальные классы нельзя передавать в шаблоны

slonishka

Представь, что у меня есть приватный метод класса, которому нужно что-то по-быстрому отсортировать. Совершенно не хочется только ради него заводить функцию-сравнение, равно как и писать внешний функтор. Кроме того это сильно упрощенных пример. На самом деле в разных местах эта структура сортируется по разным признакам. Лично мне так очень часто не хватает в старом добром С++ просто локальных функций, не говоря уже о лямбдах. Так и не понял до сих пор, чего они им не угодили?

Serpent555

Чем не устраивает вариант обычной статической функции? "Не хочется" — плохой ответ, ибо моём случае текст будет читабельный, а в твоём — достаточно сложная и вытянутая конструкция.

rosali

 sort(v.begin v.end (&_1)->*(&S::p;  

rosali

sort(v.begin v.end (&_1)->*(&S::p) < (&_2)->*(&S::p;

iravik

нужно просто привыкнуть к такому синтаксису

привыкнуть к такому синтаксису

agent007new

boost::bind(&S::p, _1) < boost::bind(&S::p, _2)
А объясни, пожалуйста, как это работает, я с бустом плохо знаком.
Мне приходит в голову, что сначала буст как-то создаёт два неких функтора F(a) и F(..., b а затем у нас работает некий operator < (F x, F y который как-то хитро возвращает новый функтор G(a, b). Но как-то это очень хитро и странно, и я подозреваю, что всё не так.

struct S

{

	S(int p_) : p(p_) {}



	int p;

};



int wmain(int argc, wchar_t* argv[])

{

	std::vector<S> v;

	v.push_back(S(5;

	v.push_back(S(1;

	v.push_back(S(-10;

	v.push_back(S(15;



	std::sort(v.begin v.end boost::bind(&S::p, _1) < boost::bind(&S::p, _2;

	std::transform(v.begin v.end std::ostream_iterator<int>(cout, ", " boost::bind(&S::p, _1;

	std::cout << std::endl;



	return 0;

}

  

-10, 1, 5, 15,
Press any key to continue . . .

erotic

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

apl13

придется разбираться в boost::bind, в лямбдах

Serpent555

хоть иногда и хочется написать что-то покороче да попроще, но потом, чтобы преемникам твоего кода это понять, им придется разбираться в boost::bind, в лямбдах и прочих прелестях, теряя кучу времени и нервов, хотя ты мог бы написать явно и понятно лишние три строчки.

agent007new

им придется разбираться в boost::bind, в лямбдах и прочих прелестях

kokoc88

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

bool compare(const S& s1, const S& s2)

{

     return s1.p < s2.p;

}

slonishka

или в еще какой-нить язык, где достаточно 10-ти страниц прочитать, чтобы весь язык освоить

#include <stdio.h>



int func(int arg)

{

    switch (arg)

    {

    case 0:

        printf("case 0: 0 == %d\n", arg);

        return 0;

    defau1t:

        printf("default: 0 != %d\n", arg);

        return 0;

    }



    printf("bad case :)\n");

    return -1;

}



int main(int argc, char **argv)

{

    func(0);

    func(1);



    return 0;

}

erotic

slonishka

erotic

Ну вообще, boost::bind - принят в 0x, поэтому любой уважающий себя С++'р должен его изучить. Если же человек, который занимается якобы "разработкой на С++", просто прочитал одного Кернигана и не хочет ничего больше изучать, то, блин, нех ему делать в программировании на С++, пусть в Си идет (дофига проектов на Си написано) или в еще какой-нить язык, где достаточно 10-ти страниц прочитать, чтобы весь язык освоить

Dasar

slonishka

такое действительно должно компилится по стандарту?
нафига им(стандартизаторам) такое понадобилось?

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

doublemother

Вообще, то, что это работает, проверить просто

kokoc88

ну оно по презумпции разрешенности, я так понимаю, компилится.

slonishka

kokoc88

goto чтоль ни разу не писал?

Dasar

slonishka

короче, это же просто метка. компилятор не может ничего против сказать, т.к. с т.з. языка все по-честному
и вот лишь одна странность - метка не используется (т.е. нигде нет строчки "goto defau1t;"). =)

asvsergey

спасает еще то, что на qwerty-клавиатуре "1" и "l" спутать довольно трудно.

kokoc88

Ещё ide подсвечивает.

doublemother

kokoc88

Нет, я ни на секунду не сомневаюсь, что это работает
Мне интересно, как именно это устроено.

template<class C, class V, int N>

class bound_field

{

public:

	static const int _N = N;



	bound_field(V (C::*pv : m_pv(pv)

	{

	}



	const V& operatorconst C& c) const

	{

		return c.*m_pv;

	}



private:

	const V (C::* m_pv);

};



template<int N1, int N2>

struct resolve_less

{

};



template<>

struct resolve_less<1, 2>

{

	template<class V>

	bool operatorconst V& v1, const V& v2)

	{

		return v1 < v2;

	}

};



template<>

struct resolve_less<2, 1>

{

	template<class V>

	bool operatorconst V& v1, const V& v2)

	{

		return v2 < v1;

	}

};



template<class F1, class F2, int N1 = F1::_N, int N2 = F2::_N>

class less_func

{

public:

	less_func(const F1& f1, const F2& f2) : m_f1(f1 m_f2(f2)

	{

	}



	template<class C>

	bool operatorconst C& c1, const C& c2)

	{

		return resolve_less<N1, N2>m_f1(c1 m_f2(c2;

	}



private:

	const F1 m_f1;



	const F2 m_f2;

};



template<class C, class V, int N1, int N2>

less_func<bound_field<C, V, N1>, bound_field<C, V, N2>> operator<(const bound_field<C, V, N1>& b1, const bound_field<C, V, N2>& b2)

{

	return less_func<bound_field<C, V, N1>, bound_field<C, V, N2>>(b1, b2);

}



struct S

{

	S(int p) : m_p(p)

	{

	}



	int m_p;

};



int main(int argc, char* argv[])

{

	bound_field<S, int, 1> b1(&S::m_p);

	bound_field<S, int, 2> b2(&S::m_p);

	S s1(5);

	S s2(7);

	std::cout << b1 < b2s1, s2) ? "true" : "false") << std::endl;

	std::cout << b1 < b2s2, s1) ? "true" : "false") << std::endl;

	std::cout << b2 < b1s1, s2) ? "true" : "false") << std::endl;

	std::cout << b2 < b1s2, s1) ? "true" : "false") << std::endl;

	return 0;

}

  

slonishka

Ещё ide подсвечивает.

slonishka

Я копипастил в vim. Бага спалилась сразу же по отступам.

Marinavo_0507

slonishka

Marinavo_0507

slonishka

doublemother

kokoc88

Ахтунг. Спасибо.

doublemother

поясни.

doublemother

Это сейчас что было?

slonishka

Bibi

slonishka

жмешь равно, чтобы автоиндент сработал

slonishka

erotic

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

doublemother

slonishka

я свой вимрц в альт.линуксе выкладывал тебе он, помнится, еще и понравился.

Werdna

asvsergey

метки обычно тем же цветом, что и case-конструкции подсвечены.
по крайней мере во всех IDE, что использовал я, было так.

apl13

$ cat ~/.vimrc

filetype plugin indent on

$ vim -h | head -n 1

VIM - Vi IMproved 7.2 (2008 Aug 9, compiled Sep 21 2009 11:22:49)

slonishka