C++ Compiler background of construting objects [closed] - c++

Question

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 7 years ago.
Improve this question
For example I have line of code:
EDITED:
MyClass myObject = MyClass(5);
Here, the constructor of MyClass MyClass() will be called. It take the parameter and does what suposed..
But I this example myObject is not a reference - it is an actual object. So how the compiler do this:
construct an object by MyClass constructor, which does not know the location of actual object
(by saying location I mean address in RAM on stack).
Same question applies also to other examples (myObject = new MyClass(5);, myobject(5), etc.)
EDIT
1) Why MyClass myObject = MyClass(i);
This is actually equivalent to: MyClass myObject(i);
2) Is in this case "=" is operator= (overloaded)?
3) Can you please write an equivalent code to compiler generated operations?
4) What role copy-constructor acts here (MyClass myObject = MyClass(i);)?

Answer 1

MyClass myObject = MyClass( int i );
This is a syntax error, an illegal mixture of declaration and use. You probably meant:
int i = 42;
MyClass myObject = MyClass( i );
This is actually equivalent(*) to:
MyClass myObject( i );
This declares a MyClass object with local scope ("on the stack"), and then initializes the memory using the MyClass constructor.
myObject = new MyClass(int i);
Again, this is an invalid mix of declaration and use syntax. You probably meant:
int i = 42;
MyClass * myObject = new MyClass( i );
This allocates dynamic storage ("on the heap") and constructs a MyClass object there.
A pointer to that memory / object is then assigned to myObject, which is of type pointer to MyClass.
In both cases, the constructor initializes a MyClass object at {some memory location}. Which location that is depends on the context in which the constructor is called. The compiler knows that context, and knows (how to obtain) the memory address at runtime.
Answering the added questions (which, actually, should be separate questions):
1) Why MyClass myObject = MyClass(i); This is actually equivalent to: MyClass myObject(i);
This looks like a constructor call creating a temporary MyClass object which is then assigned (operator=()) to myObject.
But it is not, because that would be just stupid.
Since myObject -- the object assigned to -- is created by this statement, and the temporary would not exist after this statement, the C++ standard allows the "temporary" MyClass object to be created in place of myObject by the constructor(*), avoiding the duplicate effort of construction / assignment / destruction of the temporary.
(A mechanic that C++11 expanded to any kind of temporaries, in a way, with the advent of the "move" semantics and && rvalue references.)
Consider:
#include <iostream>
class MyClass
{
public:
MyClass( int i ) : member( i ) { std::cout << "const\n"; }
~MyClass() { std::cout << "dest\n"; }
MyClass & operator=( MyClass const & other ) { std::cout << "assign\n"; }
private:
int member;
};
int main()
{
MyClass x = MyClass(42);
}
This will print:
const
dest
There is no assignment.
2) Is in this case "=" is operator= (overloaded)?
No. As I said, that specific statement is equivalent to MyClass myObject( i ) -- no assignment taking place, just in-place construction.
3) Can you please write an equivalent code to compiler generated operations?
I don't think you will learn much by looking at disassembly. And anyway, your compiler is better at that than I am. (Or you are.)
4) What role copy-constructor acts here (MyClass myObject = MyClass(i);)?
What role? I have no idea what you mean.
(*): As rici correctly pointed out, the copy elision making this equivalent is only legal if a visible copy / move constructor exists.