Summation of 2D arrays using templates C++

You have a few issues, for one the constructor of sum takes pointers to Left and Right but when used, pointers are not being passed.

I think the problem becomes simpler to look at if the internal classes are broken out;

#include<iostream>

using namespace std;

/* represents a one-dimensional array */
template<typename T> class row {
private:
    T* data;
    size_t n;
public:
    row(T* data, size_t n)
        : data(data), n(n) {
    }

    T operator[](int i) {
        return data[i];
    }
};

/* represents a two-dimensional array */
template<typename T> class array {
private:
    T** data;
    size_t n, m;
public:
    array(T** data, size_t n, size_t m)
        : data(data), n(n), m(m) {
    }

    row<T> operator[](int i) {
        return row<T>(data[i], m);
    }
};

/* represents a two rows from two arrays, observable as a single summed row */
template<typename T> class sum_row_proxy {
private:
    row<T> left;
    row<T> right;
public:
    sum_row_proxy(row<T> left, row<T> right)
        : left(left), right(right) {
    }

    T operator[](int i) {
        return left[i] + right[i];
    }
};

template<typename T> class sum {
private:
    array<T> left;
    array<T> right;
public:
    sum(const array<T>& left, const array<T>& right)
        : left(left), right(right) {
    }

    sum_row_proxy<T> operator[](int i) {
        return sum_row_proxy<T>(left[i], right[i]);
    }
};

int main() {
    double **test = new double*[5];
    for(int i = 0; i < 5; ++i) {
        test[i] = new double[4];
        for(int j = 0; j < 4; ++j) {
            test[i][j] = 1.0;
        }
    }

    array<double> array_a(test, 5, 4);
    array<double> array_b(test, 5, 4);

    sum<double> s(array_a, array_b);

    for(int i=0; i<5; ++i){
        cout<<"\n";
        for(int j=0; j<4; ++j){
            cout<<s[i][j]<<" ";
        }
    }

    return 0;
}

I've tried to use (roughly) the same classes you used, but this problem can also be solved by a single class (plus a proxy class for the second indexer) taking two T** as input.

Hope this helps,
Fredrik

I would not declare a template class, but a template function. And would design the function with three arguments for: left operand, right operand, and result. If you don't use a result argument, you will have to pass the result as the return value of your function. That, however, is not what you want. If the return value would also be a pointer to an array, the function would have to allocate that array. And the calling code would have to free the array.

So: I would go for something like:

template<typename t="">
void sum2D (T* pLeft, T* pRight, T* pSum, int cols, int rows)
{
   int n = cols * rows;
   for (int i = 0; i < n; ++i)
      pSum[i] = pLeft[i] + pRight[i};
};
</typename>

Note that now the caller has to allocate the space for the result array.