Trying to convert base class to a class template - c++

Question

So, I'm trying to convert an array class to a template class, so far I have combined the header and main file code into one, resulting in just the header file with all the .cpp code. Though trying to compile the code into the main file results in countless errors. Now, please go easy on me here, I am still coming to grasp with C++ here, and some of the higher functions and abilities go over my head, so I apologize in advance that I am not super familiar with all the functions. The code is below.
#ifndef ARRAY_H
#define ARRAY_H
#include <iostream>
#include <iomanip>
#include <stdexcept>
using namespace std;
template <typename GArray>
class Array
{
friend std::ostream &operator<<(std::ostream &, const Array &);
friend std::istream &operator>>(std::istream &, Array &);
public:
// default constructor for class Array (default size 3)
template <typename GArray> Array::Array(int arraySize)
: size(arraySize > 0 ? arraySize :
throw invalid_argument("Array size must be greater than 0")),
ptr(new int[size])
{
for (size_t i = 0; i < size; ++i)
ptr[i] = 0; // set pointer-based array element
} // end Array default constructor
template <typename GArray> Array::~Array()
{
delete[] ptr; // release pointer-based array space
} // destructor
size_t Array::getSize() const
{
return size; // number of elements in Array
} // end function getSize
// overloaded assignment operator;
// const return avoids: ( a1 = a2 ) = a3
template <typename GArray> const Array &Array::operator=(const Array &right)
{
if (&right != this) // avoid self-assignment
{
// for Arrays of different sizes, deallocate original
// left-side Array, then allocate new left-side Array
if (size != right.size)
{
delete[] ptr; // release space
size = right.size; // resize this object
ptr = new int[size]; // create space for Array copy
} // end inner if
for (size_t 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=
template <typename GArray> bool operator==(const Array &) const; // equality operator
// subscript operator for const objects returns rvalue
int operator[](int) const;
private:
size_t size;
int *ptr;
};
template <typename GArray> bool Array::operator==(const Array &right) const
{
if (size != right.size)
return false; // arrays of different number of elements
for (size_t i = 0; i < size; ++i)
if (ptr[i] != right.ptr[i])
return false; // Array contents are not equal
return true;
}
template <typename GArray> int Array::operator[](int subscript) const
{
if (subscript < 0 || subscript >= size)
throw out_of_range("Subscript out of range");
return ptr[subscript];
}
template <typename GArray> istream &operator>>(istream &input, Array &a)
{
for (size_t i = 0; i < a.size; ++i)
input >> a.ptr[i];
return input; // enables cin >> x >> y;
}
template <typename GArray> ostream &operator<<(ostream &output, const Array &a)
{
// output private ptr-based array
for (size_t i = 0; i < a.size; ++i)
{
output << setw(12) << a.ptr[i];
if ((i + 1) % 4 == 0) // 4 numbers per row of output
output << endl;
}
if (a.size % 4 != 0) // end last line of output
output << endl;
return output; // enables cout << x << y;
}
#endif

Answer 1

Firstly
If you define a class as a template, you do not need to tell the member functions declaration to be template. Just make them template in the definition and use them in your class template argument if they are defined outside the class. For example,
template <class T> class Test {
void func1(T arg1);
};
template <class T> Test<T>::func1(T arg1) {
// Your definition here
}
Or inside the class,
template <class T> class Test {
void func1(T arg1) {
//Your definition here
}
};
So you need to remove those from your code.
Secondly
Your class has two friend functions. In my opinion, they should also be template functions to work properly with your class. You can see here for a good knowledge in friend function in template classes.
Some good resources to know how to convert regular class to template
Converting regular class to template
I learned from here
Best place for c++ template tutorial
Finally
Although what I understand what you want, there should be added a lot more functionality to the class to work properly, after some modification, here is the code that is compilable and can be used as a starting point to know about your errors.
#ifndef ARRAY_H
#define ARRAY_H
#include <iostream>
#include <iomanip>
#include <stdexcept>
using namespace std;
template <typename GArray>
class Array {
private:
size_t size;
int *ptr;
public:
Array(int arraySize);
~Array();
size_t getSize() const;
const Array& operator=(const Array &right);
bool operator==(const Array &) const;
int operator[](int) const;
friend std::ostream &operator<<(std::ostream &, const Array &);
friend std::istream &operator>>(std::istream &, Array &);
};
template <typename GArray> bool Array<GArray>::operator==(const Array<GArray> &right) const
{
if (size != right.size)
return false; // arrays of different number of elements
for (size_t i = 0; i < size; ++i)
if (ptr[i] != right.ptr[i])
return false; // Array contents are not equal
return true;
}
template <typename GArray> int Array<GArray>::operator[](int subscript) const
{
if (subscript < 0 || subscript >= size)
throw out_of_range("Subscript out of range");
return ptr[subscript];
}
template <typename GArray> istream &operator>>(istream &input, Array<GArray> &a)
{
for (size_t i = 0; i < a.size; ++i)
input >> a.ptr[i];
return input; // enables cin >> x >> y;
}
template <typename GArray> ostream &operator<<(ostream &output, const Array<GArray> &a)
{
// output private ptr-based array
for (size_t i = 0; i < a.size; ++i)
{
output << setw(12) << a.ptr[i];
if ((i + 1) % 4 == 0) // 4 numbers per row of output
output << endl;
}
if (a.size % 4 != 0) // end last line of output
output << endl;
return output; // enables cout << x << y;
}
template<typename GArray>
Array<GArray>::Array(int arraySize)
: size(arraySize > 0 ? arraySize :
throw invalid_argument("Array size must be greater than 0")),
ptr(new int[size]) {
for (size_t i = 0; i < size; ++i)
ptr[i] = 0; // set pointer-based array element
}
template<typename GArray>
Array<GArray>::~Array() {
//This should be like this
for (int i = 0; i < size; ++i) {
delete ptr[i];
}
// delete[] ptr; // release pointer-based array space
}
template <typename GArray>
size_t Array<GArray>::getSize() const {
return size; // number of elements in Array
}
template<typename GArray>
const Array<GArray> &Array<GArray>::operator=(const Array &right) {
if (&right != this) // avoid self-assignment
{
// for Arrays of different sizes, deallocate original
// left-side Array, then allocate new left-side Array
if (size != right.size)
{
delete[] ptr; // release space
size = right.size; // resize this object
ptr = new int[size]; // create space for Array copy
} // end inner if
for (size_t 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
}
#endif