0

我得到了以下课程：

class Matrix{
    private:
        int rows;
        int columns;
        double* matrix;
    public:
        Matrix();
        explicit Matrix(int N);
        Matrix(int M, int N);
        void setValue(int M, int N, double value);
        double getValue(int M, int N);
        bool isValid() const;
        int getRows();
        int getColumns();
        ~Matrix();
        friend ostream& operator<<(ostream &out, Matrix&matrix1);

        Matrix &operator=(const Matrix &m) {
            if (rows * columns != m.rows * m.columns){
                delete [] this->matrix;
                this->matrix = new double[m.rows * m.columns];
            }
            rows = m.rows;
            columns = m.columns;
            for(int i = 0; i < rows; i++){
                for(int j = 0; j < columns; j++){
                    this->matrix[i * columns + j] = m.matrix[i * columns + j];
                }
            }
            return *this;
        }
        Matrix(const Matrix &rhs);
};

有了这些功能

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

//OPPGAVE 2
Matrix::Matrix(){
    matrix = NULL;
}

Matrix::Matrix(int N){
    matrix = new double[N * N];
    rows = N;
    columns = N;

    for(int i = 0; i < N; i++){
        for(int j = 0; j < N; j++){
            if(i==j)
                matrix[i * N + j] = 1;
            else
                matrix[i * N + j] = 0;
        }
    }
}

Matrix::Matrix(int M, int N){
    matrix = new double[M * N];
    rows = M;
    columns = N;

    for(int i = 0; i < M; i++){
        for(int j = 0; j < N; j++)
            matrix[i * N + j] =  0;
    }
}

Matrix::~Matrix(){
    delete [] matrix;
}

void Matrix::setValue(int M, int N, double value){
    matrix[M * columns + N] = value;
}

double Matrix::getValue(int M, int N){
    return matrix[M * columns + N];
}

bool Matrix::isValid() const{
    if(matrix==NULL)
        return false;
    else
        return true;
}

int Matrix::getRows(){
    return rows;
}

int Matrix::getColumns(){
    return columns;
}

ostream& operator<<(ostream &out, Matrix&matrix1){
    if(matrix1.isValid())
        for(int i = 0; i < matrix1.getRows(); i++){
            for(int j = 0; j < matrix1.getColumns(); j++)
                out << matrix1.getValue(i,j) << "\t";
            out << endl;
        }
    else
        out << "Matrisen er ikke gyldig." << endl;
    return out;
}

Matrix::Matrix(const Matrix &rhs) : rows(rhs.rows), 
    columns(rhs.columns), 
    matrix(new double[rows * columns]) {
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < columns; j++) {
                this->matrix[i * columns + j] = rhs.matrix[i * columns + j];
            }
        }
    }

练习说：

a) 创建一个继承 MxN 矩阵的类 Vector。我们希望将 Vector 类用作具有一些额外功能的 Mx1 维矩阵的接口。

b) 为 Vector 类实现以下构造函数。

•Vector()
默认构造函数，应将底层矩阵初始化为无效状态。

•explicit Vector(unsigned int N)
应构造底层Mx1 矩阵，初始化为零矩阵。（课程大纲中没有明确的关键字，但应该在这里使用。）

•Vector(const Matrix & other);
来自Matrix 的复制构造函数。当且仅当矩阵的维度为 Nx1 时，应将矩阵分配给 *this，否则应将生成的 *this 设置为无效。提示：重用来自 Matrix 类的 operator=。

这是我到目前为止所得到的：

#include "Matrix.h"

class Vector : public Matrix{
    public:
        Vector();
        explicit Vector(int N);
        Vector(const Matrix & other);

};

和

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

Vector::Vector() 
    :Matrix(){ }

Vector::Vector(int N)
    :Matrix(N,1){ }

我应该如何重用 Matrix 中的 operator=？如果我尝试将它从 Matrix 类复制到 Vector 类中，它会说行、列等是不可访问的。我如何访问这些？

是否可以为 Vector 类编写与 Matrix 类的复制构造函数或多或少相同的复制构造函数？它们都是数组，所以我想它应该可以工作吗？

如果我将 Matrix 与 Vector 相乘，是否会自动使用我为 Matrix 重载的运算符（此处未包括），还是我还需要以某种方式将这些包含在 Vector 类中？（它们是在 Matrix.cpp 文件中的 Matrix 类之外编写的。）

接下来我将为 Vector 类编写 set 和 get 函数。是否可以在此表单上编写这些函数？：

void Vector::setValue(int i, double value) {
    Matrix::setValue(i, 1, value);
}

非常感谢帮助和提示！

4

2 回答 2

1

接下来是为了满足一个不称职的教授而做出的可怕的恶作剧。不要在现实世界中这样做。

首先，错误命名的“复制”构造函数。如果我们不担心尺寸，我们可以这样做（不寒而栗）：

Vector(const Matrix & other)
{
  *this = other;
}

但我们必须先检查尺寸。我们可以这样做：

Vector(const Matrix & other)
{
  if(other.getColumns()==1)
      *this = other;
}

但是有些傻瓜忽略了制作getColumns()const，所以这会导致编译器错误。我们可以做一些真正激烈的事情，const cast：

Vector(const Matrix & other)
{
  Matrix *p = const_cast<Matrix *>(&other);
  if(p->getColumns()==1)
      *this = other;
}

或者只是一些可怕的可怕的东西：

Vector(const Matrix & other)
{
  Matrix M(other); // notice that this is not const
  if(M.getColumns()==1)
      *this = other;
}

你需要帮助isValid吗？

于 2013-03-13T16:33:01.843 回答
1

你在正确的轨道上设置和获取。您可以使用类似语法的成员函数调用运算符 Class::operator*(args)。实现向量分配看起来像这样：

Vector & Vector::operator=(const Vector &v){
    Matrix::operator=(v);
    return *this;
}

您将希望将 Vector 构造函数声明为 public。我在想，因为您正在使用继承，编译器将为 Vector 类生成正确的复制构造函数和赋值运算符。你应该编写测试来验证这个假设。

于 2013-03-13T16:34:40.657 回答