11.4

#include<iostream>

class vector_int
{
public:
    vector_int();
    vector_int(int n);
    vector_int(int n, int value);
    vector_int(vector_int &X);
    ~vector_int();
    int &at(int n);
    void show();

private: 
    int size;
    int *array;
}; 

vector_int::vector_int(int n):size(n)
{
    array = new int[n];
}

vector_int::vector_int(int n, int value):size(n)
{
    array = new int[n];
    
    for(auto i = 0; i < n ; i++)
    {
        array[i] = value;
    }
}

vector_int::vector_int(vector_int &X)
{
    size = X.size;
    array = new int(X.size);
    
     for(auto i=0; i<X.size; ++i)
        array[i] = X.array[i];
}

vector_int::~vector_int()
{
    delete[] array;
}

int &vector_int::at(int n)
{
    return array[n];
}

void vector_int::show()
{
    for(auto i=0; i<size; ++i)
        std::cout << array[i] << " ";
    
    std::cout << std::endl;
}

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

int main() 
{
    using namespace std;

    vector_int x1(3);
    vector_int x2(3,4);
    vector_int x3(x2);
    

        x3.at(0) = 0;
    
    cout << "x2 :";
    x2.show();
    cout << "x3 :" ;
    x3.show();
}

#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)              // 构造函数，构造一个n*m的矩阵
{
    lines = n;
    cols = m;
    p = new double[n*m];
}

Matrix::Matrix(const Matrix &X)           // 复制构造函数，使用已有的矩阵X构造
{
    lines = X.lines;
    cols = X.cols;
    p = new double[lines*cols];
    int i,j;
    for(i = 0; i < lines ;i++)
    {
        for(j =0; j < cols ;j++)
        {
            p[i*cols+j] = X.p[i*cols+j];
        }
    }
    
}

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

void Matrix::set(const double *pvalue)     // 用pvalue指向的连续内存块数据为矩阵赋值
{
    int i,j,k = 0;
    for(i = 0; i < lines ;i++)
    {
        for(j =0; j < cols ;j++)
        {
            p[i*cols+j] = pvalue[k];
            k++;
        }
    }
}    

void Matrix::set(int i, int j, int value) //设置矩阵第i行第j列元素值为value
{
    p[i*cols+j] = value;
}

double &Matrix::at(int i, int j)          //返回矩阵第i行第j列元素的引用
{
    return p[i*cols+j];
}
   
double Matrix::at(int i, int j) const     // 返回矩阵第i行第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(auto i = 0; i < lines ;i++)
    {
        for(auto j =0; j < cols ;j++)
        {
            std::cout << p[i*cols+j] << " ";
        }
        std::cout << std::endl;
    }
}
  

#endif

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

 实验总结：

无