锁定22小时。此问题的评论已被禁用，但仍在接受新的答案和其他交互。Learn more。

程序没有给予我一个错误。只有两个警告，我不明白，当我运行程序时，它说“异常触发”。也许有人可以向我解释错误或警告意味着什么，并确定可能的原因。
这就是矩阵. h

#pragma once
#include <iostream>
using namespace std;

class Matrix
{
    private:
        // Setzen Sie hier die Datenelemente
        // der Klasse ein
        int Zeile, Spalte;
        double** werte;

        
    public:
        Matrix();
        Matrix(int zeilen, int spalten);
        Matrix(const Matrix &m);                  // Copy-Konstruktór
        ~Matrix();

        Matrix operator = (const Matrix &m);    // Zuweisungsoperator

        // Methode setze_element(): setzt wert an angegebener Zeile und Spalte
        // Rückgabe 1 wenn erfolgreich, Rückgabe 0 falls Zeile und Spalte ausserhalb 
        // des gültigen Bereichs liegt
        int setze_element(int zeile, int spalte, double Wert_setzen);
        
        
        // Methode lese_element(): gibt Wert von angegebener Zeile und Spalte zurück.
        // Falls Zeile und Spalte ausserhalb des gültigen Bereichs liegt, dann Rückgabe von 0
        // und erfolg 0.
        // erfolg signalisiert einen gültigen zurückgegebenen Wert mit 1.  
        double lese_element(int zeile, int spalte, int &erfolg) const;
        void print_matrix();

        // Methode gueltig gibt 0 (für ungültig) zurück, wenn das Matrixobjekt durch eine unzulässige 
        // mathematische Operation entstanden ist, bespielsweise durch Addition von Matrizen unterschiedlicher Größe 
        //int gueltig() const;

        // Methoden zeilen() und spalten() geben die jeweilige Anzahl der Zeilen und Spalten zurück
        int zeilen() const;
        int spalten() const;

        // Mathematische Operationen
        Matrix transpos(); 
        Matrix operator +(const Matrix &m) const;
        Matrix operator *(const Matrix &m) const;

        // Vergleichsoperator
        int operator == (const Matrix &m) const;
        friend ostream& operator << (ostream& stream, Matrix& m);

};

Matrix Matrix::transpos()   // r = row = zeile / c = col = Spalte
{
    Matrix MT(Spalte, Zeile);

    for (int r = 0; r < Zeile; r++)
    {
        for (int c = 0; c < Spalte; c++)
        {
            MT.werte[c - 1][r - 1] = werte[r - 1][c - 1];
        }
    }
    cout << endl;

    return MT;
}

Matrix Matrix::operator*(const Matrix& M) const 
{
    Matrix Merg(Zeile, M.Spalte);
    cout << endl;

    if (Spalte != M.Zeile && Zeile != M.Spalte)
    {
        cout << "UNGUELTIG!" << endl;
        cout << endl;
        return Merg;
    }

    for (int r = 0; r < Zeile; r++)
    {
        for (int c = 0; c < M.Spalte; c++)
        {
            for (int i = 0; i < Spalte; i++)
            {
                Merg.werte[r - 1][c - 1] = (werte[r - 1][i - 1] * M.werte[i - 1][c - 1]) + Merg.werte[r - 1][c - 1];
            }
        }
    }

    return Merg;
}

Matrix Matrix::operator+(const Matrix& M) const 
{
    if (Zeile != M.Zeile && Spalte != M.Spalte)
    {
        cout << "UNGUELTIG!" << endl;
        cout << endl;
        return *this;
    }

    for (int r = 0; r < Zeile; r++) 
    {
        for (int c = 0; c < Spalte; c++)
        {
            werte[r - 1][c - 1] = werte[r - 1][c - 1] + M.werte[r - 1][c - 1];
        }
    }
    return *this;
}

Matrix::Matrix(const Matrix& M) //Copy
{
    Spalte = M.Spalte;
    Zeile = M.Zeile;
    werte = M.werte;
}

Matrix Matrix::operator= (const Matrix& M)
{
    Zeile = M.Zeile;
    Spalte = M.Spalte;
    werte = M.werte;
    return *this;
}

int Matrix::operator==(const Matrix& M) const
{
    if (Zeile == M.Zeile && Spalte == M.Spalte)
    {
        for (int r = 0; r < Zeile; r++)
        {
            for (int c = 0; c < Spalte; c++)
            {
                if (werte[r - 1][c - 1] != M.werte[r - 1][c - 1] && (werte[r - 1][c - 1] - M.werte[r - 1][c - 1]) > 1e-10)  //max abw. muss noch mit implementiert werden 
                {
                    return 0;
                }
            }
        }
    }
    if (Zeile != M.Zeile || Spalte != M.Spalte)
    {
        cout << "Die Matritzen sind nicht gleich gross und koennen nicht identisch sein." << endl;
        return 0;
    }

    return 1;
}

Matrix::Matrix()
{
    Zeile = Spalte = 0;
    werte = NULL;       //Null-pointer
}

ostream& operator << (ostream& stream, Matrix& m)
{
    for (int r = 0; r < m.Zeile; r++) {
        for (int c = 0; c < m.Spalte; c++)
        {
            stream << m.werte[r - 1][c - 1] << "\t";        // here is something wrong when i build the vector
        }
        stream << endl;
    }
    return stream;
}

void Matrix::print_matrix()
{
    for (int r = 0; r < Zeile; r++)
    {
        for (int c = 0; c < Spalte; c++)
        {
            cout << werte[r - 1][c - 1] << "\t";
        }
        cout << endl;
    }
}

