добрый день.
Предположим есть такой класс:
struct A
{
vector<int> v;

bool pred (int);

A ();
};

Как использовать метод pred в алгоритмах.

например так:
A::A ()
{
...
find_if (v.begin(), v.end(), pred);
...
}
ясно, что так работать не будет...
А как сделать что б работало?

Благодарю за ответы.

Здравствуйте, IDm, Вы писали:
Можно так:

A::A()
{
  find_if(v.begin(), v.end(), boost::bind(&pred,this));
}

А можно аналогично через mem_fun.

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

IDm>добрый день.
IDm>Предположим есть такой класс:
IDm>struct A
IDm>{
IDm> vector<int> v;

IDm> bool pred (int);

IDm> A ();
IDm>};

IDm>Как использовать метод pred в алгоритмах.

IDm>например так:
IDm>A::A ()
IDm>{
IDm> ...
IDm> find_if (v.begin(), v.end(), pred);
IDm> ...
IDm>}
IDm>ясно, что так работать не будет...
IDm>А как сделать что б работало?

IDm>Благодарю за ответы.

Попробуйте добавить static к определению pred.

Если не прокатит, сделайте pred функтором:

struct Pred
{
    bool operator () ( int ) const {...}
};

//...
find_if( v.begin(), v.end(), Pred() );

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

L>Здравствуйте, IDm, Вы писали:
L>Можно так:
L>

A::A()
L>{
L>  find_if(v.begin(), v.end(), boost::bind(&pred,this));
L>}
L>

А можно аналогично через mem_fun.

Да в том-то и дело, что я знаю, что как-то через mem_fun сделать можно, но как, я низнаю...
Поэтому и спрашиваю.

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

L>> Можно так:
L>>

A::A()
 L>> {
 L>>  find_if(v.begin(), v.end(), boost::bind(&pred,this));
 L>> }
 L>>

А можно аналогично через mem_fun.
I>
I> Да в том-то и дело, что я знаю, что как-то через mem_fun сделать можно,
I> но как, я низнаю... Поэтому и спрашиваю.
Если я не ошибаюсь, то адаптеры mem_fun, mem_fun_ref нужны для того, чтобы вызывать функции-члены объектов, хранящихся в контейнере. Т.к. у тебя в контейнере хранятся объекты типа int, у которых нет функций-членов, то mem_fun, mem_fun_ref для них неприменимы

L>>> Можно так:
L>>>

 L>>> A::A()
 L>>> {
 L>>>  find_if(v.begin(), v.end(), boost::bind(&pred,this));
 L>>> }
 L>>>

P> Если я не ошибаюсь, то адаптеры mem_fun, mem_fun_ref нужны для того, чтобы вызывать функции-члены объектов, хранящихся в
P> контейнере. Т.к. у тебя в контейнере хранятся объекты типа int, у которых нет функций-членов, то mem_fun, mem_fun_ref для них
P> неприменимы

Если класс A имеет функцию-член bool pred(int), то boost::bind(&A::pred,this)) создаст функтор с одним параметром типа int. find_if
требует именно такой.

--
aga

P>> Если я не ошибаюсь, то адаптеры mem_fun, mem_fun_ref нужны для того,
P>> чтобы вызывать функции-члены объектов, хранящихся в контейнере. Т.к. у
P>> тебя в контейнере хранятся объекты типа int, у которых нет
P>> функций-членов, то mem_fun, mem_fun_ref для них неприменимы
AG> Если класс A имеет функцию-член bool pred(int), то
AG> boost::bind(&A::pred,this)) создаст функтор с одним параметром типа
AG> int. find_if требует именно такой.
Так против boost::bind я ничего не имею.
А вот mem_fun, mem_fun_ref в случае со встроенными типами бессмыленны

P> Так против boost::bind я ничего не имею.
P> А вот mem_fun, mem_fun_ref в случае со встроенными типами бессмыленны

Ну почему же?

Вот несколько синтетический пример:

#include <vector>
#include <algorithm>

class A
{
public:
  A()
  : value (0)
  {
  }
  A(int value_)
  : value (value_)
  {
  }
  bool equal(int value_) const
  {
    return value == value_;
  }
private:
  int value;
};

int main()
{
  std::vector<int> iv;
  iv.push_back(10);
  iv.push_back(1);
  iv.push_back(3);
  iv.push_back(0);
  iv.push_back(6);
  A a(0);
  std::find_if(iv.begin(), iv.end(), std::bind1st(std::mem_fun(&A::equal), &a));

  std::vector<A> av;
  av.push_back(A(10));
  av.push_back(A(1));
  av.push_back(A(3));
  av.push_back(A(0));
  av.push_back(A(6));
  std::find_if(av.begin(), av.end(), std::bind2nd(std::mem_fun_ref(&A::equal), 0));
}

boost::bind(&A::pred,this)) эквивалентен boost::bind(boost::mem_fn(&A::pred), this))

--
aga

P>> Так против boost::bind я ничего не имею.
P>> А вот mem_fun, mem_fun_ref в случае со встроенными типами бессмыленны
AG>
AG> Ну почему же?
AG>
AG> Вот несколько синтетический пример:
хъ
Гм, действительно. Про стандартные биндеры я не подумал

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

IDm>Да в том-то и дело, что я знаю, что как-то через mem_fun сделать можно, но как, я низнаю...
IDm>Поэтому и спрашиваю.

Пардон, не учёл и ошибся.
Я имел ввиду boost::mem_fn (а не похожий std::mem_fun). Он применяется, когда нужно из метода создать функтор, имеющий явный аргумент — указатель на класс, и используется обычно в тех же алгоритмах, только с перебором классов, например:

std::list<A> o;
...
for_each(o.begin(),o.end(),boost::mem_fn(&A::method));//вызвать для каждого класса i->method();

Всё это можно реализовать и через boost::bind (что я и делаю), потому я и забыл уже, для чего служат mem_fn и mem_fun.
А в данном конкретном случае mem_fun/mem_fn тебе нафиг не нужен.

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

AG>Вот несколько синтетический пример:

Пример отличный, и работает. Спасибо.
Но вот, скажем, если не не int, а string...

#include <vector>
#include <algorithm>
#include <functional>
#include <iostream>

using namespace std;

class A
{
    string value_;
public:
    A(const string& value): value_ (value){}
    bool equal(const string& value) const{return /*value == value_;*/true;}
};

int main()
{
    vector<string> iv;
    iv.push_back("10");
    iv.push_back("1");
    iv.push_back("3");
    iv.push_back("0");
    iv.push_back("6");
    
    A a("0");
    find_if(iv.begin(), iv.end(), bind1st(mem_fun(&A::equal), &a) );

}

... то не компилиться:

c:\Program Files\Microsoft Visual Studio .NET 2003\Vc7\include\functional(272): warning C4181: qualifier applied to reference type; ignored
c:\Program Files\Microsoft Visual Studio .NET 2003\Vc7\include\functional(272): error C2529: '_Right' : reference to reference is illegal
c:\Program Files\Microsoft Visual Studio .NET 2003\Vc7\include\functional(277): error C2529: '_Right' : reference to reference is illegal
c:\Program Files\Microsoft Visual Studio .NET 2003\Vc7\include\functional(278): error C2535: 'std::binder1st<_Fn2>::result_type std::binder1st<_Fn2>::operator ()(std::binder1st<_Fn2>::argument_type & ) const' : member function already defined or declared
with
[
_Fn2=std::const_mem_fun1_t<bool,A,const std::string &>
]


Подскажите, где собака порылась?

R.