抽象类和静态方法

Question

我有一个抽象类：

class A 
{ 
    public: 
    bool loaded_; 
    virtual int load() = 0; 
} 

和几个派生类：

class B:public A 
{ 
    public: 
    int load(); 
    static B& instance(); 
} 

class C:public A 
{ 
    public: 
    int load(); 
    static C& instance(); 
} 

事实是，里面的代码::实例（）方法是相同的每个类：

static B& B::instance() 
{ 
    static B instance_; 
    if (!instance_.loaded_) 
    { 
    instance_.load(); 
    instance_.loaded_=true; 
    } 
    return instance_; 
} 

static C& C::instance() 
{ 
    static C instance_; 
    if (!instance_.loaded_) 
    { 
    instance_.load(); 
    instance_.loaded_=true; 
    } 
    return instance_; 
} 

我想分解此::实例方法，但假设它使用虚方法:: load，ic annot在A类中定义它。 从理论上讲，我知道它很奇怪，因为A类应该有0个实例，而B应该有1个实例，但是这个代码应该被分解也是有意义的。

你会如何解决这个问题？

Answer 1

你可以做instance()自由函数模板：

template<class T> 
T& instance() 
{ 
    static T instance_; 
    if (!instance_.loaded_) 
    { 
    instance_.load(); 
    instance_.loaded_=true; 
    } 
    return instance_; 
} 

然后你可以使用它像这样：

instance<B>().do_stuff() 

Answer 2

这是CRTP的一个常见的用法，定义创建功能然后在每个类型中实例化：

struct A { 
    virtual ~A() {}  // don't forget to make your destructor virtual! 
    virtual void load() = 0; 
}; 
template <typename T> 
struct instance_provider { 
    static T& instance() { /* implementation */ } 
}; 
struct B : A, instance_provider<B> { 
    virtual void load(); 
}; 
struct C : A, instance_provider<C> { 
    virtual void load(); 
};