- Sue.

Initialization and assignment are different operations, with different uses and different implementations.

Let’s get it absolutely straight. Assignment occurs when you assign. All the other copying you run into is initialization, including initialization in a declaration, function return, argument passing, and catching exceptions.

Assignment and initialization are essentially different operations not only because they’re used in different contexts but also because they do different things. This difference in operation is not so obvious in the built-in types such as int or double, because, in that case, both assignment and initialization consist simply of copying some bits (but see also References Are Aliases, Not Pointers [5, 13]):

int a = 12; // initialization, copy 0X000C to a
a = 12; // assignment, copy 0X000C to a

However, things can be quite different for user-defined types. Consider the following simple, nonstandard string class:

class String {
public:
String( const char *init ); // intentionally not explicit!
~String();
String( const String &that );
String &operator =( const String &that );
String &operator =( const char *str );
void swap( String &that );
friend const String // concatenate
operator +( const String &, const String & );
friend bool operator (::operator new( BUFSIZ ));
names[0] = “Sakamoto”; // oops! delete [] uninitialized pointer!

In this case, names refers to uninitialized storage because we called operator new directly, avoiding implicit initialization by String’s default constructor; names refers to a hunk of memory filled with random bits. When the String assignment operator is called in the second line, it will attempt to perform an array delete on an uninitialized pointer. (See Placement New [35, 119] for a safe way to perform an operation similar to such an assignment.)

Because a constructor has less work to do than an assignment operator (in that a constructor can assume it’s working with uninitialized storage), an implementation will sometimes employ what’s known as a “computational constructor” for efficiency:

const String operator +( const String &a, const String &b )
{ return String( a.s_, b.s_ ); }

The two-argument computational constructor is not intended to be part of the interface of the String class, so it’s declared to be private.

String::String( const char *a, const char *b ) {
s_ = new char[ strlen(a)+strlen(b)+1 ];
strcat( strcpy( s_, a ), b );
}