реализация виртуальных функций не в своем классе

[pproger]

добрый день. такой вопрос.

есть базовый класс

class Base {
public:
	virtual void foo() = 0;

	void call()
	{
		foo();
	}
};

наследую от него

class A : public Base {
public:
};

но!!! я не хочу в классе A реализовывать чисто виртуальную функцию. хочу ее реализовать, например тут

class MyPolicy {
public:
	virtual void foo()
	{
		cout << "foo called" << endl;
	}
};

вопрос. как заставить класс A думать, что его вирт функция это Policy::foo? класс Base шаблонным делать нельзя MyPolicy так же ничего не должен знать о Base, т.е делать

class Policy : public Base {};
class A : public Policy {};

не хочется

как вариант, можно загнать в макрос перенаправление вызовов (A-->Policy). но хочется еще проще

загнал в макрос, получилось такое

#define CLASS_POLICY_REDIRRECTION(POLICY) \
protected: \
	inline void foo() { POLICY::foo(); } \
private:

class A : public Base, public MyPolicy {
    CLASS_POLICY_REDIRRECTION(MyPolicy)

public:
};

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


придумал. если кому вдруг интересно

#include <iostream>
#include <memory>

using namespace std;

class BasePolicy {
public:
	virtual ~BasePolicy() {}
	virtual void foo() = 0;
};

class Base {
public:
	Base(BasePolicy *b) : pol(b)
	{
		cout << "created" << endl;
	}

	virtual ~Base()
	{
		cout << "destroyed" << endl;
		delete pol;
	}

	void call()
	{
		pol->foo();
	}

	BasePolicy *getPol() { return pol; }

private:
	BasePolicy *pol;
};

class Policy1 : public BasePolicy {
public:
	void foo()
	{
		cout << "Policy1 foo called" << endl;
	}
};

class Policy2 : public BasePolicy {
public:
	void foo()
	{
		cout << "Policy2 foo called" << endl;
	}
};


class A : public Base {
public:
	A() : Base(new Policy1)
	{
		getPol()->foo();
	}
};

class B : public Base {
public:
	B() : Base(new Policy2)
	{
		getPol()->foo();
	}
};

int main()
{
	auto_ptr<Base> a(new A);
	auto_ptr<Base> b(new B);
	a->call();
	b->call();
	return 0;
}

всем спасибо за участие



ай нет, подсказали еще более лучший вариант) заменить диспетчеризацию на non virtual interface

#include <iostream>
#include <memory>

using namespace std;

class Base {
public:
	virtual void foo() = 0;

	void f()
	{
		foo();
	}
};

template<typename T>
class BaseImpl : public Base {
public:
	virtual void foo()
	{  
		static_cast<T *>(this)->call_foo();
	}
};

class Policy1 {
public:
	void call_foo()
	{
		cout << "Policy1 foo called" << endl;
	}
};

class Policy2 {
public:
	void call_foo()
	{
		cout << "Policy2 foo called" << endl;
	}
};

class A : public Policy1, public BaseImpl<A> {
};

class B : public Policy2, public BaseImpl<B> {
};

int main()
{
	(new A)->foo();
	(new B)->foo();
	return 0;
}

вот это уже идеально

[sashonk]

рассказали бы тогда еще зачем такие конструкции использовать.

[pproger]

для того, чтобы создавать дочерние классы от base с возможностью выбрать нужный policy (на стадии компиляции). так же именно этот policy должен был использоваться функциями класса base.