Otdfbt

Why am I not able to call the appropriate constructor for the Geometry object?

class Geometry 
private:
 float fRadius;
 int iSegments;
 float fWidth;
 float fLenght;
 std::string stdstrType;
 bool bValid;

public:
 Geometry() 
 // Set data Elements
 qDebug() << "Constructor 1 is called";
 

 Geometry(float Radius, int Segments, float Width, float Length,
 std::string strType, bool bValue) 
 // Set data Elements
 qDebug() << "Constructor 2 is called";
 

 Geometry(const Geometry & g) 
 // Set data Elements
 qDebug() << "Constructor 3 is called";
 

I use this class as a data variable in another class.

class Container 
private:
 std::string stdstrContainerName;
 std::string stdstrPluginType;
 Geometry Geom;

public:
 Container();
 Container(std::string, std::string, Geometry geometry);
;

Container::Container() 
 stdstrContainerName = "Group";
 stdstrPluginType = "Geometry";


Container::Container(std::string strName, std::string strType,
 Geometry geometry) 
 stdstrContainerName = stdstrContainerName;
 stdstrPluginType = stdstrPluginType;
 Geom = geometry;

When I try to set a Geometry object in the container, even though I have given all the parameters for constructor 2 to be called, constructor 1 is called.

geometry(0.3, 32, 0.0, 0.0, "SPHERE", true);
Container cont("Sphere", "SPHERE", geometry);

Regarding your use case, here's what each line calls:

Geometry geometry(0.3, 32, 0.0, 0.0, "SPHERE", true); // Geometry constructor 2 
Container cont("Sphere", "SPHERE", geometry); // Container constructor 2, Geometry constructors 3 & 1 

Here, the constructor for Geometry is actually called outside the constructor of Container. But Geometry constructor 3 and 1 are also being called... why?

Why indeed. Since the constructor for Container takes a Geometry parameter by value, the geometry object passed will be copied (hence, the copy constructor is called). Next, Geometry constructor 1, aka the default constructor is actually called in the constructor of Container. Afterwards, copy-assignment, another implicitly-generated special method, is called:

Container::Container(std::string strName, std::string strType, Geometry geometry)
 /*: stdstrContainerName()
 , stdstrPluginType()
 , Geom()*/ // default-constructors implicitly called as member-initialisation 

 stdstrContainerName = stdstrContainerName;
 stdstrPluginType = stdstrPluginType;
 Geom = geometry; // copy-assignment, i.e. operator= (Geometry const&) 

To override the default behaviour, use member initialisation explicitly:

Container::Container(std::string strName, std::string strType, Geometry geometry)
 : stdstrContainerName(strName)
 , stdstrPluginType(strType)
 , Geom(geometry) // copy-constructor, i.e. Geometry(Geometry const&) 

This should yield constructor 3, as the copy-constructor is now called.

Demo

On switching over to member initialisation, you may have noticed that constructor 3 is called twice. Again, this is due to the constructor of Container taking its geometry parameter by value, creating a new object via copy-constructing. To prevent a copy from being made and make the constructor more efficient, we can pass geometry by reference. In addition, we can const-ify the parameter to guarantee that the reference isn't modified in the constructor.

Thus the constructor of Container can be changed to:

Container(const std::string &strName, const std::string &strType, const Geometry &geometry); 

The Container's constructor:

Container::Container(std::string strName, std::string strType, Geometry geometry)

 stdstrContainerName = stdstrContainerName;
 stdstrPluginType = stdstrPluginType;
 Geom = geometry;

doesn't have any explicit initialization of the Geom field. It is first default initialized hence the default constructor call and then you assign it the geometry argument.

To achive what you want, you need to define Container's constructor this way:

Container::Container(std::string strName, std::string strType, Geometry geometry)
: Geom(geometry)

 stdstrContainerName = strName;
 stdstrPluginType = strType;

Notice the : Geom(geometry) part. This is where the constructor of Geom is called and if you don't put something like that in your constructor then the default one is called.

Also, I'm almost certain that you have a bug in your constructor. It probably should be stdstrContainerName = strName; and not stdstrContainerName = stdstrContainerName;. The same applies to stdstrPluginType.

One more thing, this is not a bug and is technically correct but passing objects of types like std::string or Geometry (that is objects which might be 'heavy') might be decrease performance so why don't you pass them by reference? But that's not a bug (at least not in the piece of code you posted) and isn't directly related to your question.

Constructor #1 is called for the Geometry geometry argument passed by value to the constructor of Container. Because you are passing it by value, it is recreated on the stack of the constructor of Container. Change it to const Geometry& geometry.