Operator přetypování – C / C++ – Fórum – Programujte.com

Mám tento kod

struct MyRef
{
	explicit MyRef(int* inRight) : 
		m_Ref(inRight)
{
}

	int* m_Ref;
};

class XXX
{
public:
	XXX(int* const Ptr = 0):
		m_Val(Ptr)
	{
		cout << "XXX::CTOR(int*)" << endl;
	}

	XXX(XXX &inRight):
		m_Val(inRight.m_Val)
  	{
		cout << "XXX::CTOR(XXX&)" << endl;
  	}

	XXX(MyRef inRight):
		m_Val(inRight.m_Ref)
  	{
		cout << "XXX::CTOR(MyRef)" << endl;
  	}

  	operator MyRef()
  	{
		cout << "operator MyRef" << endl;

	  	MyRef ret(m_Val);
	  	m_Val = 0;
	  	return ret;
  	}

  	~XXX()
  	{
		cout << "XXX::DTOR() " << m_Val << endl;
	  	delete m_Val;
  	}

private:
	int* m_Val;
};

XXX MyCreate()
{
	return XXX(new int);
}

int main()
{
	XXX a = MyCreate();

	return 0;
}

Proč se při volání funkce MyCreate volá konstructor XXX(MyRef inRight) a tím pádem operátor přetypování operator MyRef() ?

Děkuji.

Lebo ::MyCreate() vracia Rvalue a konstruktor XXX::XXX(XXX &inRight) ocakava Lvalue parameter. Skus vytvorit copy konstruktor XXX::XXX(const XXX &inRight)  alebo ak mas c++11/14 tak mozes pouzit move constructor XXX::XXX(XXX &&inRight) .

jop, delas hromadu kopii a kopirovaci konstruktor MUSI mit const parametr..

Dík, ale v tomto případě by se copy CTOR vůbec neměl volat.

Pokud dám copy CTOR jako const referenci, tak to funguje jak má a volá se pouze tento CTOR 

XXX(int* const Ptr = 0) a copy CTOR se vůbec nevolá.

pro KIIV.

Nemusí, ale vetšinou by měl.

Toto je čístě z teoretických důvodů, proč se to takto volá. Nějak mi to nedává smysl.

#5 Jurin
Ty zrejme narazas na tzv: "copy elision". Copy ctor sa nemusi volat ak kompilator vyoptymalizuje zbytocne kopie. Ak si vypnes optimalizacie tak sa ti budu volat vsetky ctory.

Já myslel, že u tohoto volání  

return XXX(new int);

je dáno standartem C++, že copy CTOR se nevolá.

Neviem ci to je v standarde, ale v gcc je mozne zadat flag -fno-elide-constructors a tym vypnut tuto optimalizaciu. 

Na strane 274|31 mas presnejsie pravidla: https://isocpp.org/files/papers/N3690.pdf

Stejně mě to furt nějak neleze do hlavy.

Když tento CTOR  XXX(MyRef inRight)  ze třídy XXX vyhodím, tak se to chová jak bych čekal, tj. volá se jenom CTOR  XXX(int* const Ptr). A copy CTOR mám pořád stejně, bez const.

Když CTOR  XXX(MyRef inRight)  přidám do XXX, tak se pro mě z nějakého záhadného důvodu začne volat.

Chová se to stejně v gcc i MS VS 2010.

#5 Jurin
MUSI .. jen si pridej do vypisu vypis << this << a uvidis, kolik kopii objektu ti tam prolezl, kdyz se snazil neco delat...

a jelikoz si nemel copy konstruktor (bez const & to proste neni copy konstruktor), tak to naslo, ze mas konstruktor z MyRef ... a ze u XXX zna konverzi na MyRef  .. .a tak dale... to samy potom u toho a = ...

#9 Jurin
skus si spustit toto a porozmyslat preco sa vystupy lisia:

struct Test{
	Test(){std::cout << "Test::Test()\n";}
	Test(Test& ){std::cout << "Test::Test(Test&)\n";}
	Test(int){std::cout << "Test::Test(int)\n";}
  	operator int(){std::cout << "Test::operator int()\n";}
  	~Test(){std::cout << "Test::~Test()\n";}
};


int main(){
    std::cout << "\nA:\n";{
        Test x;
        Test A = x;
    }

    std::cout << "\nB:\n";{
        Test B = Test();
    }

    return 0;
}

vitamin:

Tvůj příklad je jasný, mě celou dobu mátl MS překladač kde prochází tento kod. 

struct Test
{
	Test()
	{
		std::cout << "Test::Test()\n";
	}

	Test(Test&)
	{
		std::cout << "Test::Test(Test&)\n";
	}


	~Test()
	{
		std::cout << "Test::~Test()\n";
	}
};

int main()
{
	{
		Test B = Test();
	}

	return 0;
}

Díky všem za příspěvky.

#12 Jurin
To bude bug v prekladaci.