Benjamin Johnson Benjamin Johnson - 21 days ago 8
C++ Question

Trying to return class type but error with template parameters

I have a total of 5 functions for overloading &, +, -, *, and / in a class that only has a dynamically created array with arrSize as a private member. I am also using a template to universalize the class and its overloaded functions. In each of the 5 functions I'm having trouble with, I'm getting the error invalid use of template-name 'SmartArray' without argument list. Here are my functions:

/* function description: overrides the & operator. Lets us concatenate two arrays together.
parameters: const SmartArray& numArray is the right-hand array being concatenated to the left-hand array.
return value: void
*/
template <class ArrType>
SmartArray<ArrType>& SmartArray::operator&(const SmartArray& numArray) const{
SmartArray concatenate(arrSize+numArray.length()); // creating object with array large enough to hold both arrays.
for(int i=0; i<arrSize; i++) // putting left-hand array into concatenated array
concatenate.elements[i] = elements[i];
for(int i=arrSize; i<arrSize+numArray.length(); i++) // puts in right-hand array elements second
concatenate.elements[i] = numArray.elements[i-arrSize];

return concatenate;
}

/* function description: overrides + operator. Lets us add the contents of two arrays together.
parameters: const SmartArray& numArray is the right-hand array being added to the left-hand array.
return value: SmartArray
*/
template <class ArrType>
SmartArray SmartArray::operator+(const SmartArray& numArray) const{
SmartArray added; // initializes array to hold added arrays
if(arrSize > numArray.length()){ // checks which array is larger, then creates new array with the larger size
SmartArray added(arrSize);
for(int i=0; i<numArray.length(); i++)
added.elements[i] += numArray.elements[i];
for(int i=numArray.length(); i<arrSize; i++)
added.elements[i] = numArray.elements[i];
}else if(arrSize <= numArray.length()){
SmartArray added(numArray.length());
for(int i=0; i<arrSize; i++)
added.elements[i] += numArray.elements[i];
for(int i=arrSize; i<numArray.length(); i++)
added.elements[i] = numArray.elements[i];
}
return added;
}

/* function description: overrides + operator. Lets us subtract the contents of two arrays together.
parameters: const SmartArray& numArray is the right-hand array being subtracted to the left-hand array.
return value: SmartArray
*/
template <class ArrType>
SmartArray SmartArray::operator-(const SmartArray& numArray) const{
SmartArray subtracted; // initializes array to hold subtracted arrays
if(arrSize > numArray.length()){ // checks which array is larger, then creates new array with the larger size
SmartArray subtracted(arrSize);
for(int i=0; i<numArray.length(); i++)
subtracted.elements[i] -= numArray.elements[i];
for(int i=numArray.length(); i<arrSize; i++)
subtracted.elements[i] = numArray.elements[i];
}else if(arrSize <= numArray.length()){
SmartArray subtracted(numArray.length());
for(int i=0; i<arrSize; i++)
subtracted.elements[i] -= numArray.elements[i];
for(int i=arrSize; i<numArray.length(); i++)
subtracted.elements[i] = numArray.elements[i];
}
return subtracted;
}

/* function description: overrides + operator. Lets us multiply the contents of two arrays together.
parameters: const SmartArray& numArray is the right-hand array being multiplied to the left-hand array.
return value: SmartArray
*/
template <class ArrType>
SmartArray SmartArray::operator*(const SmartArray& numArray) const{
SmartArray multiplied; // initializes array to hold multiplied arrays
if(arrSize > numArray.length()){ // checks which array is larger, then creates new array with the larger size
SmartArray multiplied(arrSize);
for(int i=0; i<numArray.length(); i++)
multiplied.elements[i] *= numArray.elements[i];
for(int i=numArray.length(); i<arrSize; i++)
multiplied.elements[i] = numArray.elements[i];
}else if(arrSize <= numArray.length()){
SmartArray multiplied(numArray.length());
for(int i=0; i<arrSize; i++)
multiplied.elements[i] *= numArray.elements[i];
for(int i=arrSize; i<numArray.length(); i++)
multiplied.elements[i] = numArray.elements[i];
}
return multiplied;
}

/* function description: overrides + operator. Lets us divide the contents of two arrays together.
parameters: const SmartArray& numArray is the right-hand array being divided to the left-hand array.
return value: SmartArray
*/
template <class ArrType>
SmartArray SmartArray::operator/(const SmartArray& numArray) const{
SmartArray divided; // initializes array to hold divided arrays
if(arrSize > numArray.length()){ // checks which array is larger, then creates new array with the larger size
SmartArray divided(arrSize);
for(int i=0; i<numArray.length(); i++)
divided.elements[i] /= numArray.elements[i];
for(int i=numArray.length(); i<arrSize; i++)
divided.elements[i] = numArray.elements[i];
}else if(arrSize <= numArray.length()){
SmartArray divided(numArray.length());
for(int i=0; i<arrSize; i++)
divided.elements[i] /= numArray.elements[i];
for(int i=arrSize; i<numArray.length(); i++)
divided.elements[i] = numArray.elements[i];
}
return divided;
}


With the very first function, I tried using

SmartArray<ArrType>& SmartArray::.....


but I got the error "'template class SmartArray' used without template parameters."

Answer

Everywhere you declare a variable of SmartArray type, you need to include the templated type to use. For example,

template <class ArrType>
SmartArray<ArrType> SmartArray::operator&(const SmartArray<ArrType>& numArray) const{
    SmartArray<ArrType> concatenate(arrSize+numArray.length());

Note the addition of <ArrType> to the declaration of numArray in the parameter list and the concatenate local variable. I've also removed the & from the function return type, since you don't want to return a reference to a local variable.

You'll have to make similar changes to your other functions.

Comments