矩陣類的重載運算符*

Question

我有一個矩陣：

#ifndef MATRIX_H
#define MATRIX_H

class Matrix
{   
    public:
        Matrix(int rows, int columns);
        Matrix(int, int, int** matrix); 
        Matrix(Matrix* copy);
        ~Matrix();

        void Set(int, int, int);
        void SetMatrix(int, int, int** matrix);             
        void Print();
        void ZeroMatrix(int,int,int** matrix);      
        void Add(Matrix* B);
        void Subtract(Matrix* B);
        void Copy(Matrix* B);

        int** Multiply(Matrix* B);
        int** Create(int,int);
        int** Get();
        int** Transpose();
        int** Scalar(int);

        int Get(int,int);
        int Rows();
        int Columns();

        Matrix operator*(int);

    private:
        int** _matrix;
        int _rows;
        int _columns;
};

#endif

這是實現：

Matrix Matrix::operator*(int scale)
{
    return Matrix(_rows, _columns, Scalar(scale));
}

對於學校作業，我們必須重載multi運算符以使用整數標量。 問題是我不斷收到此錯誤：

main.cpp：在函數'int main（int，char * ）'中：main.cpp：18：15：錯誤： '4 * B'中的'operator ' 不匹配

破解代碼：

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

int main(int argc, char *argv[])
{   
    Matrix* A = new Matrix(4,2);

    A->Set(0,0,1);  
    A->Set(0,1,2);
    A->Set(1,0,3);
    A->Set(1,1,4);  
    A->Print();

    Matrix B(A);
    B.Print();

    Matrix C(4 * B); //this line
    C.Print();


    delete A;

    return 0;
}

有任何想法嗎？

編輯＃1：

編碼：

Matrix operator*(int); 
        Matrix operator* (int, const Matrix &);

產生：

In file included from main.cpp:1:0:
Matrix.h:31:40: error: ‘Matrix Matrix::operator*(int, const Matrix&)’ must take either zero or one argument
In file included from matrix.cpp:1:0:
Matrix.h:31:40: error: ‘Matrix Matrix::operator*(int, const Matrix&)’ must take either zero or one argument
matrix.cpp:207:50: error: ‘Matrix Matrix::operator*(int, const Matrix&)’ must take either zero or one argument

Answer 1

當指定成員函數時，您的類必須在左側。

B * 4等效於B.operator* (4) 。 當您說4 * B ，這是行不通的。

為了解決這個問題，只需使用B * 4而不是4 * B ，或提供一個外部重載

Matrix operator* (int, const Matrix &);

然后， 4 * B將匹配此過載。

Answer 2

這將在任一方向上起作用...

#include <iostream>

class Matrix
{
public:
  Matrix(int x) // This works as a convert constructor
    : _x(x) { } // if you don't use the explicit keyword

  friend Matrix operator*(const Matrix& left, const Matrix& right);

  int _x;
};

Matrix operator*(const Matrix& left, const Matrix& right)
{
  return Matrix(left._x * right._x);
}

int main()
{
  Matrix m(3);
  int a = 4;

  Matrix m1(m * a);
  Matrix m2(a * m);

  std::cout << m._x  << endl  // 3
            << a     << endl  // 4
            << m1._x << endl  // 12
            << m2._x << endl; // 12
}