Tricky dynamic objects and pointers - c++

Question

I am having a problem understanding what is wrong with the way I set up my pointers.
I am trying to do something along the following:
matrix[0] = new Array<T>(columnSize);
But it doesn't compile. I think the problem is that matrix[0] returns a reference, and assigning new Array(columnSize) to it isn't legal?
Here's the error
/Users/Ezequiel/desktop/wow/Matrix.h: In constructor ‘Matrix<T>::Matrix(size_t, size_t) [with T = int]’:
main.cpp:8: instantiated from here
/Users/Ezequiel/desktop/wow/Matrix.h:18: error: invalid conversion from ‘Array<int>*’ to ‘long unsigned int’
/Users/Ezequiel/desktop/wow/Matrix.h:18: error: initializing argument 1 of ‘Array<T>::Array(size_t) [with T = Array<int>*]’
I attached all of my code below.
// Array.h
#ifndef ARRAY_H
#define ARRAY_H
#include <string>
#include <iostream>
#include <algorithm>
template<class T>
class Array {
private:
T* elements;
size_t low, high;
void init(const size_t, const size_t);
void copy(const Array<T>&);
public:
size_t size;
Array();
~Array();
Array(const size_t);
Array(const size_t, const size_t);
Array(const Array<T>&);
T& operator[](const size_t);
Array<T>& operator=(const Array<T>&);
template<class X>
friend std::ostream& operator<<(std::ostream&, const Array<X>&);
};
template<class T>
void Array<T>::init(const size_t low, const size_t high) {
if (high < low || (high - low + 1 <= 0)) {
std::cout << "An error was found in the bounds passed to the constructor.\n";
exit(1);
}
size = high - low + 1;
elements = new T[size];
this->low = low;
this->high = high;
}
template<class T>
void Array<T>::copy(const Array<T>& someArray) {
delete[] elements;
if (someArray.size) {
elements = new T[someArray.size];
std::copy(someArray.elements, someArray.elements + someArray.size, elements);
low = someArray.low;
high = someArray.high;
size = someArray.size;
} else {
size = 0;
elements = 0;
low = high = -1;
}
}
template<class T>
Array<T>::Array() {
size = 0;
elements = 0;
low = high = -1;
}
template<class T>
Array<T>::Array(const size_t size) {
init(0, size - 1);
}
template<class T>
Array<T>::Array(const size_t low, const size_t high) {
init(low, high);
}
template<class T>
Array<T>::~Array() {
delete[] elements;
}
template<class T>
Array<T>::Array(const Array<T>& someArray) {
copy(someArray);
}
template<class T>
Array<T>& Array<T>::operator=(const Array& someArray) {
if (this == &someArray) {
return *this;
}
copy(someArray);
return *this;
}
template<class T>
T& Array<T>::operator[](const size_t index) {
if (index < low || index > high || size <= 0) {
std::cout << "The index " << index << " goes out of bounds.\n";
exit(1);
}
return elements[index - low];
}
template<class X>
std::ostream& operator<<(std::ostream& os, const Array<X>& someArray) {
if (someArray.elements) {
for (size_t i = 0; i < someArray.size - 1; ++i) {
os << someArray.elements[i] << ", ";
}
os << someArray.elements[someArray.size - 1];
} else {
os << 0;
}
}
#endif
// Matrix.h
#include "Array.h"
template<class T>
class Matrix {
private:
Array< Array<T>* > *matrix;
size_t rowSize, columnSize;
public:
Matrix(const size_t rowSize, const size_t columnSize);
};
template<class T>
Matrix<T>::Matrix(const size_t rowSize, const size_t columnSize) {
matrix = new Array< Array<T>* >(rowSize);
// Compiles perfectly fine, except after I uncomment this line:
// matrix[0] = new Array<T>(columnSize);
this->rowSize = rowSize;
this->columnSize = columnSize;
}

Answer 1

matrix isn't an Array<Array<T>*>. It's an Array<Array<T>*>* -- a pointer to an Array<Array<T>*>. This means that matrix[0] (better written as *matrix; see below) is of type Array<Array<T>*>.
You are allocating matrix via new rather than new[]. Only one object is being allocated. You can use matrix[0] to refer to this single object, but since you are allocating with new, it's better to use the dereference operator. Using matrix[0] might lead you or a reader of your code to think there might be a matrix[1]. There isn't.
The way to fix that commented-out statement is to use
(*matrix)[0] = new Array<T>(columnSize);
and if you are allocating in a loop,
(*matrix)[idx] = new Array<T>(columnSize);
Note that referencing the i,j element of the matrix is done via (*matrix)[i][j].
If you insist on using matrix[0] you will need to use
matrix[0][idx] = new Array<T>(columnSize);
to allocate and matrix[0][i][j] to reference the i,j element of the matrix.