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.