C++ C++；派生类中的运算符重载_C++_Templates

C++ C++；派生类中的运算符重载

c++ templates

C++ C++；派生类中的运算符重载,c++,templates,C++,Templates,我有一个模板类matrix，我试图覆盖不同矩阵的+操作。我想重写派生类中的运算符，但有一些错误。换句话说，我只想对矩阵的两个定义对象执行A+B，而不想对循环执行。代码如下： #include<iostream> using namespace std; template<class T> class matrix { protected: T **tab; int row,col; public: matrix(int row,

我有一个模板类

matrix

，我试图覆盖不同矩阵的

操作。我想重写派生类中的运算符，但有一些错误。换句话说，我只想对矩阵的两个定义对象执行

A+B

，而不想对循环执行

。
代码如下：
#include<iostream>

using namespace std;
template<class T>
class matrix
{
    protected:
    T **tab;
    int row,col;
    public:
    matrix(int row,int col)
    {
        this->row = row;
        this->col = col;
        tab = new T* [col];
        for(int i = 0; i < col; i++)
        tab[i] = new T[row];
        tab[0][0] = 100;
    }
    T& operator()(int i,int j) 
    {
        return tab[i][j];
    }

    T operator()(int i,int j)const 
    {
        return tab[i][j];
    }
    void operator=(const matrix& that)
    {
        for(int i = 0; i < col ; i++)
            for(int j = 0; j < row ; j++)
            tab[i][j] = that.tab[i][j];
    }

    matrix(const T& tab)
    {
        row = tab.row;
        col = tab.col;
        tab = new T* [col];
        for(int i = 0; i < col; i++)
        tab[i] = new T[row];
    }
    ~matrix()
    {
        for(int i = 0; i < col; i++)
        delete tab[i];
        delete tab;
    }
};
template<class T>
class Operations: public matrix<T>
{
    T& operator+(matrix& tab1,matrix& tab2)
    {

        int i,j;
        ligne = tab.ligne;
        col = tab.col;
        tab3 = new T* [col];
        for(int i = 0; i < col; i++)
        tab3[i] = new T[ligne];

        for(i  = 0; i < col; i++)
            for(j = 0; j < ligne; j++)
            tab3[i][j] = tab1[i][j]+tab2[i][j];
        return tab3;
    }
};
int main()
{
    matrix<int> tab1(10,10);
    matrix<int> tab2(5,5);
    cout<<tab1(0,0)<<endl;
    tab1(0,0) = 10;
    cout<<tab2(0,0)<<endl;
    tab2(0,0) = 5;
    tab2 = tab1;

    tab1(0,0) = 3;
    return 0;
}

你能给我解释一下这些错误的原因和改正方法吗？
多谢各位
编辑
我想在矩阵
中将+运算符作为成员类函数实现，但我收到了一条错误消息：您能告诉我定义运算符+的方式出了什么问题吗
matrix operator+(const matrix& that)const 
    {

        int i,j;
        T** tab3;
        tab3 = new T* [col];
        for(int i = 0; i < col; i++)
        tab3[i] = new T[row];

        for(i  = 0; i < col; i++)
            for(j = 0; j < row; j++)
            tab3[i][j] = that.tab[i][j]+tab[i][j];
        return tab3;
    }

矩阵运算符+（常数矩阵&that）常数
{
int i，j；
T**tab3；
tab3=新的T*[col]；
for（int i=0；i
我认为您应该为矩阵
类重载+运算符
matrix& operator+(matrix& other){
   ....
}

您可以像这样使用它：
matrix<type> a;
// initialise a
matrix<type> b;
// initialise b
matrix<type> c = a+b; // a+b <=> a.operator+(b);

矩阵a；
//草签
矩阵b；
//初始化b
矩阵c=a+b；//a+b a.操作员+（b）；
我认为您应该为矩阵
类重载+运算符
matrix& operator+(matrix& other){
   ....
}

您可以像这样使用它：
matrix<type> a;
// initialise a
matrix<type> b;
// initialise b
matrix<type> c = a+b; // a+b <=> a.operator+(b);

矩阵a；
//草签
矩阵b；
//初始化b
矩阵c=a+b；//a+b a.操作员+（b）；
运算符+（）
通常应该是它所作用的类的成员（并接受一个参数），或者是接受两个参数的非成员
比如,
class matrix
{
    public:

        matrix operator+(const matrix &) const;   // member version
};

或
注意，如果矩阵提供了操作符+（）
所需的公共成员函数，则友谊在第二种情况下是可选的
这两种方法不能混用。如果编译器遇到一个同时具有两种形式的运算符+（）
的类，它没有理由选择调用其中一种而不是另一种，并且会由于歧义而拒绝类似c=a+b
的代码
另一个类（如您的操作
）也不可能提供接受两个类型为矩阵
的参数的非静态成员函数运算符+（）
。您得到的关于“非函数”的错误消息是指该函数（尽管编译器供应商对错误消息使用了相当隐晦的措辞）
还要注意，operator+（）
通常应该按值返回，而不是返回引用。返回引用通常会导致像c=a+b
这样的表达式的工作方式与预期不同，并且（取决于返回的引用）可能会导致调用方表现出未定义的行为。
运算符+（）
通常被预期为其所作用的类的成员（并接受一个参数）或者是接受两个参数的非成员
比如,
class matrix
{
    public:

        matrix operator+(const matrix &) const;   // member version
};

或
注意，如果矩阵提供了操作符+（）
所需的公共成员函数，则友谊在第二种情况下是可选的
这两种方法不能混用。如果编译器遇到一个同时具有两种形式的运算符+（）
的类，它没有理由选择调用其中一种而不是另一种，并且会由于歧义而拒绝类似c=a+b
的代码
另一个类（如您的操作
）也不可能提供接受两个类型为矩阵
的参数的非静态成员函数运算符+（）
。您得到的关于“非函数”的错误消息是指该函数（尽管编译器供应商对错误消息使用了相当隐晦的措辞）
还要注意，operator+（）
通常应该按值返回，而不是返回引用。返回引用通常会导致像c=a+b
这样的表达式的工作方式与预期不同，并且（取决于返回的引用）可能会导致调用方表现出未定义的行为。
请给出一个简单的示例。这不是运算符重载的工作方式。有关一些示例，请参见此处：为什么要使操作
继承自矩阵
？这太疯狂了！我想训练自己从模板类继承。你在训练一个错误的示例。请给出一个最小的示例。运算符重载不是这样工作的。有关一些示例，请参见此处：为什么要使操作
继承自矩阵
？这太疯狂了！我想训练自己从模板类继承。你在训练一个错误的例子。你想错了operator+（）
不应返回引用，因为它使类似a=a+b
的表达式的行为与调用方可能假设的行为不同。您认为错误operator+（）
不应返回引用，因为它使类似a=a+b
的表达式的行为与调用方可能假设的行为不同。您没有提供任何信息来证明其中一个的正确性，因此这两个表达式都可以。只是不能同时两者。您还需要一个工作赋值运算符、复制构造函数等。谢谢，我刚刚理解了您所说的运算符只能有一个定义的意思。我选择实现成员类函数，但遇到了一个错误。代码在问题的编辑中。你能告诉我在定义成员类操作符的方法上哪里出错了吗？你的操作符+（）
需要返回矩阵的一个实例，而不是指向T
的指针。你没有给出任何信息证明其中一个是正确的，所以这两个都可以。只是不能同时两者。您还需要一个工作赋值运算符、复制构造函数等。谢谢，我刚刚理解了您所说的只有一个定义是什么意思