0

何らかの理由で、次を呼び出すたびに例外が発生しているようです (A、B、C はすべて行列であり、行列の乗算規則が破られていないと仮定します):

c=a*b;

私は何時間も自分のコードをステップ実行してきましたが、私の人生では何が悪いのかを見つけることができません。

テイカーはいますか？allocate() または clear() 関数、またはコピー コンストラクター/代入演算子のいずれかに問題がある可能性があると思います。

前もって感謝します！

// matrix.h
#ifndef matrix_H
#define matrix_H
#include <iostream>
#include <cstdlib>
using namespace std;
template <class mType> class matrix {
public:
    matrix() : N(0), M(0), origin(NULL) { /* EMPTY */ }
    matrix(const matrix<mType> &m) {
        if (origin)
                clear();
        origin = new mType* [m.numrows()];
        for (int i=0; i<m.numrows(); ++i)
            origin[i] = new mType[m.numcols()];

    }
    matrix(int n, int m): N(n), M(m), origin(NULL) {
        allocate(n,m);
    }

    ~matrix() {
        clear();
    }

    matrix & operator=(const matrix &rhs) {

        if (this != &rhs) {     //Check to see they're not the same instance

            this->clear();
            this->allocate(rhs.numrows(), rhs.numcols());
            for(int i=0; i<N; ++i)
                for (int j=0; j<M; ++j)
                    this->origin[i][j] = rhs[i][j];
            }

        return *this;
    }

    matrix & operator+=(const matrix &rhs) {
        try {
            if (    this->numrows() != rhs.numrows() ||
                this->numcols() != rhs.numcols() ) 
                throw 1;
        }
        catch (int e)
        {
            cerr << "Error: The addition of two matrices of different demensions is not defined." << endl;
            return *this;
        }

        for(int i=0; i<N; ++i)
            for (int j=0; j<M; ++j)
                this->origin[i][j] += rhs[i][j];
        return *this;
    }


    const matrix operator+(const matrix &rhs) const {
       matrix tmp = *this;     // tmp copy so we can use the += operator
       return (tmp += rhs);     // return answer
    }

    friend const matrix operator*(const matrix &that, const matrix &rhs) {
        try {
            if (    that.numcols() != rhs.numrows() )
                throw 1;
        }
        catch (int e)
        {
            cerr << "Error: matrix Multiplication not defined." << endl;
            return that;
        }
        matrix<mType> returnmatrix(that.numrows(), rhs.numcols());
        int x=0;
        for (int i=0; i<returnmatrix.numrows(); ++i)
            for (int j=0; j<returnmatrix.numcols(); ++j)
                for (int k=0; k < that.numcols(); ++k){
                    cout << (++x)<<endl;
                    returnmatrix[i][j] += that[i][k] * rhs[k][j];}
        cout << "rt" <<endl;    
        return returnmatrix;

     }


    inline int const numrows() const {
        return N;
    }

    inline int const numcols() const {
        return M;
    }


    void allocate(int n, int m) {
        if (origin)
            clear();
    origin = new mType* [n];
    for (int i=0; i<n; ++i)
        origin[i] = new mType[m];
    M=m;
    N=n;        
}
void clear() {
    if (this->origin) {
        for(int i = 0; i < N; i++)
                delete[] origin[i];
        delete this->origin;
    }

    M=N=0; // Reset

    origin=NULL; 
}



mType* operator [] (const int index)  { return origin[index]; }
const mType* operator [] (const int index) const  { return origin[index]; }



friend matrix<mType> operator*( mType factor, const matrix<mType> rhs ) {
    matrix<mType> out(rhs.numrows() , rhs.numcols());       
        for (int i=0; i<rhs.numrows(); ++i) {
            for (int j=0; j<rhs.numcols(); ++j) {
                out[i][j] = rhs[i][j]*factor;
            }
        }
    return out;
}

friend ostream& operator<< (ostream& out, const matrix<mType>& A) {

    if (A.numrows() > 0 && 0 <  A.numcols()) {
        out <<"[";
        for (int j=0; j<A.numcols(); ++j) {
            out << A[0][j] << " ";
        }
        for (int i=1; i<A.numrows(); ++i) {
            out << endl;
            for (int j=0; j<A.numcols(); ++j) {
                out << " " << A[i][j];
            }
        }
        out << "]" <<endl;

    }
    return out;
}

 friend istream& operator>> (istream& in, matrix<mType> &A)  {
    //[3 2 9 1 2 3 4 5]
    //toss first char
    try {
        if (in.get() != '[')
            throw 1;
        int N, M;
        mType tmp;
        in >> N;
        in >> M;

        A = matrix<mType>(N,M);
        for (int i=0; i<N; ++i)
            for (int j = 0; j < M; j++)
            {   
                in >> tmp;
                A[i][j] = tmp;
            }
        in.get();
            in.ignore();
        }
        catch (int e) {
            cerr << "Invalid Input for matrix" << endl;

        }

        return in;
    }


private: 
    int N, M;
    mType ** origin;


};


#endif

改訂：

