Re: Constructor initializations - which way better why?

From:

MrAsm <mrasm@usa.com>

Newsgroups:

microsoft.public.vc.mfc

Date:

Wed, 07 Mar 2007 07:40:22 GMT

Message-ID:

<f1qsu2t6nqmit674meoum6jogv9ogfgk7h@4ax.com>

On Wed, 07 Mar 2007 02:06:22 -0500, Joseph M. Newcomer
<newcomer@flounder.com> wrote:

Just to point out that arguments about "faster" are usually meaningless unless there is
actual analysis, here are two examples, and the generated code is shown. Note that the
code is identical.
                joe

class A {
public:
   A() : x(5) {}
protected:
   int x;
   };
class B {
public:
   B() { x = 5; }
protected:
   int x;
   };

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