Перегрузка оператора приращения C ++, поскольку функция друга не работает?

Question

Я просто предвосхищу это тем фактом, что я новичок в C ++, так что вполне возможно, что здесь просто глупая ошибка, но я не могу ее найти.

Я просто пытаюсь перегрузить оператор приращения в функции друга. Все отлично компилируется и все работает, если я явно вызываю перегрузку постфиксного приращения:

operator++(*test, 0);

Каждый элемент в матрице увеличивается, и программа выводит его, используя cout. Проблема в том, что когда я пытаюсь сделать обычный инкремент ++ test++;, создается впечатление, что что-то не так происходит с указателем теста, на котором, когда он пытается напечатать тестовый объект, он ничего не печатает.

Есть идеи, что происходит? Я невежественен. Вот код, с которым я работаю ...

Компиляция и запуск

g++ -o App App.cpp Matrix.cpp
./App

App.cpp

#include <iostream>
#include "Matrix.h"

using namespace std;

#define X 9

int main(int argc, char *argv[])
{
    // Start the actual program here
    Matrix* test = new Matrix(3,3);
    // Row 1
    test->setElement(0,0,1);
    test->setElement(0,1,2);
    test->setElement(0,2,3);
    // Row 2
    test->setElement(1,0,4);
    test->setElement(1,1,5);
    test->setElement(1,2,6);
    // Row 3
    test->setElement(2,0,7);
    test->setElement(2,1,8);
    test->setElement(2,2,9);

    operator++(*test, 0);
    //test++;
    //++test;

    // Print the Matrix object
    cout << *test << endl;
}

Matrix.h

#ifndef MATRIX_H
#define MATRIX_H

#include <iostream>
using namespace std;

class Matrix {
    friend ostream& operator<<(ostream&, const Matrix&);
    friend Matrix& operator++(Matrix&);        // prefix increment
    friend Matrix& operator++(Matrix&, int);   // postfix increment
    private:
        int rows;
        int cols;
        int** elements;
    public:
        // Constructors
        Matrix(int);
        Matrix(int,int);
        Matrix(const Matrix&);
        // Define setters
        void setElement(int,int,int);
        // Define getters
        int getRowCount();
        int getColCount();
        int getElementAt(int,int);
        void increment();
        // Destructor
        ~Matrix();
};

#endif

Matrix.cpp

#include <iostream>
#include "Matrix.h"

using namespace std;

//===================================
//    DEFINE [CON]/[DE]STRUCTORS
//===================================
// Constructor for creating square matricies
Matrix::Matrix(int _size) {
    rows = _size;
    cols = _size;
    elements = new int*[_size];
    for (int i = 0; i < _size; i++) {
        elements[i] = new int[_size];
    }
}

// Constructor for supporting non-square matricies
Matrix::Matrix(int _rows, int _cols) {
    rows = _rows;
    cols = _cols;
    elements = new int*[_rows];
    for (int i = 0; i < _rows; i++) {
        elements[i] = new int[_cols];
    }
}

// Copy constructor
Matrix::Matrix(const Matrix& mat1) {
    Matrix(mat1.rows, mat1.cols);

    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            elements[i][j] = mat1.elements[i][j];
        }
    }
}

// Destructor
Matrix::~Matrix() {
    for (int i = 0; i < rows; i++) {
        delete[] elements[i];
    }
    delete[] elements;
}

//===================================
//     DEFINE SETTER FUNCTIONS
//===================================
void Matrix::setElement(int row, int col, int newElement) {
    if (row > rows-1 || row < 0)
        throw "Row out of index";
    if (col > cols-1 || col < 0)
        throw "Column out of index";

    elements[row][col] = newElement;
}

//===================================
//     DEFINE GETTER FUNCTIONS
//===================================
int Matrix::getRowCount() { return rows; }

int Matrix::getColCount() { return cols; }

int Matrix::getElementAt(int row, int col) {
    if (row > rows-1 || row < 0)
        throw "Row out of index";
    if (col > cols-1 || col < 0)
        throw "Column out of index";

    return elements[row][col];
}

//===================================
//    OVERRIDE OPERATOR FUNCTIONS
//===================================
// Print the Matrix to the output stream
ostream& operator<<(ostream& out, const Matrix& mat) {
    for (int i = 0; i < mat.rows; i++) {
        for (int j = 0; j < mat.cols; j++) {
            out << mat.elements[i][j] << " ";
        }
        out << endl;
    }

    return out;
}

// Prefix. Increment immediately and return the object.
Matrix& operator++(Matrix& mat) {
    cout << "Prefix ++ operator" << endl;
    // Increment all elements in the object by 1
    for (int i = 0; i < mat.rows; i++) {
        for (int j = 0; j < mat.cols; j++) {
            mat.elements[i][j] += 1;
        }
    }
    return mat;
}

// Postfix. Return the current object and "save" the incremented.
Matrix& operator++(Matrix& mat, int x) {
    cout << "Postfix ++ operator" << endl;
    // Save the current values
    Matrix* curVals = new Matrix(mat);
    // Increment the object
    ++(mat);
    // Return the unincremented values
    return *curVals;
}

Answer 1

test++ увеличивает значение test, чтобы оно указывало на память после вашего объекта Matrix. Вам нужно разыменовать указатель, чтобы получить объект Matrix, а затем применить к нему приращение.

То, что вы хотите, это (*test)++ или ++*test.