Constructors are a common idiom in C++. They are used to create objects and define functions to help an object grow. With that in mind, the parameterized constructor is the first parameter to a constructor. This allows a constructor to add an object to the end of an array or list of objects. The way this works is that the constructor creates an object of the type specified in the first parameter and then creates a temporary instance of that object to be passed in the second parameter.
It looks kind of simple, but the problem lies in the way these constructors are implemented. The first parameter to the constructor is a pointer to an object. This object isn’t initialized, so it has no way of knowing whether it is the constructor’s first or second parameter. This type of constructor is called a value-initializer and is an example of the sort of constructors that we are talking about.
It looks like that is where the problem lies and that the developer of the compiler should take care of it, but in fact, parameterized constructors are a very bad idea because they are a nightmare to debug. The problem is that the compiler is allowed to pass in a pointer to a temporary object to the constructor of the second parameter, which is basically the same as the first parameter.
In the example, we have a pointer to a temporary object that the compiler (the C++ compiler) passed into a parameterized constructor of the second parameter. You can see this by looking at the code in the question.
The problem is that the compiler is now saying, “I don’t know what the parameters are supposed to be, but I need to construct a temporary object for all of them. Let’s do it this way.” But we know that we shouldn’t do that. The compiler has to figure out the values, so it doesn’t make sense to pass the temporary object into the constructor of the second parameter. But that’s just the compiler telling us what to do.
In c++ we don’t pass parameters into constructors.
It is possible to write code without using a constructor.
We do have to use constructors, but they’re pretty simple. So most of our code in c++ is not using them. In fact, the only time we use them is when we need to pass temporary objects to a function, and those are the only times they are used.
The other thing that is possible to do in c++ is to parameterize a constructor. I’ll explain what that means. It means that we dont use the first parameter of the constructors, but we pass the second parameter. That second parameter is the parameter that has to be passed to the function. We usually pass the first parameter to the function, and the compiler takes care of the rest. But there are exceptions. In this case, you can pass in a reference to a temporary object.