Хочется воспользоватся сабж в следующем случае:

class Base {
...
bool operator < (Base &b){...}
...
}

class Deriver : public Base {...}

typedef std::vector<Deriver*> Vec;

bool find(Base &b, Vec &vec){
 return ??? // как найти с помощью STL
}

Здравствуйте, Аноним, Вы писали:

Может так?

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

class CA
{
public:
    int i;
    CA(int _val)
    {
        this->i = _val;
    }
    bool operator < ( const CA& _val ) const
    {
        return i < _val.i;
    }
};

class CB : public CA
{
public:
    CB(int _val) : CA(_val)
    {
    }
};

class Condition
{
public:
    Condition( CA* _cmp )
    {
        this->m_Cmp = _cmp;
    }

    bool operator() ( CA* _val )
    {
        return *_val < *m_Cmp;
    }
    CA* m_Cmp;

    
};

bool find(CA &b, std::vector<CB*> &vec){
    std::vector<CB*>::iterator find_it;
    find_it = std::find_if( vec.begin(), vec.end(), Condition(&b) );
    return find_it != vec.end();
}



int main()
{
    std::vector<CB*> v;
    for(int i=0;i < 10; ++i )
    {
        CB* val = new CB(i);
        v.push_back( val );
    }
    CB comp(-11);
    
    std::cout << find( comp, v ) << std::endl;
}

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

G>Здравствуйте, Аноним, Вы писали:

G>Может так?

G>

G>#include <iostream>
G>#include <vector>
G>#include <algorithm>

G>class CA

G>class Condition
G>{
G>public:
G>    Condition( CA* _cmp )
G>    {
        this->>m_Cmp = _cmp;
G>    }

G>    bool operator() ( CA* _val )
G>    {
G>        return *_val < *m_Cmp;
G>    }
G>    CA* m_Cmp;

    
G>};
G>}

можно конечно и так
токо вот хочется без вспомогательного класса (Condition)

Здравствуйте, Аноним, Вы писали:

А>Здравствуйте, Glоbus, Вы писали:

G>>Здравствуйте, Аноним, Вы писали:

G>>Может так?

G>>

G>>#include <iostream>
G>>#include <vector>
G>>#include <algorithm>

G>>class CA

G>>class Condition
G>>{
G>>public:
G>>    Condition( CA* _cmp )
G>>    {
        this->>>m_Cmp = _cmp;
G>>    }

G>>    bool operator() ( CA* _val )
G>>    {
G>>        return *_val < *m_Cmp;
G>>    }
G>>    CA* m_Cmp;

    
G>>};
G>>}

А>можно конечно и так
А>токо вот хочется без вспомогательного класса (Condition)

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

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

G>Можно конечно и функцию в виде предиката вмондить, но я честно говоря не знаю тогда как передать ей то, с чем сравнивать — первый параметр в твоей функции find — можно конечно в глобальной переменной, но это самый крайний случай. А как бы ты хотел шоб это выглядело?

что-то типа
find_if(... bind2nd(equal_to<Deriver>(),Deriver(&b)) );
токо вот как разыменовать ?

Здравствуйте, Аноним, Вы писали:

А>Здравствуйте, Glоbus, Вы писали:

G>>Можно конечно и функцию в виде предиката вмондить, но я честно говоря не знаю тогда как передать ей то, с чем сравнивать — первый параметр в твоей функции find — можно конечно в глобальной переменной, но это самый крайний случай. А как бы ты хотел шоб это выглядело?

А>что-то типа
А>find_if(... bind2nd(equal_to<Deriver>(),Deriver(&b)) );
А>токо вот как разыменовать ?

Так в чем проблема
Вот так вот например работает

bool find(CA &b, std::vector<CB*> &vec){
    std::vector<CB*>::iterator find_it;
    find_it = std::find_if( vec.begin(), vec.end(), std::bind2nd( std::less<CA*>(), &b ) );
    return find_it != vec.end();
}

Здравствуйте, Аноним, Вы писали:


в первый раз затупил

class MyFindPred
{
    Base &b;
public:
    MyFindPred(Base &b) 
        : b(b)
    {
    }
    
    bool operator()(Deriver * pDerivObj)
    {
        return !((b < *pDerivObj) || (*pDerivObj < b));
    }
};

bool find(Base &b, Vec &vec){
    std::find_if(vec.begin(), vec.end(), MyFindPred(b));
    return true;
}

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

G>Так в чем проблема
G>Вот так вот например работает


G>

G>bool find(CA &b, std::vector<CB*> &vec){
G>    std::vector<CB*>::iterator find_it;
G>    find_it = std::find_if( vec.begin(), vec.end(), std::bind2nd( std::less<CA*>(), &b ) );
G>    return find_it != vec.end();
G>}

G>

а сравниваться что будет адереса или по перегруженому оператору < ?

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

Cтоп
прогнал
не заработает конечно

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

ssm>Здравствуйте, Аноним, Вы писали:


ssm>в первый раз затупил

ssm>

ssm>class MyFindPred
ssm>{
ssm>    Base &b;
ssm>public:
ssm>    MyFindPred(Base &b) 
ssm>        : b(b)
ssm>    {
ssm>    }
    
ssm>    bool operator()(Deriver * pDerivObj)
ssm>    {
ssm>        return !((b < *pDerivObj) || (*pDerivObj < b));
ssm>    }
ssm>};

ssm>bool find(Base &b, Vec &vec){
ssm>    std::find_if(vec.begin(), vec.end(), MyFindPred(b));
ssm>    return true;
ssm>}
ssm>

а шаблона такого в STL случайно нету ?
ведь довольно часто приходится в векроте ссылку хранить

Такой код у меня отработал:

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

using namespace std;

class Base: public binary_function<Base *, Base *, bool>
{
    int m_i;
public:
    Base(int i): m_i(i) {}
    
    bool operator<(const Base &b) const
    {
        return (m_i < b.m_i);
    }

    bool operator()(Base *b1, Base *b2) const
    {
        return ((*b1) < (*b2));
    }

    void print()
    {
        cout << "Base object: " << m_i << endl;
    }
};

class Deriver : public Base
{
    int m_j;
public:
    Deriver(int i, int j): Base(i), m_j(j) {}
};


int main()
{
    vector<Deriver *> vct;
    vct.push_back(new Deriver(5,2)); vct.push_back(new Deriver(6,4));
    vct.push_back(new Deriver(2,5)); vct.push_back(new Deriver(1,6));

    Base *b = new Base(3);

    vector<Deriver *>::iterator it = find_if(vct.begin(), vct.end(), bind2nd(*b, b));

    if (it != vct.end() )
        (*it)->print();

    return 0;
}

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

S>Такой код у меня отработал:

Base object: 2