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();
}

事实上，:: 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_;
}

我想对这个:: instance方法进行分解，但是假设它使用了虚方法:: load，我无法在类A中定义它。从理论上讲，我知道这很奇怪，因为A类应该有0个实例和B，C应该有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();
};

抽象类和静态方法

2 个答案: