C++ operator << overloading for a 2D dynamic array allocation

Question

I define the square matrix by a 2D dynamic array with the new operator following:

int n, i{0};
int value;

do {
    cin >> n;
} while ((n <=0) || (n > 20));

int* pMatrix = new int [n*n];
if(pMatrix == NULL) return 1;

do {
    cin >> value;
    *(pMatrix + i) = value;
    i++;
} while (i < (n*n));

Then I have tried to print that array out by operator << overloading, following:

template <typename customizedType, int matrixEdge>
ostream& operator<< (ostream &os, const customizedType* inputMatrix[matrixEdge]) {
    os << "{ ";
    for (int i = 0, matrixSize = matrixEdge*matrixEdge; i < matrixSize; i++) {
        os << *(inputMatrix + i) << ' ';
        if (((i+1) % matrixEdge) == 0 && (i < matrixSize-1)) {os << '}' << endl; os << "{ ";}
    }
    os << '}' << endl;
    return os;
}

Please help me to make it work! I could solved that as the function void printing2DArray(...), but just want to do that with operator << overloading. Thank you.

Why do you use raw C array with manual new instead of std::vector ? It is recommended anyway, and will also make overloading operator<< easier. — wohlstad
– wohlstad, Commented Sep 17, 2024 at 3:58
This is very bad code. Define a class called Matrix and work with it. Don't pepper your code with raw pointers. Your pMatrix is int* not int* [something]. You cannot recover the number of elements from a raw pointer. — n. m. could be an AI
– n. m. could be an AI, Commented Sep 17, 2024 at 4:05
FYI: if(pMatrix == NULL) is useless here since pMatrix can never be null here. Will new operator return NULL? and Why doesn't new in C++ return NULL on failure — Richard
– Richard, Commented Sep 17, 2024 at 4:10
Side notes, learn about rangebased for loops and stop using endl and using namespace std;. I would also expext that you would make a Matrix class and then use ostream& operator<< (ostream &os, const Matrix<customizedType>&. A pointer is NOT a matrix — Pepijn Kramer
– Pepijn Kramer, Commented Sep 17, 2024 at 4:10
In general don't overload operators for types you don't own. Specially not in the global namespace. — Richard
– Richard, Commented Sep 17, 2024 at 4:14

Jerry Coffin · Accepted Answer · 2024-09-18 02:23:10Z

3

You'd normally do this by creating a class to hold your 2-D matrix, then overloading operator<< for instances of that class:

template <class T>
class matrix2d {
    std::vector<T> data;
    std::size_t cols;
    std::size_t rows;
public:
    matrix2d(std::size_t y, std::size_t x) : cols(x), rows(y), data(x*y) {}
    T &operator()(std::size_t y, std::size_t x) { 
        assert(x<=cols);
        assert(y<=rows);
        return data[y*cols+x];
    }
    T operator()(std::size_t y, std::size_t x) const {
        assert(x<=cols);
        assert(y<=rows);
        return data[y*cols+x];
    }

    friend std::ostream &operator<<(std::ostream &os, matrix2d const &m) {
        for (std::size_t y=0; y<m.rows; y++) {
            for (std::size_t x = 0; x<m.cols; x++) {
                os << m(y,x) << "\t";
            }
            os << "\n";
        }
        return os;
    }
};

live on Godbolt

edited Sep 18, 2024 at 2:23

answered Sep 17, 2024 at 5:21

Jerry Coffin

494k83 gold badges656 silver badges1.2k bronze badges

Sign up to request clarification or add additional context in comments.

5 Comments

Pepijn Kramer Over a year ago

T operator()(size_t y, size_t x) const Don't you mean const T& operator()(size_t y, size_t x) const ?

Jerry Coffin Over a year ago

@PepijnKramer: could go either way on that. I'm assuming it's primarily for numerical types that we don't particularly mind copying, so we only use references where needed, but there are certainly cases where you wouldn't want that.

Pepijn Kramer Over a year ago

Ok, I just have tendency to add some SFINAE (or concepts) on my T. So if I assume "cheap to copy" I would constrain T to some concept of "cheap to copy"

Jerry Coffin Over a year ago

@PepijnKramer: In practical use, that's a perfectly reasonable thing to do. But the single responsibility principle applies as much to code in answers as anywhere else. The sole responsibility of this code is to give somebody the general idea of how to overload operator<< for a matrix-like object, not to try to be a complete (or really even partial) replacement for std::valarray, Eigen, etc. Yes, I try to avoid things I think are bad (e.g., raw new and delete), but not at the expense of fulfilling its primary goal.

Pepijn Kramer Over a year ago

@JerryCoffin Fair comments :)

Collectives™ on Stack Overflow

C++ operator << overloading for a 2D dynamic array allocation

1 Answer 1

5 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

5 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related