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;
}

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.

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

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.