c – 带运算符重载的矩阵乘法

概述我正在尝试为我构建的矩阵类创建一个重载运算符.我的矩阵类将矩阵存储在动态分配的多维数组中.我只是试图通过将两个完全相同的矩阵相乘并显示输出来测试我的重载运算符.我得到了奇怪的结果,我相信它与我的for循环中的一个条件有关.然而,我已经遍历了所有的for循环,并且没有发现任何错误.我乘以的矩阵都是6×6. 我的重载运算符 template <typename T>const matrix<T> m 我正在尝试为我构建的矩阵类创建一个重载运算符.我的矩阵类将矩阵存储在动态分配的多维数组中.我只是试图通过将两个完全相同的矩阵相乘并显示输出来测试我的重载运算符.我得到了奇怪的结果,我相信它与我的for循环中的一个条件有关.然而,我已经遍历了所有的for循环,并且没有发现任何错误.我乘以的矩阵都是6×6.

我的重载运算符

template <typename T>const matrix<T> matrix<T>::operator * (const matrix& right) const{    matrix<T> c = right;    int sum_elems;    for( int i = 0; i < this->rows - 1; ++i)    {        for(int j = 0; j < right.cols - 1; ++j)        {            sum_elems = 0;            for( int k = 0; k < right.rows - 1; ++k)            {                sum_elems += this->the_matrix[i][k] * right.the_matrix[k][j];            }            c.the_matrix[i][j] = sum_elems;        }    }    return c;}

现在我调用main函数中的重载 *** 作符：

std::cout << my_matrix;matrix<int> copy_matrix;copy_matrix = my_matrix * my_matrix; std::cout << copy_matrix;

我的输出：

The Matrix: 0  1  0  1  1  0 1  0  1  0  1  1 0  1  0  1  0  1 1  0  1  0  1  0 1  1  0  1  0  1 0  1  1  0  1  0   The Matrix: -1  33  139587680  18  38  75 139587680  18  38  75  157  1 139587712  38  1470  4365  10411  1 139587744  75  4365  19058932  64514866  0 139587776  157  10411  64514866  1136204102  1 139596144  1  1  0  1  0

正如你所看到的那样,我似乎走出了我的一个阵列的界限.我似乎无法找到它.我提前感谢您的帮助.

编辑：按要求我完整实现我的矩阵类

矩阵定义：

template <typename T>class matrix{    public:        //Default Constructor        matrix();        //Overloaded Constructor        matrix(std::ifstream&,const char*);        //copy Constructor        matrix(const matrix&);        //Destructor        ~matrix();        //overloaded operators        T* operator [] (T);        const matrix operator * (const matrix&) const;        matrix& operator = (const matrix&);        frIEnd std::ostream& operator << <T> (std::ostream&,const matrix<T>&);     private:        T** the_matrix;        unsigned rows,cols;

矩阵实施：

/* Template version of matrix class *//*---------------------------------------------------------------------------*/// Default contructortemplate <typename T>matrix<T>::matrix() { }// Overloaded contructortemplate <typename T>matrix<T>::matrix( std::ifstream& in,const char* file){    // declare the variables to be used    T vertices,edges,u,v;    std::string line;    // open file for reading    in.open(file);    // get number of vertices    in >> vertices;    // throw away second line       std::getline(in,line);    std::getline(in,line);    // get number of edges and dump them in two arrays    in >> edges;    T edge1 [edges];    T edge2 [edges];    int j = 0,k = 0;    for(int a = 0; a < edges; ++a)    {            in >> u >> v;        edge1[j] = u;        edge2[k] = v;        ++j;        ++k;    }    in.close();    // Create multi-dim-dynamic array    rows = vertices;    cols = vertices;    the_matrix = new T*[rows];    for( int b = 0; b < rows; ++b)    {        the_matrix[b] = new T [rows];    }    // Initialize array values to zero    for ( int c = 0; c < rows; ++c)    {       for( int d = 0; d < cols; ++d)       {           the_matrix[c][d] = 0;       }    }    // push the edges to the matrix    for( int e = 0; e < edges; ++e)    {        the_matrix[edge1[e] - 1][edge2[e] - 1] = 1;    }    for ( int f = 0; f < edges; ++f)    {        the_matrix[edge2[f] - 1][edge1[f]-1] = 1;    }}// copy Constructortemplate <typename T>matrix<T>::matrix(const matrix& left){    the_matrix = left.the_matrix;    rows = left.rows;    cols = left.cols;    spath = left.spath;}// Destructortemplate <typename T>matrix<T>::~matrix(){     // Deletes the data in reverse order of allocation    for( int a = cols; a > 0; --a)    {        delete[ ] the_matrix[a];    }    delete[ ] the_matrix;}// Overloaded * Operatortemplate <typename T>const matrix<T> matrix<T>::operator * (const matrix& right) const{    matrix<T> c = right;    T sum_elems;    for( int i = 0; i < this->rows - 1; ++i)    {        for(int j = 0; j < right.cols - 1; ++j)        {            sum_elems = 0;            for( int k = 0; k < right.rows - 1; ++k)            {                sum_elems += this->the_matrix[i][k] * right.the_matrix[k][j];            }            c.the_matrix[i][j] = sum_elems;        }    }    return c;}// Overloaded assignment Operatortemplate <typename T>matrix<T>& matrix<T>::operator = (const matrix& right){    this->the_matrix= right.the_matrix;    this->rows = right.rows;    this->cols = right.cols;    this->spath = right.spath;    return *this;}// Overloaded << operatortemplate <typename T>std::ostream& operator << (std::ostream& output,const matrix<T>& left){    // Test screen output to see if correct       std::cout << std::setw(14) << "The Matrix:" << '\n';    for( int a = 0; a < left.rows; ++a)    {        for( int b = 0; b < left.cols; ++b)        {            std::cout << ' ' << left.the_matrix[a][b] << ' ';        }        std::cout << '\n';    }    return output;}

解决方法 我怀疑,你的拷贝构造函数和赋值运算符实际上没有正确实现.你只是将指针复制过来.这意味着当您将一个矩阵复制到另一个矩阵时,它们都共享相同的数据.当其中一个超出范围时,将调用析构函数,然后删除共享数据,使剩余的矩阵具有悬空指针.

修复这些功能,以便它们实际分配新数组,并复制数据.

总结

以上是内存溢出为你收集整理的c – 带运算符重载的矩阵乘法全部内容，希望文章能够帮你解决c – 带运算符重载的矩阵乘法所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。