I would like to be able to initialize a class member in one of N ways (in this examples N=2) based on a condition that is recieved via the class constructor as in the code that follows, but the MainObject's initialization seems to be only local to the (container) class' constructor. I wonder what are the best-practices for this particular pattern.
// in ContainerObject.hpp
class ContainerObject {
public:
MainClass MainObject;
ContainerObject(int type);
}
// in ContainerObject.cpp
ContainerObject::ContainerObject(int type);{
if (type == 0){
MainObject("something", 1, 2);
} else if (type == 1){
MainObject(4, "another thing", "yet another thing");
}
}
I have so-far thought about
- putting the main object in the heap
- defining N class constructors and call the appropiate one recursively inside the "main"/"first" class constructor.
please note that the "0" and "1" initialization is only an example and it could be drastically different.
EDIT1: added ";" required for compiling EDIT2: Changed the original
//...
if (type == 0){
MainObject(0);
} else if (type == 1){
MainObject(1);
}
//...
for the current one
//...
if (type == 0){
MainObject("something", 1, 2);
} else if (type == 1){
MainObject(4, "another thing", "yet another thing");
}
//...
as it was called a duplicate by being misinterpreted for a case that could be solved by adding the following.
//...
ContainerObject(int type): MainObject(type);
//...
CodePudding user response:
I am interpreting the question as "how to execute non-trivial logic before/during the member initialization list".
A good way to go about that is to delegate the work of converting the constructor parameter of the outer object into the child object to a utility function:
// in ContainerObject.cpp
#include <stdexcept> // for std::invalid_argument
// Anonymous namespace since main_factory() is only needed in this TU.
namespace {
MainClass main_factory(int type) {
if (type == 0) {
return MainClass("something", 1, 2);
} else if (type == 1) {
return MainClass(4, "another thing", "yet another thing");
}
// N.B. This is one of the scenarios where exceptions are indisputably
// the best way to do error handling.
throw std::invalid_argument("invalid type for MainClass");
}
}
ContainerObject::ContainerObject(int type)
: MainObject(main_factory(type)) {}
CodePudding user response:
A constructor is always called automatically whenever an object is created. You can never call it by yourself anywhere.