This constructor is referred to as the class copy constructor, and we shall see a great deal more of it in later chapters Here is our implementation, once again ignoring possible run-time program anomalies:

IntArray:: IntArray( const IntArray &rhs ) { // copy constructor _size = rhs_size; ia = new int[ _size ]; for ( int ix=0; ix < _size; ++ix ) ia[ ix ] = rhsia[ ix ]; }

This example introduces a new compound type, that of a reference ( IntArray &rhs) A reference is a kind of pointer without the special pointer syntax (Thus, we write rhs_size and not rhs->_size) Like a pointer, a reference provides indirect access to an object (We have more to say about references and pointers in Section 36) Notice that all three constructors are implemented in similar ways In general, when two or more functions duplicate the same general code, it makes sense to factor the code into a separate function that can be shared between them Later, if a change in the implementation is required, it need be made only once Moreover, the shared nature of the implementation is easier for the human reader to grasp How might we factor our constructors' code into an independent, shared function Here is one possible implementation:

class IntArray { public: // private: void init( int sz, int *array ); // }; void IntArray:: init( int sz, int *array ) { _size = sz; ia = new int[ _size ]; for ( int ix=0; ix < _size; ++ix ) if ( ! array ) ia[ ix ] = 0; else ia[ ix ] = array[ ix ]; }

Our three rewritten constructors are as follows:

IntArray::IntArray( IntArray::IntArray( { init( IntArray::IntArray(

int sz ){ init( sz, 0 ); } int *array, int sz ) sz, array ); } const IntArray &rhs )

file:///F|/WinDDK/resources/CPPPrimer/c++primerhtm (43 / 1065) [2001-3-29 11:32:02]

{ init( rhssize, rhsia ); }

The class mechanism also supports a special destructor member function A destructor is automatically invoked on each class object after the final use of the object in our program We identify a destructor by giving it the name of the class preceded by a tilde (~) The destructor in general frees resources acquired during the construction and use of the class object In the IntArray destructor, for example, the memory allocated during construction is deleted Here is our implementation (constructors and destructors are discussed in detail in 14):

class IntArray { public: // constructors explicit IntArray( int size = DefaultArraySize ); IntArray( int *array, int array_size ); IntArray( const IntArray &rhs ); // destructor ~IntArray() { delete [] ia; } // private: // };

The array class will not be of much practical interest unless users can easily index into a class object to access individual elements For example, our class needs to support the following general usage:

IntArray array; int last_pos = arraysize()-1; int temp = array[ 0 ]; array[ 0 ] = array[ last_pos ]; array[ last_pos ] = temp;

We support indexing into an IntArray class object by providing a class-specific instance of the subscript operator Here is our implementation supporting the required usage

#include <cassert> int& IntArray:: operator[]( int index ) { assert( index >= 0 && index < size ); return ia[ index ]; }

In general, the language supports operator overloading in which a new instance of an operator can be defined for a particular class type Typically, a class provides one or more instances of the assignment operator, the equality operator, perhaps one or more relational operators, and an iostream input and output operator (We provide additional illustrations of overloaded operators in Section

file:///F|/WinDDK/resources/CPPPrimer/c++primerhtm (44 / 1065) [2001-3-29 11:32:02]