I have an assignment to create a template for a predefined Array
class by using a type parameter and a nontype parameter. The
problem I am having is with my overloaded operators and copy
constructor. My overloaded operators give me an error that
states: "no operator defined which takes a right-hand operand of
type 'class Array<int,10>' (or there is no acceptable
conversion)". My test program gives me the following error when
I attempt to use the copy constructor: "use of class template
requires template argument list."
Could someone tell me where I am going wrong?
Here is my code and the applicable portions of the test program.
<header>
Code:template< class elementType, int numberOfElements = 10 > class Array { .. public: Array(); // default constructor Array( const Array & ); // copy constructor ~Array(); // destructor int getSize() const; // return size // assignment operator const Array &operator=( const Array & ); // equality operator bool operator==( const Array & ) const; // inequality operator; returns opposite of == operator bool operator!=( const Array &right ) const { return ! ( *this == right ); // invokes Array::operator== } // end function operator!= <definition> // copy constructor for class Array; // must receive a reference to prevent infinite recursion template< class elementType, int numberOfElements > Array< elementType, numberOfElements >::Array ( const Array &arrayToCopy ) :size( numberOfElements ) { ptr = new elementType[ size ]; // create space for array for ( int i = 0; i < size; i++ ) ptr[ i ] = arrayToCopy.ptr[ i ]; // copy into object } // end Array copy constructor // overloaded assignment operator; // const return avoids: ( a1 = a2 ) = a3 template< class elementType, int numberOfElements > const Array< elementType, numberOfElements > &Array< elementType, numberOfElements >::operator=( const Array &right ) { if ( &right != this ) { // check for self-assignment // for arrays of different sizes, deallocate original // left-side array, then allocate new left-side array if ( size != right.size ) { delete [] ptr; // reclaim space size = right.size; // resize this object ptr = new elementType[ size ]; // create space for array copy } // end inner if for ( int i = 0; i < size; i++ ) ptr[ i ] = right.ptr[ i ]; // copy array into object } // end outer if return *this; // enables x = y = z, for example } // end function operator= // determine if two arrays are equal and // return true, otherwise return false template< class elementType, int numberOfElements > bool Array< elementType, numberOfElements >::operator==( const Array &right ) const { if ( size != right.size ) return false; // arrays of different sizes for ( int i = 0; i < size; i++ ) if ( ptr[ i ] != right.ptr[ i ] ) return false; // arrays are not equal return true; // arrays are equal } // end function operator== <test program> .. Array< int, 7 > integers1; // seven-element Array Array< int > integers2; // 10-element Array by default .. // use overloaded inequality (!=) operator cout << "\nEvaluating: integers1 != integers2\n"; if ( integers1 != integers2 ) cout << "integers1 and integers2 are not equal\n"; .. // create array integers3 using integers1 as an // initializer; print size and contents Array integers3 ( integers1 ); // calls copy constructor .. // use overloaded assignment (=) operator cout << "\nAssigning integers2 to integers1:\n"; integers1 = integers2; // note target is smaller
