C++ 具有多个非默认构造函数基的单例派生类

我有一个从多个基类派生的类，我想把它变成一个单例。问题是派生类和基类不使用默认构造函数和参数，所以我不知道如何管理。我希望能够将参数传递给构造函数，但我只希望能够传递一次，我不希望它成为setter。我唯一的解决方案是派生类的getInstance成员中的静态bool值

基本情况：

//Singleton Derived Class with multiple bases of non-default constructors
class base1 {
    public:
        base1(int* value) :
              val_{value} {;}
        ~base1();
    private:
        int val_;
}

class base2 {
    public:
        base2(int* value) :
              val_{value} {;}
        ~base2();
    private:
        int val_;      
}

class derived : public base1, public base2 {
    public:
        derived(int* value) :
                base1{value},   //Base 1 constructor call
                base2{value},   //Base 2 constructor call
                val_{value} {;}
        ~derived();
    private:
        int val_;
}

//Creation
derived newDerived(&value);

试着让它像单身汉一样

//Lets make it a singleton
class base1 {
    public:
        base1(); //Can I pass the construtor anything?
        ~base1();
    private:
        int val_;
}

class base2 {
    public:
        base2(); //Can I pass the construtor anything?
        ~base2();
    private:
        int val_;      
}

class derived : public base1, public base2 {
    public:
        static derived& getInstance(int* value) {
            static bool init;
            if (!init) {
                base1::val_ = value;
                base2::val_ = value;
                init=true;
            }
            static derived instance;
            return instance;
        }
        derived(int* value) {;}
        ~derived();
    private:
        derived(derived const&) = delete;           //Copy construct
        derived(derived&&) = delete;                //Move construct
        derived& operator=(derived const&) = delete;//Copy assign
        derived& operator=(derived &&) = delete;    //Move assign
        int val_;
}

//Creation
derived::getInstance(&value);

---

我在寻找我应该如何做的方向，或者我根本不应该做的原因？谢谢

给你。这里我使用的不是引用而是指针。这只是一个示例，因此我不会将此单例作为线程安全的。还将默认构造函数声明为private，以便它不能被实例化

class base1 {
public:
     base1(int* value) : val_(*value) {}
    ~base1() {};
    private:
        int val_;
};

class base2 {
 public:
    base2(int* value) :
    val_(*value ) { }
    ~base2() {};
private:
    int val_;
};

class derived : public base1, public base2 {
    private:
    derived(int* value) :
    base1(value),   //Base 1 constructor call
    base2(value),   //Base 2 constructor call
    val_(*value) {}
   ~derived() {};
     private:
     int val_;
     static derived* driv;

    public:
  static derived* getInstance(int* value);
};

 derived* derived::driv = NULL;

derived* derived::getInstance(int* value)
{
    if (driv == NULL)
    {
      driv = new derived(value);
    }
  return driv;
} 

---

只需将它们传递到这个单例的构造函数中。将其存储为静态局部变量并不是一个好主意，除了使用默认构造函数创建实例之外，您还放弃了对实例生存期的控制。如果使用惰性初始化，我可以将“int*value”传递给派生构造函数，并保持一切不变，这就是你的建议吗？为什么要使用singleton？看起来不错，谢谢。我想我不理解指针vs引用方法的优点，但是，我仍然需要显式删除copy/assignment/move构造函数，对吗？您只需要利用基类析构函数来释放内存。请参阅联机文档如何释放singleton类的内存。