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。

C ++增量运算符重载为好友功能不起作用？

1 个答案: