我需要实现对实现相同接口的对象向量的有效访问。到目前为止，我一直在使用虚函数的继承：接口被定义为具有纯虚函数的抽象类，并且每个对象类都实现了虚函数。对象向量只是抽象类上的指针向量（参见消息末尾的动态访问示例）。
我需要更快地访问对象集合。因为我在编译时知道所有可能的对象类，所以我使用 boost::variant 来实现对象集合（即 boost::variant 的向量）。我需要访客计划的额外定义才能通过集合。为了明确表示所有对象都实现相同的接口，我使用 CRTP 来获得静态继承：接口是 CRTP 抽象，并且每个对象类都派生自模板化的 CRTP 抽象类。
这是 CRTP 实现的示例。该接口简单地定义了两个函数f()和g(double). 有两个派生类C1并C2实现接口（具有相同的行为）。
#include <vector>
#include <boost/foreach.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/variant.hpp>
namespace testVariantSimple
{
// Definition of the interface (abstract class).
template< typename C >
struct CBase
{
void f() { static_cast<C&>(*this).f(); }
int g(const double & x) { return static_cast<C&>(*this).g(x); }
};
// Definition of the first implementation.
struct C1 : public CBase<C1>
{
void f();
int g(const double & x);
};
void C1::f() { return ; }
int C1::g(const double & x) { return sizeof(x); }
// Definition of the second implementation.
struct C2 : public CBase<C2>
{
void f();
int g(const double & x);
};
void C2::f() { return ; }
int C2::g(const double & x) { return sizeof(x); }
// Definition of the visitor for the first function of the interface.
class f_visitor : public boost::static_visitor<int>
{
public:
template< typename C >
int operator()(CBase<C> &c ) const { c.f(); return 0; }
};
// Definition of the visitor for the second function of the interface.
struct g_visitor : public boost::static_visitor<int>
{
const double & x;
g_visitor( const double & x ) : x(x) {}
public:
template< typename C >
int operator()(CBase<C> & c) const { return c.g(x); }
};
// Example of use: construct a random collection and visit it.
void test(int nbSample)
{
typedef boost::variant<C1,C2> CV;
std::vector<CV> vec;
for( int i=0;i<nbSample;++i )
{
switch( std::rand() % 2 )
{
case 1: vec.push_back( C1() ); break;
case 2: vec.push_back( C2() ); break;
}
}
double argdouble;
BOOST_FOREACH(CV & c, vec)
{
boost::apply_visitor( f_visitor(), c );
g_visitor g(argdouble);
boost::apply_visitor( g, c );
}
}
}
这段代码有效，并且比使用动态继承的代码效率高 15 倍（有关使用动态的代码，请参见消息末尾）。对于不熟悉 CRTP 的人来说，代码阅读起来稍微困难一些，但维护或编写起来并不困难。由于 CRTP 的接口是显式的，因此访问者实现相当琐碎，但冗长，难以理解和使用。
我的问题很简单：是否可以从 CRTP 界面自动定义访问者。我想避免 and 的额外定义f_visitor，g_visitor并获得更易读的外观：
BOOST_FOREACH( CV & c, vec )
{
c.f();
c.g(argdouble);
}
谢谢你的帮助。对于感兴趣的读者，这里是使用虚拟继承的相同代码。
namespace testDynamicSimple
{
struct CBase
{
virtual void f() = 0;
virtual int g(const double & x) = 0;
};
struct C1 : public CBase
{
void f() {}
int g(const double & x) { return 1; }
};
struct C2 : public CBase
{
void f() {}
int g(const double & x) { return 2; }
};
bool test(int nbSample)
{
typedef boost::shared_ptr<CBase> CV;
std::vector<CV> vec;
for( int i=0;i<nbSample;++i )
{
switch( std::rand() % 5 )
{
case 1: vec.push_back( CV(new C1()) ); break;
case 2: vec.push_back( CV(new C2()) ); break;
}
}
double argdouble = 0.0;
BOOST_FOREACH( CV & c, vec)
{
c->f();
c->g(argdouble);
}
}
}