copy assigment und object construction in einer Zeile

[OrangeOwl]

Wenn ich folgende Zeilen compiliere erwarte ich eigentlich, dass
1. der default constructor der Klasse MyObject aufgerufen wird.
2. der assignment operator der Klasse MyObject aufgerufen wird.
Die Zeilen sind:
MyObject mos;
MyObject moc=mos;

Was wirklich passiert, ist, dass weder der assignment operator noch der default constructor aufgerufen wird, moc.i aber mit 0 initialisiert ist. Soll das so sein oder mach ich was falsch? Compiliert wurde das ganze mit Visual Studio 2008.

Hier ist der gesamte code:

#include "stdafx.h"
#include <iostream>

using namespace std;

class MyObject{
public:
	MyObject():i(0)
	{
		cout<<"Default constructor called\n";
	}

	MyObject& operator=(const MyObject& object)
	{
			cout<<"Object internal assignment operator called\n";
			this->i=object.i;
			return *this;
	}

	int i;

};

int _tmain(int argc, _TCHAR* argv[])
{

	cout<<"Creating object on Stack\n";
	MyObject mov;
        mov.i=1;
	cout<<"Creating reference to object\n";
	MyObject & mor=mov;
	cout<<"Creating pointer to object\n";
	MyObject * mop=&mor;
	cout<<"Creating copy of object from original\n";
	MyObject mocv=mov;//neither assignment operator nor default constructor are called. Why?
	cout<<"mocv.i should be 1 is "<<mocv.i<<"\n";//outputs 0
	cout<<"Creating 2 objects on stack, assigning one to the other\n";
	MyObject mov1;
	MyObject mov2;
	mov1=mov2;//assignment operator is called

	cout<<"Creating object on heap\n";
	MyObject * mooh/*my object on heap*/=new MyObject();
	cout<<"Copy assigning heap object to stack object\n";
	mov=*mooh;//assignment operator is called
	cout<<"Copy assigning stack object to heap object\n";
	cout<<"Creating second object on heap\n";
	MyObject * mooh2=new MyObject();
	cout<<"Copy assigning first object on heap to second object on heap\n";
	*mooh2=*mooh;//assignment operator called;
        return 0;
}

[drakon]

MyObject mocv=mov;

Hier würde ich darauf tippen, dass der copy-ctor aufgerufen wird, weil das Compiler das optimieren kann. Sonst hättest du ja eine Konstruktion und dann eine Zuweisung. Das kannst du mit dem copy-ctor kürzer haben.

[OrangeOwl]

Danke für den Tip, ist Tatsächlich so. Habe einen copy constructor hinzugefügt und der wurde aufgerufen. Sind copy assignment und copy construction richtig implementiert macht das natürlich Sinn, da es viel schneller ausgeführt wird. Muss mal ausprobieren welche Compiler Switches dafür verantwortlich sind. Eigentlich bin ich ja nicht glücklich darüber, dass der Compiler so eigenmächtig in meinen Code eingreift. Ist ja nicht so, dass das selbe Ergebnis entstehen würde.

[queer_boy]

das X x = y ist niemals eine zuweisung, sondern immer eine initialisierung. das hat nichts mit optimierungen von compilern zu tun, es ist schlicht und einfach so festgelegt, dass hier der copy-ctor verwendet wird (in gewissen situationen darf der compiler hier allerdings den tatsächlichen aufruf des copty-ctors wegoptimieren).

stichwörter zum googlen: copy-initialization und direct-initialization

[drakon]

OrangeOwl schrieb:

Danke für den Tip, ist Tatsächlich so. Habe einen copy constructor hinzugefügt und der wurde aufgerufen. Sind copy assignment und copy construction richtig implementiert macht das natürlich Sinn, da es viel schneller ausgeführt wird. Muss mal ausprobieren welche Compiler Switches dafür verantwortlich sind. Eigentlich bin ich ja nicht glücklich darüber, dass der Compiler so eigenmächtig in meinen Code eingreift. Ist ja nicht so, dass das selbe Ergebnis entstehen würde.

Doch, wenn du es richtig machst, darf das keine Rolle spielen, was aufgerufen wird. Darum wird von denen ja von den "Grossen 3" gesprochen, das heisst, wenn du einen assignment-ctor, copy-ctor oder d-tor brauchst, brauchst du auch die anderen 2.

[OrangeOwl]

Die Regel kannte ich nicht bzw. war mir nicht klar was ihre Missachtung für folgen haben kann. Also, danke nochmal, auch für diesen Hinweis.