// matrix.h
#ifndef matrix_H
#define matrix_H
#include <iostream>
#include <cstdlib>
using namespace std;
template <class mType> class matrix {
public:
matrix() : N(0), M(0), origin(NULL) { /* EMPTY */ }
matrix(const matrix<mType> &m) {

    origin = new mType* [m.numrows()];
    for (int i=0; i<m.numrows(); ++i)
        origin[i] = new mType[m.numcols()];
    for (int i=0; i<N;++i)
        for (int j = 0; j < M; j++)
        {
            origin[i][j] = m[i][j];
        }


}
matrix(int n, int m): N(n), M(m), origin(NULL) {
    allocate(n,m);
    for (int i=0; i<N;++i)
        for (int j = 0; j < M; j++)
        {
            origin[i][j] = 0;
        }
}

~matrix() {
    clear();
}

matrix & operator=(const matrix &rhs) {

    if (this != &rhs) {     //Check to see they're not the same instance

        this->clear();
        this->allocate(rhs.numrows(), rhs.numcols());
        for(int i=0; i<N; ++i)
            for (int j=0; j<M; ++j)
                this->origin[i][j] = rhs[i][j];
        }

    return *this;
}

matrix & operator+=(const matrix &rhs) {
    try {
        if (    this->numrows() != rhs.numrows() ||
            this->numcols() != rhs.numcols() ) 
            throw 1;
    }
    catch (int e)
    {
        cerr << "Error: The addition of two matrices of different demensions is not defined." << endl;
        return *this;
    }

    for(int i=0; i<N; ++i)
        for (int j=0; j<M; ++j)
            this->origin[i][j] += rhs[i][j];
    return *this;
}


const matrix operator+(const matrix &rhs) const {
   matrix tmp = *this;     // tmp copy so we can use the += operator
   return (tmp += rhs);     // return answer
}

friend const matrix operator*(const matrix &that, const matrix &rhs) {
    try {
        if (    that.numcols() != rhs.numrows() )
            throw 1;
    }
    catch (int e)
    {
        cerr << "Error: matrix Multiplication not defined." << endl;
        return that;
    }
    matrix<mType> returnmatrix(that.numrows(), rhs.numcols());
    int x=0;
    for (int i=0; i<returnmatrix.numrows(); ++i)
        for (int j=0; j<returnmatrix.numcols(); ++j)
            for (int k=0; k < that.numcols(); ++k){
                cout << (++x)<<endl;
                returnmatrix[i][j] += that[i][k] * rhs[k][j];}
    cout << "rt" <<endl;    
    return returnmatrix;

 }


inline int const numrows() const {
    return N;
}

inline int const numcols() const {
    return M;
}


void allocate(int n, int m) {
    if (origin)
        clear();
    origin = new mType* [n];
    for (int i=0; i<n; ++i)
        origin[i] = new mType[m];
    M=m;
    N=n;        
}
void clear() {
    if (this->origin) {
        for(int i = 0; i < N; i++)
                delete[] origin[i];
        delete this->origin;
    }

    M=N=0; // Reset

    origin=NULL; 
}



mType* operator [] (const int index)  { return origin[index]; }
const mType* operator [] (const int index) const  { return origin[index]; }



friend matrix<mType> operator*( mType factor, const matrix<mType> rhs ) {
    matrix<mType> out(rhs.numrows() , rhs.numcols());       
        for (int i=0; i<rhs.numrows(); ++i) {
            for (int j=0; j<rhs.numcols(); ++j) {
                out[i][j] = rhs[i][j]*factor;
            }
        }
    return out;
}

friend ostream& operator<< (ostream& out, const matrix<mType>& A) {

    if (A.numrows() > 0 && 0 <  A.numcols()) {
        out <<"[";
        for (int j=0; j<A.numcols(); ++j) {
            out << A[0][j] << " ";
        }
        for (int i=1; i<A.numrows(); ++i) {
            out << endl;
            for (int j=0; j<A.numcols(); ++j) {
                out << " " << A[i][j];
            }
        }
        out << "]" <<endl;

    }
    return out;
}

 friend istream& operator>> (istream& in, matrix<mType> &A)  {
    //[3 2 9 1 2 3 4 5]
    //toss first char
    try {
        if (in.get() != '[')
            throw 1;
        int N, M;
        mType tmp;
        in >> N;
        in >> M;

        A = matrix<mType>(N,M);
        for (int i=0; i<N; ++i)
            for (int j = 0; j < M; j++)
            {   
                in >> tmp;
                A[i][j] = tmp;
            }
        in.get();
        in.ignore();
    }
    catch (int e) {
        cerr << "Invalid Input for matrix" << endl;

    }

    return in;
}


private: 
    int N, M;
    mType ** origin;


};


#endif
4

1 に答える 1

4

非常に多くのコードがありますが、コピー コンストラクターを見たところ、重大な間違いが 2 つあります。

最初の間違い

matrix(const matrix<mType> &m) {
    if (origin)
            clear();

origin はこの時点で初期化されていないため、その値をテストすることはできません。この2行を削除するだけです。コンストラクターが新しいオブジェクトを初期化することを思い出してください。コンストラクターが既に存在するオブジェクトをテストしている場合は間違っています。

二度目の間違い

コピー コンストラクターは何もコピーしません。正しいサイズの行列を作成しますが、行列の値はコピーしません!

最初のエラーがクラッシュの原因だと思います.2番目のエラーは、ガベージ結果が得られることを意味します.

于 2012-09-12T20:45:37.280 に答える