Надо в одну коллекцию собрать указатели на различные однотипные функции, определённые в разных классах. Оцните такой вариант

class AbstractFunction {
public:
    virtual float operator() (int) = 0;
};

template<class T>
class Function : public AbstractFunction {
public:
    typedef float (T::*PFN_METHOD)(int);

    Function(T* obj, PFN_METHOD pfn) : _obj(obj), _pfn(pfn) {}

    virtual float operator() (int k) { 
        return (_obj->*_pfn)(k); 
    }

protected:
    T*         _obj;
    PFN_METHOD _pfn;
};

Для использования что — то типа

//////////////////////////////// 
class Test1 {
public:
    float fn1(int k) {
        return 2*k;
    }
};

class Test2 {
public:
    float fn2(int k) {
        return k+100;
    }
};

/////////////////////////////////

void use() {
    AbstractFunction *func[2];
    Test1 t1;
    Test2 t2;

        // заполнение
    func[0] = new Function<Test1>(&t1, Test1::fn1);
    func[1] = new Function<Test2>(&t2, Test2::fn2);

    AbstractFunction *f=func[0];

         // вызов
    float r = (*f)(1);

    delete func[0];
    delete func[1];
}

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

А>Надо в одну коллекцию собрать указатели на различные однотипные функции, определённые в разных классах. Оцните такой вариант

А действительно ли надо ?

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

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

А>>Надо в одну коллекцию собрать указатели на различные однотипные функции, определённые в разных классах. Оцните такой вариант

Fuz>А действительно ли надо ?

Надо Федя, надо

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

я бы ещё добавил следующее:

template<class T> Function<T>* createFunction(T* p_Object, float (T::*p_Method)(int) )
{
return new Function<T>(p_Object, p_Method);
}

А>/////////////////////////////////

А>void use() {
А> AbstractFunction *func[2];
А> Test1 t1;
А> Test2 t2;

А> // заполнение
А>// func[0] = new Function<Test1>(&t1, Test1::fn1);
А>// func[1] = new Function<Test2>(&t2, Test2::fn2);

А> func[0] = createFunction(&t1, Test1::fn1);
А> func[1] = createFunction(&t2, Test2::fn2);

А> AbstractFunction *f=func[0];

А> // вызов
А> float r = (*f)(1);

А> delete func[0];
А> delete func[1];
А>}
А>[/ccode]

Здравствуйте, Сгибатель, Вы писали:

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

С>я бы ещё добавил следующее:

С>template<class T> Function<T>* createFunction(T* p_Object, float (T::*p_Method)(int) )
С>{
С> return new Function<T>(p_Object, p_Method);
С>}



а я бы еще добавил этим функторам семантику значений.

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

LV>Здравствуйте, Сгибатель, Вы писали:

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

С>>я бы ещё добавил следующее:

С>>template<class T> Function<T>* createFunction(T* p_Object, float (T::*p_Method)(int) )
С>>{
С>> return new Function<T>(p_Object, p_Method);
С>>}



LV>а я бы еще добавил этим функторам семантику значений.

Что это значит ?

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

А>Здравствуйте, lesha-v, Вы писали:

LV>>а я бы еще добавил этим функторам семантику значений.

А>Что это значит ?

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

class AbstractFunction {
public:
    virtual float operator() (int) = 0;
    virtual AbstractFunction* Clone() const = 0;
};

template<class T>
class Function : public AbstractFunction {
public:
    typedef float (T::*PFN_METHOD)(int);

    Function(T* obj, PFN_METHOD pfn) : _obj(obj), _pfn(pfn) {}

    virtual float operator() (int k) { 
        return (_obj->*_pfn)(k); 
    }
    
    virtual AbstractFunction* Clone() const
    {
        return new Function<T>(*this);
    }

protected:
    T*         _obj;
    PFN_METHOD _pfn;
};


class Func
{
public:
    Func()
      {
          impl_ = 0;
      }


    template<typename T>
    Func(T* obj, PFN_METHOD pfn)
    {
        impl_ = new Function<T>(obj, pfn);
    }
    
    Func(const Func& other)
    {
        impl_ = other.impl_->Clone();
    }

    Func& operator=(const Func& other)
    {
        delete impl_;
        impl_ = other.impl_->Clone();
    }
    
    ~Func()
    {
        delete impl_;
    }
    
    float operator() (int arg)
    {
        (*impl_)(arg);
    }
    
    AbstractFunction* impl_;
}

использование

/////////////////////////////// 
class Test1 {
public:
    float fn1(int k) {
        return 2*k;
    }
};

class Test2 {
public:
    float fn2(int k) {
        return k+100;
    }
};

/////////////////////////////////

void use() {
    Func func[2];
    Test1 t1;
    Test2 t2;

        // заполнение
    func[0] = Func(&t1, Test1::fn1);
    func[1] = Func(&t2, Test2::fn2);

    Func f=func[0];

         // вызов
    float r = f(1);
}

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

LV>а я бы еще добавил этим функторам семантику значений.
А я бы взял boost::function или CLOSURE

Автор: WolfHound
Дата: 19.09.04

(не использует динамическую память)