La Multiplication de matrice avec la surcharge d'opérateur

Je suis d'essayer de créer une surcharge de l'opérateur pour une matrice de classe que j'ai construit. Mon matrice classe stocke la matrice dans un allouée dynamiquement tableau multidimensionnel. Je suis simplement en train de tester mon opérateur surchargé par la multiplication de deux matrices ensemble que sont exactement les mêmes et afficher le résultat. J'obtiens des résultats bizarres et je crois que ça a à voir avec des conditions sur mes boucles for. J'ai cependant de marcher à travers tous mes boucles for et peut trouver rien de mal. Les matrices je suis multipliant sont à la fois 6x6.

Mon opérateur surchargé

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;
}                 

Maintenant, mon appel à l'opérateur surchargé dans ma fonction principale:

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

Ma sortie:

  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

Comme vous pouvez le voir, il semble que je suis sorti des limites du terrain sur l'un de mes tableaux. Je n'arrive pas à trouver où. Je vous remercie de votre aide à l'avance.

Edit: Comme l'a demandé ma mise en œuvre intégrale de ma classe matrix

Matrice Définitions:

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;

De La Matrice De Mise En Œuvre:

/* Template version of matrix class */
/*---------------------------------------------------------------------------*/
//Default contructor
template <typename T>
matrix<T>::matrix() { }
//Overloaded contructor
template <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 Constructor
template <typename T>
matrix<T>::matrix(const matrix& left)
{
the_matrix = left.the_matrix;
rows = left.rows;
cols = left.cols;
spath = left.spath;
}
//Destructor
template <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 * Operator
template <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 Operator
template <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 << operator
template <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;
}

OriginalL'auteur Nic Young | 2012-02-19