double Matrix::lese_element(int zeile, int spalte, int& erfolg) const
{
    if (zeile < this->Zeile && spalte < this->Spalte)
    {
        cout << "In der [Zeile / Spalze]: " << "[" << zeile << " / " << spalte << "]" << " befindet sich der Wert: " << werte[zeile - 1][spalte - 1] << endl;
        erfolg = 1;
        return erfolg;
    }
    else
    {
        cout << "Der gesuchte Wert in [Zeile / Spalte]: " << "[" << zeile << " / " << spalte << "]" << " liegt ausserhalb der Matrix." << endl;
        erfolg = 0;
        return erfolg;
    }
}

int Matrix::setze_element(int zeile, int spalte, double Wert_setzen)
{
    this->Zeile;
    this->Spalte;

    if (zeile < this->Zeile && spalte < this->Spalte)
    {
        werte[zeile - 1][spalte - 1] = Wert_setzen;
        return 1;
    }
    else
    {
        cout << "Wert Ausserhalb der Matrix. Abbruch!" << endl;
        return 0;
    }
}

Matrix::~Matrix()
{
    //delete[] werte;
}

int Matrix::spalten()const
{
    return this->Spalte;
}

int Matrix::zeilen() const
{
    return this->Zeile;
}

Matrix::Matrix(int zeilen, int spalten)
{
    this->Spalte = spalten;
    this->Zeile = zeilen;

    werte = new double* [Spalte];
    for (int r = 0; r < Zeile; r++)
    {
        werte[r - 1] = new double[Zeile];
    }

    double init_mit = 0;

    for (int r = 0; r < Zeile; r++)
    {
        for (int c = 0; c < Spalte; c++)
        {
            werte[r - 1][c - 1] = init_mit;
        }
    }
}

这就是int main（）

#include "matrix.h"
#include <iostream>
using namespace std;

void belegen_m1(Matrix &m)
{
    double cmat[5][3] = { { 1.0, 0.0, 0.0 },
                          { 0.0, 2.0, 0.0 },
                          { 0.0, 0.0, 3.0 },
                          { 4.0, 0.0, 0.0 },
                          { 0.0, 5.0, 0.0 }
                        };
    for (int z = 0; z < m.zeilen(); z++)
      for (int s = 0; s < m.spalten(); s++)
        if (m.setze_element(z, s, cmat[z][s]) == 0)
        {
            cout << "Fehler bei belegen_m1(), Abbruch" << endl;
            exit(EXIT_FAILURE);
        }

    
}
void belegen_m2(Matrix &m)
{
    double cmat[3][5] = { { 1.0, 0.0, 0.0, 4.0, 0.0 },
                          { 0.0, 2.0, 0.0, 0.0, 5.0 },
                          { 0.0, 0.0, 3.0, 0.0, 0.0 }
                        };
    for (int z = 0; z < m.zeilen(); z++)
      for (int s = 0; s < m.spalten(); s++)
        if (m.setze_element(z, s, cmat[z][s]) == 0)
        {
          cout << "Fehler bei belegen_m2(), Abbruch" << endl;
          exit(EXIT_FAILURE);
        }
    
}

Matrix erzeuge_quadr_testmatrix(int n)
{
    Matrix test(n, n);
    for (int z = 0; z < test.zeilen(); z++)
      for (int s = 0; s < test.spalten(); s++)
       if (test.setze_element(z, s, z*test.zeilen()+s) == 0)
       {
          cout << "Fehler bei erzeuge_quadr_testmatrix(), Abbruch" << endl;
          exit(EXIT_FAILURE);
       }
    return test;
}

int main()
{
    Matrix m1(5,3), m2(3,5);
    Matrix m3, m4, m5, m6 ,m7;

    belegen_m1(m1);

    belegen_m2(m2);

    cout<<"m1:"<<endl<<m1<<endl;
    cout<<"m2:"<<endl<<m2<<endl;

    m3 = m1.transpos();

    cout<<"m3= m1.transposition():"<<endl<<m3<<endl;

    if (m3.transpos() == m1 )
    {
        cout<<"Zweifache Transposition ergibt wieder die Originalmatrix."<<endl;
    }
    else
    {
        cout << "Nach zweifacher Transposition ergibt sich keine Originalmatrix, Fehler in Methode transposition()" << endl;
        exit(EXIT_FAILURE);
    }

    m3 = m3.transpos();
    cout<<"m3= m3.transpos():"<<endl<<m3<<endl;

    m4 = m1 + m3;

    cout<<"m4 = m1+m3:"<<endl<<m4<<endl;;
    
    m5 = m1 * m2;

    cout<<"m5=m1*m2:"<<endl<<m5<<endl;

    m6 = m2 * m1;

    cout<<"m6=m2*m1:"<<endl<<m6<<endl;

    m7 = m5 * m6;

    cout << "m7=m5*m6:" << endl << m7 << endl;

    Matrix v1(1, 10), v2(10, 1), s;      // here starts the problem in the main()
    for (int i = 0; i < v1.spalten(); i++)
        v1.setze_element(0, i, (double)i);
    for (int i = 0; i < v2.zeilen(); i++)
        v2.setze_element(i, 0, (double)i);
    s = v1*v2;

    cout << "v1: " << v1 << endl;
    cout << "v2: " << endl << v2 << endl;
    cout << "Zeilenvektor v1 * Spaltenvektor v1 ..." << endl;
    cout << s << endl;

    m7 = erzeuge_quadr_testmatrix(4);
    cout << "Ausgabe quadratische Testmatrix:" << endl << m7 << endl;

    return EXIT_SUCCESS;
}

预期输出：

我一步一步地播放程序，有断点，然后它没有挂断，或者总是挂在不同的地方。可能是ostream操作符出了问题。