实验三：类与对象Ⅱ

 

任务四：

vector.hpp:

#include<iostream>
using namespace std;
class Vector_int
{
private:int n, ori; int* p;
public:
      Vector_int(int x, int y=0) :n(x), ori(y) 
      {
           p = new int[x];
          int i;
          for (i = 0; i < n; i++)
              p[i] = ori;
          cout << "create OKK" << endl;
      };
      Vector_int(Vector_int& s):n(s.n),ori(s.ori)
      {
          int i;
          p = new int[n];
          for (i = 0; i < n; i++)
              p[i] = ori;
          cout << "double OKK" << endl;
      };
      ~Vector_int() {  cout << "delete OKK" << endl; };
      int&at(int x)
      {
          return p[x];
      };
      void print()
      {
          int i;
          for (i = 0; i < n; i++)
          {
              cout << p[i] << " ";
          }
          cout << endl;
      };
};

task4.cpp:

#include <iostream>
#include"vector.h"
using namespace std;
int main()
{
    int n;
    cin >> n;
    Vector_int x(n); 
    x.print();

    Vector_int x1(n, 6); 
    x1.print();
    Vector_int y(x1);
    y.print();
    y.at(0) = 999;
    cout << y.at(0);
    y.print();
}

运行结果：

 

任务五：

matrix.hpp:

#ifndef MATRIX_H
#define MATRIX_H

#include <iostream>
#include <cassert>
using namespace std;
class Matrix
{
public:
    Matrix(int n) :lines(n), cols(n){      p = new double [lines*cols];};                     // 构造函数，构造一个n*n的矩阵
    Matrix(int n, int m) :lines(n), cols(m){    p = new double[lines * cols];};              // 构造函数，构造一个n*m的矩阵
    Matrix(const Matrix& X) :lines(X.lines), cols(X.cols)
    { 
        p = new double[lines * cols];
        int i = 0, j = 0;
        for (i = 0; i < lines; i++)
            for (j = 0; j < cols; j++)
            {
                *(p + ((i)*cols + j)) = *(X.p + ((i)*cols + j));

            }
    };           // 复制构造函数，使用已有的矩阵X构造
    ~Matrix() { delete p; };                         //析构函数
    void set(const double* pvalue)
    {
        int i = 0, j = 0;
        for(i=0;i<lines;i++)
            for (j=0; j < cols; j++)
            {
                *(p+((i)*cols+j)) = *(pvalue + ((i)*cols + j));

            }
    };     // 用pvalue指向的连续内存块数据为矩阵赋值
    void set(int i, int j, int value)
    {
        *(p + (i ) * cols + j ) = value;
    }; //设置矩阵第i行第j列元素值为value
    double& at(int i, int j) { return *(p + (i ) * cols + j ); };          //返回矩阵第i行第j列元素的引用
    double at(int i, int j) const { return * (p + (i ) * cols + j ); };     // 返回矩阵第i行第j列元素的值
    int get_lines() const { return lines; };             //返回矩阵行数
    int get_cols() const { return cols; };              //返回矩列数
    void print() const
    {
        int i, j;
        for (i = 0; i < lines; i++)
        {
            for (j = 0; j < cols; j++)
            {
                cout << *(p + ((i ) * cols + j )) << " ";
            }
            cout << endl;
        }
    };                // 按行打印输出矩阵
private:
    int lines; // 矩阵行数
    int cols;  // 矩阵列数
    double* p; // 指向存放矩阵数据的内存块的首地址
};


// 类Matrix的实现：待补足
// ×××

#endif

task5.cpp:

#include <iostream>
#include "matrix.hpp"

int main()
{
    using namespace std;

    double x[] = { 1, 2, 3, 4, 5, 6 };

    Matrix m1(3, 2);    // 创建一个3×2的矩阵
    m1.set(x);          // 用一维数组x的值按行为矩阵m1赋值
    m1.print();         // 打印矩阵m1的值
    cout << "the first line is: " << endl;
    cout << m1.at(0, 0) << " " << m1.at(0, 1) << endl;
    cout << endl;

    Matrix m2(2, 3);
    m2.set(x);
    m2.print();
    cout << "the first line is: " << endl;
    cout << m2.at(0, 0) << " " << m2.at(0, 1) << " " << m2.at(0, 2) << endl;
    cout << endl;

    Matrix m3(m2);
    m3.set(0, 0, 999);
    m3.print();
}

运行结果：

 

总结：

对于实验四，虽然代码很短，但坑却比较多，首先是如果想要对一个函数复制（at），一般这个函数的返回类型是引用（&）。

然后就是这个析构函数了，如果用老师给的cpp代码，编译器会提示对象（x）重定义，于是自然而然的想到析构函数，然而报错却仍然显示着，上网查阅后发现，析构函数与我们所想的（删除）不同，它所进行的是一种扫尾工作，清空数据但不释放空间，所以会导致使用析构函数后得到的是一个空的对象，但仍然存在着，只有超出生存期时才会消失

而想要删除，则建议用new定义对象，用delete删除，而非new定义的，他们并不推荐进行删除，于是就把对象x改成（x1）了。

实验五就是很常规的类的定义，比较特殊的就是对指针成员的定义，值得注意的是做题时要看清老师给的代码，是定义double*p还是int**p。