assignment vs initialization

We have a coding guideline that says

"Always use () instead of =, unless not possible (code optimization).
For example: int x(3); instead of int x = 3;"

so we are not allowed to type X x = 2;

The argument being that it is faster to use the X x(2) form because then only the constructor is called and with X x = 2 the constructor is called and then the copy constructor.

Im convinced this is just not true but I can't persuade them and I cant find the paragraph in the standard where it talks about explicit constructor calls and the form with '='.
Anyone knows where to find this or am I wrong in thinking that the forms dont differ?

>The argument being that it is faster to use the X x(2) form because then only the
>constructor is called and with X x = 2 the constructor is called and then the copy constructor.
Ha! Unless the constructor is declared as explicit (in which case the second form is illegal), the two are identical. You can write a test program to strengthen your case:

Code:

---

#include <iostream>

class X {
public:
    X(int) { std::cout<<"Default\n"; }
    X(const X&) { std::cout<<"Copy\n"; }
};

int main()
{
    X a = 1;
    X b(1);
}

---

>Anyone knows where to find this or am I wrong in thinking that the forms dont differ?
The specific clauses can be found in section 12.3.1: Conversion by constructor. Specifically this one:

Code:

---

A constructor declared without the function-specifier explicit that can be called with a
single parameter specifies a conversion from the type of its first parameter to the type
of its class. Such a constructor is called a converting constructor. [ Example:

class X {
    // ...
public:
    X(int);
    X(const char*, int =0);
};

void f(X arg)
{
    X a = 1; // a = X(1)
    X b = "Jessie"; // b = X("Jessie",0)
    a = 2; // a = X(2)
    f(3); // f(X(3))
}

—end example ]

---

Since every modern compiler should compile them to the identical machine code, I think it is only matter of code readability, and for me the second form seems better (at least for the fundamental types).

Code:

---

#include <iostream>

class X {
public:
    X(int) { std::cout<<"Default\n"; }
    X(const X&) { std::cout<<"Copy\n"; }
};

int main()
{
    X a = 1;
    X b(1);
}

---

Pretty much the only difference here should be that the first version requires an available copy constructor. (You'll get an error if you declare the copy constructor private.)

But that doesn't mean the copy constructor will be invoked. Constructor calls can be elided in certain cases, just that the code must be valid as if they weren't elided.