cpp实验三 类与对象II

一、实验任务四

模拟实验任务2，不使用标准库模板类vector，自己动手设计并实现一个动态的整型数组类Vector_int，

使其支持以下要求：

支持在创建int型数组对象时，指定其大小

支持在创建int型数组对象时，指定其大小，并将数组对象中每个数据项初始化到特定的值value

支持用已经存在的int型数组对象x，来构造新的int型数组对象y（要求实现深复制）

提供方法at()能够支持诸如 x.at(i) 这样通过索引访问动态int型数组对象中第i个数据项

析构函数，释放占用的内存资源

在构造和析构函数里，增加打印输出信息。运行程序时，帮助观察资源是否正确释放。

即在测试代码中，支持形如下面的代码操作：

要求：

① 设计并实现动态整型数组类Vector_int，保存在文件vector_int.hpp中

② 编写测试代码文件task4.cpp，测试其构造函数接口、复制构造函数、at()方法等，是否都正常使用，

是否实现了深复制。

分析过后代码如下：

Vector_int.hpp如下：

#include<iostream> 
#include<cassert>
using namespace std;

class Vector_int
{
private:
    int n,x;//n为数组长度，x为默认初始值 
    int *p;//数组 
public:
    Vector_int(int n0):n(n0),x(0)
    {
        p=new int[n];
        for(int i=0;i<n0;i++)
        p[i]=x; 
    };//构造函数
    Vector_int(int n0,int x0):n(n0),x(x0)
    {
        p=new int[n];
        for(int i=0;i<n0;i++)
        p[i]=x;
    };//构造函数
    Vector_int(const Vector_int &y)//复制构造函数 
    {
        n=y.n;
        x=y.x;
        p=new int[n];
        for(int i=0;i<n;i++)
        p[i]=y.p[i];
    } 
    
    void print() const;//输出 
    ~Vector_int()//析构函数
    {
    delete[] p;
    cout<<"destructor called"<<endl;
    } 
    
    int &at(int index);//返回下标为index的数据引用 
    
    
};

void Vector_int::print() const{
    for(int i=0;i<n;i++){
        cout<<p[i]<<"  ";
    }
    cout<<endl;
    
}

int &Vector_int::at(int index)
{
    assert(index >= 0 && index < n);
    return p[index];
 } 

task4.cpp如下：

#include<iostream>
#include"Vector_int.hpp"
using namespace std;
int main()
{
    int n;
    cout<<"请输入数组长度：\n";
    cin>>n;
    Vector_int x0(n); 
    cout<<"x0=";
    x0.print();
    int n1,x;
    cout<<"请输入数组长度和初始值：\n"; 
    cin>>n1>>x;
    Vector_int x1(n1, x);
    cout<<"x1=";
    x1.print();
    Vector_int y(x1);
    cout<<"y=";
    y.print();
    y.at(0) = 999;
    cout<<"y=";
    y.print();
    return 0;
}

运行结果如下：

 

 

二、实验任务五

实现一个动态矩阵类Matrix，类Matrix的声明见文件Matrix.hpp。

① 实现类Matrix的定义

② 使用task5.cpp测试矩阵类Matrix。

经过分析后，Matrix.hpp如下：

#ifndef MATRIX_H
#define MATRIX_H

#include <iostream>
#include <cassert>
using namespace std;
class Matrix
{
public:
    Matrix(int n);                     // 构造函数，构造一个n*n的矩阵
    Matrix(int n, int m);              // 构造函数，构造一个n*m的矩阵
    Matrix(const Matrix &X);           // 复制构造函数，使用已有的矩阵X构造
    ~Matrix() //析构函数
    {
        delete[] p;
        cout<<"destructor called\n";
    }
    void set(const double *pvalue);     // 用pvalue指向的连续内存块数据为矩阵赋值
    void set(int i, int j, int value); //设置矩阵第i行第j列元素值为value
    double &at(int i, int j);          //返回矩阵第i行第j列元素的引用
    double at(int i, int j) const;     // 返回矩阵第i行第j列元素的值
    int get_lines() const;             //返回矩阵行数
    int get_cols() const;              //返回矩列数
    void print() const;                // 按行打印输出矩阵
private:
    int lines; // 矩阵行数
    int cols;  // 矩阵列数
    double *p; // 指向存放矩阵数据的内存块的首地址
};

Matrix::Matrix(int n):lines(n),cols(n)
{
    p=new double[n*n];
}

Matrix::Matrix(int n,int m):lines(n),cols(m)
{
    p=new double[n*m];
}

Matrix::Matrix(const Matrix &X ):lines(X.lines),cols(X.cols)
{
    p=new double[lines*cols];
    for(int i=0;i<lines*cols;i++)
        p[i]=X.p[i];
}

void Matrix::set(const double *pvalue)
{
    for(int i=0; i<lines*cols; i++)
        p[i]=*(pvalue+i);
}

void Matrix::set(int i,int j,int value)
{
    assert((i >= 0 && i < lines) && (j >= 0 && j < cols));
    p[i*cols+j]=value;    
}

double Matrix::at(int i, int j) const {
    assert((i >= 0 && i < lines) && (j >= 0 && j < cols));
    return p[i*cols+j];
}
double & Matrix::at(int i, int j) {
    return p[i*cols+j];
}

int Matrix::get_lines() const {
    return lines;
}
int Matrix::get_cols() const {
    return cols;
}

void Matrix::print() const {
    for(int i=0; i<lines; i++) {
        for(int j=0; j<cols; j++) {
            cout<<p[i*cols+j]<<" ";
        }

        cout<<endl;
    }
}





#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();
}

运行结果如图：

 

 

三、实验结论

1.引用是没有自己的地址的，指针有自己的地址

2.引用作为形参时，例如&x,作为实参时要用x;

   指针作为形参时，例如*x，作为实参要用&x.

3.*pa=a时，&pa是自己的地址，pa是a的地址

   &ra=a时，&ra是a的地址，ra是a的值

4.在类中如果需要一组数组，可以用指针来帮助解决这种问题，例如定义*p，p=new double[]

5.assert是标准c++头文件cassert中定义的一个宏，用来判断一个条件表达式的值是否为true。

如果是false，会终止。

6.引用类型的函数其实现时也要用引用类型，例如double & Matrix::at(int i, int j)

7.自己构造一个容器时，例如vector，有一个数组指针*p，在构造函数中也要初始化它，初始化具体语句为：

 p=new int[n];
        for(int i=0;i<n0;i++)
         p[i]=x;