Introduction

1. A declaration tells compilers about the name and type of an object, function, class, or template, but it omits certain details.

2. A definition, on the other hand, provides compilers with the details. For an object, the definition is where compilers allocate memory for the object. For a function or a function template, the definition provides the code body. For a class or a class template, the definition lists the members of the class or template.

3. When you define a class, you generally need a default constructor if you want to define arrays of objects.Incidentally, if you want to create an array of objects for which there is no default constructor, the usual ploy is to define an array of pointers instead. Then you can initialize each pointer separately by using new.

4. Probably the most important use of the copy constructor is to define what it means to pass and return objects by value.

5. From a purely operational point of view, the difference between initialization and assignment is that the former is performed by a constructor while the latter is performed by operator=. In other words, the two processes correspond to different function calls. The reason for the distinction is that the two kinds of functions must worry about different things. Constructors usually have to check their arguments for validity, whereas most assignment operators can take it for granted that their argument is legitimate (because it has already been constructed). On the other hand, the target of an assignment, unlike an object undergoing construction, may already have resources allocated to it. These resources typically must be released before the new resources can be assigned. Frequently, one of these resources is memory. Before an assignment operator can allocate memory for a new value, it must first deallocate the memory that was allocated for the old value.

//  a possible String constructor
String::String( const   char   * value)
{
     if  (value)
     { 
         //  if value ptr isn't null
        data  =   new   char [strlen(value)  +   1 ];
        strcpy(data,value);
    }     
     else  
     { 
         //  handle null value ptr3
        data  =   new   char [ 1 ];
         * data  =   ' \0 ' ;  //  add trailing
         null   char
    }
}

//  a possible String assignment operator

String &  String:: operator = ( const  String &  rhs)
{
     if  ( this   ==   & rhs)
         return   * this ;  //  see Item 17

    delete [] data;  //  delete old memory
    
    data  =   //  allocate new memory
         new   char [strlen(rhs.data)  +   1 ];

    strcpy(data, rhs.data);
    
     return   * this ;  //  see Item 15
}

6. These different casting forms serve different purposes:

const_cast is designed to cast away the constness of objects and pointers, a topic I examine in Item 21.

dynamic_cast is used to perform "safe downcasting," a subject we'll explore in Item 39.

reinterpret_cast is engineered for casts that yield implementation-dependent results, e.g., casting between function pointer types. (You're not likely to need reinterpret_cast very often. I don't use it at all in this book.)

static_cast is sort of the catch-all cast. It's what you use when none of the other casts is appropriate. It's the closest in meaning to the conventional C-style casts.