Как передать, а затем вызвать общие функции обратного вызова, не вызывая циклическую зависимость

Question

Не удалось творчески сократить название :)

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

//Notice the use of template template parameter 
template <template <typename> class Callback> 
class A { 
    Callback <A> m_func; 
    public: 
    A (Callback <A> func): m_func (func) {} 
    void call() { m_func(*this);} 

}; 

template <typename T> 
struct MYCallback 
{ 
    void operator() (const T&t) {} 

}; 


void Test() 
{ 
    typedef A<MYCallback> AType; 

    MYCallback<AType> callback; 
    AType a (callback); 
    a.call(); 

} 

Другой, более suncinct способом, является использование tr1 :: функцию, которая станет defuct к новой стандартизации:

#include <tr1/functional> 


class A { 
    std::tr1::function <void (const A&)> m_func; 
    public: 
    template <class Callback> 
    A (Callback func) : m_func (func) {} 

    void call() { m_func(*this);} 

}; 

template <class T> 
struct My_callback 
{ 
    void operator() (const T&t) {} 

}; 

void Test() 
{ 
    My_callback <A> c; 
    A a (c); 
    a.call(); 
} 

Answer 1

Если вы просто ищете советы по очистке, я бы предложил сделать «My_callback» обычным классом, а не шаблоном класса. В этом случае нет очевидной необходимости, чтобы это был шаблон. Вместо этого, сделать его применить оператор шаблонным или заполнить непосредственно, если My_callback только имеет дело с экземплярами:

#include <tr1/functional> 

class A { 
    std::tr1::function <void (const A&)> m_func; 
    public: 
    template <class Callback> 
    A (Callback func) : m_func (func) {} 

    void call() { m_func(*this);} 

}; 

struct My_callback 
{ 
    template <class T> 
    void operator() (const T&t) {} 
}; 

int main() 
{ 
    My_callback c; 
    A a (c); 
    a.call(); 
} 

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

Answer 2

Я всегда считаю, что пустота * является вашим другом, когда вы хотите элегантности в этих вещах.

Answer 3

Один из способов сделать это является с производным классом:

template <class Callback> 
class A { 
    Callback m_func; 
    public: 
    A (Callback func): m_func (func){} 
    void call() { m_func(*this);} 

}; 

template <typename T> 
struct MYCallback 
{ 
    void operator() (const T&t) {} 

}; 


struct AConcrete : public A<MYCallback<AConcrete> > 
{ 
    template <class T> 
    AConcrete(T t): A<MYCallback<AConcrete> > (t) {} 
}; 

void Test() 
{ 

    MYCallback<AConcrete> callback; 
    AConcrete a (callback); 
    a.call(); 

} 

PS: Рекурсия жесток с шаблонами C++.