Singleton Derived Class with multiple bases of non-default constructors - c++

Question

I have a class derived from multiple base classes and I want to make it a singleton. Problem is the derived and base classes do not use default constructors and take arguments, so I'm confused how I can manage. I want to be able to pass the arguments to what would have been the constructor, but I only want possible to do once (I don't want it to be a setter). My only solution was a static bool value in the getInstance() member of the derived class.
Basic case:
//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);
Attempt to make it singleton-like?
//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);
I'm looking for some direction on how I should go about this, or maybe reasons I shouldn't do it at all? Thanks

Answer 1

Here you go. Instead of reference I am using pointer here. This is just an example hence I am not making this singleton as thread safe. Also declare a default constructor as private so that it can not be instantiate.
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;
}