Home / Questions / 283131
Accepted
k1k4ss0
Asked: 2020-08-02 08:01:35 +0800 CST 2020-08-02 08:01:35 +0800 CST

为什么我会收到错误“类型的无效操作数和二进制 'operator*'”？

  • 772

我正在用 C++ 编写一个程序，其中我必须将两个矩阵相乘，但是当我创建该方法operator*并对其进行测试（为空）时，它给了我标题中的错误：

main.cpp:28:20: error: invalid operands of types ‘matrix<float>*’ and ‘matrix<float>*’ to binary ‘operator*’
matrix<float>* b=a*a;
                 ~^~

我主要有以下几点：

#include <iostream>
#include <exception>
using namespace std;
#include "excepciones.hpp"
#include "matrix.cpp"


int main (){

    matrix<float>* a;
    int x=0, y=0;
    cout<<"introduzca el numero de filas de la matriz:"<<endl;
    cin>> x;
    cout<<"introduzca el numero de columnas de la matriz:"<<endl;
    cin>>y;

    try{

        a=new matrix<float> (x,y);
    }

    catch(exception& e){

        cout<<e.what()<<endl;
    }
    matrix<float>* b=a*a;


}

operator* 方法如下：

template <class T>
matrix<T>* matrix<T>::operator*(matrix<T>* a){

    return NULL;

}

在 hpp 中定义如下：

matrix<T>* operator*(matrix<T>* a);

它不应该工作，因为要相乘的对象的类型是在方法中指定的，（很好），现在它返回NULL，这是指针b可以毫无问题地接受的值

c++

2 Answers

  1. Best Answer

    错误简洁明了，你可能看不懂，因为是英文的，我给你翻译一下：

    error: invalid operands of types ‘matrix<float>*’ and ‘matrix<float>*’ to binary ‘operator*’
matrix<float>* b=a*a;
                 ~^~


    error: los operandos de tipos ‘matrix<float>*’ y ‘matrix<float>*’ no son válidos para el operador binario ‘operator*’
matrix<float>* b=a*a;
                 ~^~

    编译器将表达式标记b=a*a为错误源，涉及的变量类型是什么？

    该变量a已被定义为指向以 type 实例化*的模板的指针 () ：matrixfloat

       matrix<float>* a;
// ~~~^~~ ~~^~~ ^
//     \     \   \____ puntero
//      \     \_______ float
//       \____________ plantilla 'matrix'

    该变量b已被定义为指向以 type 实例化*的模板的指针 () ：matrixfloat

       matrix<float>* b=a*a;
// ~~~^~~ ~~^~~ ^
//     \     \   \____ puntero
//      \     \_______ float
//       \____________ plantilla 'matrix'

    现在让我们看看你的乘法运算符是如何定义的：

    template <class T>
matrix<T>* matrix<T>::operator*(matrix<T>* a){
//                              ~~~^~~ ^ ^
//                                  \   \ \____ puntero
//                                   \   \_____ Tipo genérico a deducir
//                                    \________ Plantilla 'matrix'    
    return NULL;

}

    乘法运算符被定义为一个成员函数，它接收指向用 type 实例化*的模板的指针参数 () 。由于它是一个成员函数，因此在（乘法）运算符的左侧必须始终有一个实例，但您没有实例，您有指针！：matrixTmatrixmatrix

       b=a*a
//   ^ ^
//    \ \___ puntero a 'matrix<float>' ---> matrix<float>*
//     \____ puntero a 'matrix<float>' ---> matrix<float>*

    如果您取消引用左操作数指针，它将对您有用：

       b=(*a)*a
//    ^~ ^
//     \   \___ puntero a 'matrix<float>' ---> matrix<float>*
//      \______ des-referencia matrix<float>* para obtener 'matrix<float>'

    但这是胡说八道，设计完全不够：

    • 指针用于管理内存，它们不应用于算术运算对象，因此：
      • 算术运算符永远不应接收指针作为参数。
      • 算术运算符永远不应返回指针。
    • 除非算术运算符也相等（例如*=），否则函数应该是常量或应该在操作类之外。

    考虑到前面的几点，您的运营商应该是这样的：

    // La función no modifica el estado de la instancia ___
   template <class T> //                               \
//                                                      |
// vvvvvvvvv <--- Devuelve una instancia              vvvvv
   matrix<T> matrix<T>::operator*(const matrix<T>& a) const {
//                                ~~^~~          ^
//                                  |            |
//                 El objeto entrante es una referencia de sólo lectura.
}

    甚至更好，像这样：

    template <class T>
class matrix {

    template <class U>
    friend matrix<U> operator*(const matrix<U> &, const matrix<U> &);
};

template <class T>
matrix<T> operator*(const matrix<T> &a, const matrix<T> &b) {
    …
}

    使用任一选项，您的函数main应如下所示：

    int main (){

    int x=0, y=0;
    cout<<"introduzca el numero de filas de la matriz:"<<endl;
    cin>> x;
    cout<<"introduzca el numero de columnas de la matriz:"<<endl;
    cin>>y;

    // Instancia, no puntero.
    matrix<float> a{x,y};
    // Instancia, no puntero.
    matrix<float> b=a*a;

    return 0;
}
    • 3

  2. 编译器会抛出错误，因为产品的第一个元素不能是指针。换句话说，运算符重载是针对类型对象完成的，matrix<T>而不是针对matrix<T>.

    以下示例应修复错误：

    // opcion 1: en crudo
matrix<float> * b = *a*a;

// opcion 2: con paréntesis
matrix<float> * b = (*a)*a;

// opcion 3: llamada explícita a la función
matrix<float> * b = a->operator*(a);

// opción 4: desreferenciando el puntero
matrix<float> * b = (*a).operator*(a);
    • 2