实验三

实验任务4

vector_int.hpp

#ifndef VECTOR_INT_HPP
#define VECTOR_INT_HPP
#include<iostream>
using namespace std;
class vector_int
{
public:
        vector_int(int n);
        vector_int(int n,int m);
        vector_int(const vector_int &obj);
        ~vector_int();
        int &at(int x);  
private:
        int *data;
        int size;    
};
//只指定其大小的构造函数
vector_int::vector_int(int n):size(n)
{
    data=new int[n];
    cout<<"The array has been created."<<endl;
    for(auto i=0;i<n;i++)
        data[i]=0;    
} 
//指定其大小和默认值的构造函数
vector_int::vector_int(int n,int m):size(n)
{
    data=new int[n];
    cout<<"The array has been created and every data item in it has been initialized as "<<endl;
    for(auto i=0;i<n;i++)
        data[i]=m;    
} 
//复制构造函数
vector_int::vector_int(const vector_int &obj):size(obj.size)
{
    cout<<"Copy constructor called." <<endl;
    data=new int[obj.size];
    for(auto i=0;i<obj.size;i++)
        data[i]=obj.data[i]; 
} 
//析构函数
vector_int::~vector_int()
{
    cout<<"Destructor called"<<endl;
    delete[] data; 
} 
//at索引函数
int& vector_int::at(int x)
{
    if(x>=0&&x<size)
        return data[x];
}
#endif

task4.cpp

#include <vector_int.hpp>
#include <iostream>
using namespace std;

int main() {
    Vector_int arr1(8);
    Vector_int arr2(10, 7);
    Vector_int arr3(arr1);
    arr2.at(6) = 4;

    cout << "arr1:" << endl;
    arr1.print();
    cout << "arr2:" << endl;
    arr2.print();
    cout << "arr3:" << endl;
    arr3.print();

    return 0;
}

 实验任务5

matrix.hpp

#ifndef MATRIX_H
#define MATRIX_H

#include <iostream>
#include <cassert>

class Matrix
{
    public:
        Matrix(int n);                     // 构造函数，构造一个n*n的矩阵
        Matrix(int n, int m);              // 构造函数，构造一个n*m的矩阵
        Matrix(const Matrix &X);           // 复制构造函数，使用已有的矩阵X构造
        ~Matrix();                         //析构函数
        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(X.lines*X.cols);
    for(int i=0;i<X.lines*X.cols;i++)
    p[i]=X.p[i];    
}

//析构函数
Matrix::~Matrix()
{
    delete[] p;
}

//矩阵赋值函数 
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)
{
     p[i*cols+j]=value;    
}

//返回引用函数 
double &Matrix::at(int i,int j)
{
    assert(i>=0&&j>=0&&i*cols+j<=lines*cols);
    return p[i*cols+j];
}

//返回值函数
double Matrix::at(int i,int j) const
{
    assert(i>=0&&j>=0&&i*cols+j<=lines*cols);
    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*cols;i++)
    {
        std::cout << p[i] <<"," ;
        if((i+1)%cols==0)
        std::cout << " 
" ;
    }
}

#endif

task5.cpp

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

int main()
{
    using namespace std;

    double x[] = {1, 3, 5, 7, 9, 11, 13, 12};

    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) << " " << m2.at(0,3) << endl;
    cout << endl;

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