void f(T i)
    {
    T v;
    v = i;
    ...
    }

However, if you change T to a uniquely C++ type, like a reference type or a class type with constructors and destructors, then the examples might behave quite differently from each other. In fact, you can even declare T as a class type such that one of the above examples is valid while the other is not.

The examples behave differently in C++ because initialization is different from assignment. Although I've contrasted initialization with assignment at various times in earlier columns, the issues are so important they deserve another, more detailed, look.

T f(T a)
    {
    T b;
    ...compute b from a ...
    return b;
    }

T x, y;
...
y = f(x);

You might reasonably expect that C and C++ treat argument passing the same. But the language definitions use different words to describe argument passing semantics. The C standard says, "In preparing to call a function, the [actual] arguments are evaluated, and each [formal] parameter is assigned the value of the corresponding argument." On the other hand, the ARM (The Annotated C++ Reference Manual) states, "When a function is called, each formal argument is initialized with its corresponding actual argument." In short, C treats argument passing as assignment, but C++ treats it as initialization.

There's a corresponding difference in the way the languages describe the return statement. The C standard states, "If the [return] expression has a type different from that of the function in which it appears, it is converted as if it were assigned to an object of that type." The C++ version of the same rule is, "If required, the expression is converted, as in an initialization, to the return type of the function in which it appears." Function return is an assignment in C, but an initialization in C++.

Why the difference? For the C language types (common to C and C++), there really isn't any. C++ changed the wording of these rules to accommodate references and class objects.

A declaration like

int i, j;
...
int &ri = i;

ri = j;

The initializer for a non-const T & must be a modifiable lvalue of type T. Thus, neither

double &rd1 = 0.0;
double &rd2 = i;

const double &rd1 = 0.0;
const double &rd2 = i;

When you consider functions with reference arguments, it's not hard to see why C++ treats argument passing as initialization rather than assignment. For example, think about what happens when you call f(i) given the declarations

int i;
void f(int &r);

There was a time when C++ compilers bound non-const references to temporaries. For example, early compilers let you call f(12), binding r to a temporary int initialized to 12. Even worse, when you wrote

float x;
void g(double &r);

X b = a;

X b;
...
b = a;

Since argument passing is initialization, passing a class object by value calls a constructor. For example, given function f declared as

void f(X x);

A function that returns a class object initializes its return value by calling a constructor. For example,

X f(int i)
    {
    int j = i;
    ...
    return j;
    }

X a;
...
a = f(10);

In earlier columns, I introduced constructors and the default constructor (CUJ May 1991), copy constructors (CUJ September 1991), and assignment operators (CUJ January 1992). However, I intentionally omitted details that were inappropriate at the time. These functions are very important in C++ programming, and worth exploring in greater detail.

class X
    {
public:
    X(int n);
    ...
    };

X x0(k);

A constructor may have formal parameters, but not a return type. Constructors may be overloaded. For example,

class X
    {
    x();
    X(int n);
    ...

X x1(10);

A declaration with no argument list, such as

X x3;

X x3;      // calls X();

X x3(0);   // calls X(int n);

class X
    {
public:
    X(int n = 0);
    ...

X x3;

Always remember that

X x4(); // surprise?!

X(const X &x)

X(X &x)
X(const X &x, const char *p = 0)
X(X &x, size_t n = 100)

In effect, a copy constructor with a const argument promises not to change the object it copies. (This is true for any function with a const reference argument.) In most cases, this is what you want. A copy constructor with a non-const argument reserves the right to change the object it copies. I have never had occasion to write one. I guess these might be useful if your objects need to know if they have been copied.

A class X can overload its copy constructors with both const and non-const arguments. For example, class X can have both

X(const X &)
X(X &)

As in C, an = appearing in a C++ declaration indicates the presence of an initializer, as in

X a = b;

Which brings me to one of my favorite C++ quiz questions: If X is a class with constructors, what if any, is the difference between

X a(b);

X a = b; // ?

X a(b);

X a = b;

X a(X(b));

An optimizing compiler must not forget that = initializers have different semantics from () initializers. For example, suppose b is an int, and you declare X as

class X
    {
public:
    X(int);
private:
    X(const X &);
    ...
    };

X a(b);

X a = b;

And by the way, if X is a scalar,

X a(b);

X a = b;

int n = 1;

int n(1);

X(const X &x)

X(X &x)

Strictly speaking, the compiler doesn't actually define X's generated copy constructor unless it's used somewhere in the program. If X has a member that is an object of a class with a private constructor, the compiler can't generate X's copy constructor. A generated copy constructor is always public.

The generated copy constructor always uses memberwise initialization. That is, each member of the constructed object gets initialized by the corresponding member of the copied object. For example, if X has data members a and b, the generated memberwise copy constructor behaves just like

X(const X &x) : a(x.a), b(x.b) { }

X &operator=(const X &x)

X &operator=(X &x)

As with the generated copy constructor, the compiler doesn't actually define X's generated operator= unless it's used somewhere in the program. If X has a member that is a const object, a reference, or an object of a class with a private operator=, the compiler can't generate X's operator=.

The generated assignment operator always uses memberwise assignment. That is, each member of the constructed object gets assigned the corresponding member of the copied object. For example, if X has data members a and b, the generated memberwise assignment behaves just like

X &operator=(const X &x)
    {
    a = x.a;
    b = x.b;
    return *this;
    }

x() { }

The compiler will not define a default constructor for a class that has any user-defined constructors.