Re: Constructor initializations - which way better why?

Maybe for a simple type like an integer the compiler outputs the same
code (is it an optimization?), but for a non-simple type, from what I
know of C++ theory, the example A calls only a constructor, while the
example B calls the default constructor and then operator =.

It is exactly what is shown in the following example:

<OUTPUT>

Case A:
NonSimple Ctor

Case B:
NonSimple Default Ctor
NonSimple Ctor
NonSimple operator=

</OUTPUT>

<CODE>

//
// *** TEST C++ OBJECT CONSTRUCTION ***
// [by MrAsm]
//

#include <iostream>
#include <string>
#include <sstream>

using std::cout;
using std::endl;
using std::string;
using std::ostringstream;

//
// A "non-simple" class
//
class NonSimple
{
public:
   NonSimple();
   NonSimple( int nn, const string & ss );
   NonSimple(const NonSimple & src);

   NonSimple & operator=(const NonSimple & src);

   string ToString() const;

   int n;
   string s;
};

NonSimple::NonSimple()
{
   cout << "NonSimple Default Ctor" << endl;
}

NonSimple::NonSimple( int nn, const string & ss )
: n(nn), s(ss)
{
   cout << "NonSimple Ctor" << endl;
}

NonSimple::NonSimple(const NonSimple & src)
: n(src.n), s(src.s)
{
   cout << "NonSimple Copy Ctor" << endl;
}

NonSimple & NonSimple::operator=(const NonSimple & src)
{
   cout << "NonSimple operator=" << endl;

   if (&src != this)
   {
       n = src.n;
       s = src.s;
   }
   return *this;
}

string NonSimple::ToString() const
{
   ostringstream os;
   os << "[NonSimple] n = " << n << "; s = " << s;
   return os.str();
}

//
// Case A
//
class A
{
public:

   // C++ typical initialization
   A() : x(1, "Case A") {}

   NonSimple x;
};

//
// Case B
//
class B
{
public:

   // Case A should be better...
   B() { x = NonSimple(2, "Case B"); }

   NonSimple x;
};

//
// TEST
//
int main()
{
   cout << "Case A:" << endl;
   A a;

   cout << endl << endl << "Case B:" << endl;
   B b;

   system("PAUSE");
   return 0;
}

//
// END
//

</CODE>

MrAsm