调用时 C++ 函数不起作用（OOP/矩阵类）

Question

所以我目前正在写我的学士论文，我需要编写一个类层次结构（使用向量和矩阵类），以便使用求解线性系统的方法。

我为这两个类编写了基本功能，甚至尝试了它们，它们都在工作。但是当我开始向代码中添加更多内容时，我注意到用于向矩阵添加元素并显示它们的函数基本上停止工作，尽管我认为我没有以任何方式修改它们（与我用于矢量类仍然有效）。

在某种程度上，函数可以工作，因为 couts 会显示，但我根本无法输入值。

这是vector类（在你说什么之前，我不想使用模板）：

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

class vector {
protected:
    int n;
    double* vect;

public:
    vector() {
        n = 1;
        vect = new double[n];
        for (int i = 0; i < n; i++) {
            vect[i] = 0;
        }
    }

    vector(int dim) {
        n = dim;
        vect = new double[n];
        for (int i = 0; i < n; i++) {
            vect[i] = 0;
        }
    }

    vector(const vector& v) {
        n = v.n;
        vect = new double[n];
        for (int i = 0; i < n; i++) {
            vect[i] = v.vect[i];
        }
    }

    ~vector() {
        delete[] vect;
    }

    int getsize() {
        return n;
    };

    const vector& operator=(const vector&);
    bool operator== (const vector&) const;
    bool operator!= (const vector&) const;
    void read();
    void display();
    friend ostream& operator<<(ostream&, const vector&);
    friend istream& operator>>(istream&, const vector&);
};

const vector& vector::operator= (const vector& c) {
    if (this == &c)
        return *this;

    if (this != &c) {
        if (n != c.n) {
            delete[] vect;
            n = c.n;
            vect = new double[n];
        }
        for (int i = 0; i < n; i++) {
            vect[i] = c.vect[i];
        }
    }
    return *this;
}

bool vector::operator== (const vector& c) const {
    if (n != c.n)
        return false;
    for (int i = 0; i < n; i++) {
        if (vect[i] != c.vect[i])
            return false;
    }
    return true;
}

bool vector::operator!= (const vector& c) const {
    return !(*this == c);
}

void vector::read() {
    cout << "Insert vector elements:";
    for (int i = 0; i < n; i++) {
        cin >> vect[i];
    }
}

void vector::display() {
    cout << "The vector is: ";
    for (int i = 0; i < n; i++) {
        cout << vect[i];
        cout << " ";
    }
}

ostream& operator<<(ostream& out, const vector& v) {
    for (int i = 0; i < v.n; i++) {
        out << " " << v.vect[i];
    }
    return out;
}

istream& operator>>(istream& in, const vector& v) {
    for (int i = 0; i < v.n; i++) {
        in >> v.vect[i];
    }
    return in;
}

矩阵类是这样的

#include "vector.h"

class matrix {
private:
    int n;
    vector** mat;
public:
    matrix() {
        n = 2;
        mat = new vector * [n];
        for (int i = 0; i < n; i++) {
            mat[i] = new vector[n];
            for (int j = 0; j < n; j++) {
                mat[i][j] = 0;
            }
        }

    }

    matrix(int dim) {
        n = dim;
        mat = new vector * [n];
        for (int i = 0; i < n; i++) {
            mat[i] = new vector[n];
            for (int j = 0; j < n; j++) {
                mat[i][j] = 0;
            }
        }

    }

    matrix(const matrix& m) {
        n = m.n;
        mat = new vector * [n];
        for (int i = 0; i < n; i++) {
            mat[i] = new vector[n];
            for (int j = 0; j < n; j++)
                mat[i][j] = m.mat[i][j];
        }
    }

    ~matrix() {
        for (int i = 0; i < n; i++)
            delete[] mat[i];
        delete[] mat;
    }

    friend ostream& operator<<(ostream&, const matrix&);
    friend istream& operator>>(istream&, const matrix&);
    void read();
    void display();
    const matrix& operator=(const matrix&);

};

const matrix& matrix::operator=(const matrix& m) {
    if (this == &m)
        return *this;

    if (this != &m) {
        for (int i = 0; i < n; i++) {
            delete[] mat[i];
        }
        delete[] mat;
        n = m.n;
        mat = new vector*[n];
        for (int i = 0; i < n; i++) {
            mat[i] = new vector[n];
        }

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                mat[i][j] = m.mat[i][j];
            }
        }
    }
    return *this;
}

ostream& operator<<(ostream& out, const matrix& m) {
    for (int i = 0; i < m.n; i++) {
        out << m.mat[i][0];
        for (int j = 1; j < m.n; j++) {
            out << " " << m.mat[i][j];
        }
        out << endl;
    }
    return out;
}

istream& operator>>(istream& in, const matrix& m) {
    for (int i = 0; i < m.n; i++) {
        for (int j = 0; j < m.n; j++)
            in >> m.mat[i][j];
    }
    return in;
}

void matrix::read() {
    cout << "Insert matrix elements:"<<endl;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++)
            cin >> mat[i][j];
    }
}

void matrix::display() {
    cout << "The matrix is:";
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++)
            cout << mat[i][j];
    }
    cout << endl;
}

这里也是源码

#include "vector.h"
#include "matrix.h"

int main() {
    vector v1(3);
    v1.read();
    v1.display();
    v1.~vector();
    cout << endl;

    matrix m2(2);
    m2.read();
    m2.display();
    m2.~matrix();
    system("pause");
    return 0;
}

编辑：

I added a picture for clarification

编辑 2： @user4581301 指出我不小心做了一个 3D 向量，所以我把 vector** mat 变成了 vector* mat 并在向量类中创建了一个初始化函数来帮助我初始化一个向量的向量。 现在它起作用了！再次感谢！

Answer 1

使用这个构造函数：

    matrix(int dim) {
        n = dim;
        mat = new vector * [n];
        for (int i = 0; i < n; i++) {
            mat[i] = new vector[n];
            for (int j = 0; j < n; j++) {
                mat[i][j] = 0;
            }
        }

    }

mat 是 vector**，所以 mat[i][j] 是 vector。 mat[i][j] = 0; 表示“从0 创建一个向量并将其分配给mat[i][j]”。

构造函数vector(int dim)用于从整数创建向量，所以这里创建零元素向量。

您将希望在 matrix 类中使用 double** mat; 和 new double 而不是 vector** mat; 和 new vector。

如果您出于某种原因真的想将vector 用于矩阵的元素，请给它们正数的元素。例如，可以通过将mat[i][j] = 0; 替换为mat[i][j] = vector(1); 来完成。

还请注意，您不应像 v1.~vector(); 和 m2.~matrix(); 那样显式调用析构函数。当对象的生命结束时会自动调用它们，这将导致双重释放问题（感谢@Frank）。