实验3

#task1

##1.源代码

该任务为验证性实验，无需要手写代码，故此处不提供源代码

##2.运行测试截图

##3.回答问题

问题1： 这个范例中， Window 和 Button 是组合关系吗？

答：是

问题2： bool has_button(const std::string &label) const; 被设计为私有。 思考并回答：
（1）若将其改为公有接口，有何优点或风险？

答：优点：用户可以主动调用该函数查看某一个button是否存在，增加了一个功能，增加了类的灵活性

风险：实际上用户对这个功能需求不大，且属于内部实现细节，破坏了类的封装性

（2）设计类时，如何判断一个成员函数应为 public 还是 private？（可从"用户是否需要"、 "是否仅为内部实现

细节"、 "是否易破坏对象状态"等角度分析。）

答：

1.用户需求：用户频繁使用的函数应当尽量设置为public
2.内部实现细节函数为了安全性考虑应当设置为private
3.容易破坏对象状态的函数应当设置为private，如函数不修改对象状态且不过多暴露内部实现细节，可以考虑设置为public

问题3： Button的接口 const std::string& get_label() const;返回 const std::string&。对比以下
两种接口设计在性能和安全性方面的差异并精炼陈述。
接口1： const std::string& get_label() const;
接口2： const std::string get_label() const;
答：性能方面：接口1相较2仅传递变量的地址，而接口二返回的是label的副本，需要对label的值进行拷贝产生新的变量，这一过程消耗时间和内存资源
　　　　　　　　因此性能方面1更加强大，
　　安全方面：接口一返回的是常量引用值，getlabel的返回值是对象内部的label成员，无法通过外部改变。

接口二返回的是常量副本值，这个值无法被改变，但是外部修改副本值不会对 原对象成员产生影响，故安全性二者相差不大。

问题4： 把代码中所有 xx.push_back(Button(xxx))改成 xx.emplace_back(xxx)，观察程序是否正常运
行；查阅资料，回答两种写法的差别。

答：能正常运行，截图如下

差别：

Window::Window(const std::string &title_): title{title_} {
buttons.emplace_back("close");
}与

Window::Window(const std::string &title_): title{title_} {
buttons.push_back(Button("close"));
}，功能都是在容器buttons中添加一个标签为close的button变量

push_back(Button(xxx))：需先显式构造一个 Button 临时对象，再将该临时对象拷贝（或移动）到容器内部，最终临时对象会被销毁。

emplace_back(xxx)：无需手动构造临时对象，而是直接将参数 close 传递到容器内部的内存空间，在容器指定位置（末尾）直接构造 Button 对象。

#任务2

##1.源代码

该任务为验证性实验，无需要手写代码，故此处不提供源代码

##2.运行测试截图

###3.回答问题

问题1：测试模块1中这两行代码分别完成了什么构造？ v1 、 v2 各包含多少个值为 42 的数据项？

答：第一行代码完成了对一个包含五个数据项，数据项的值均为42的动态数组v1的构造，第二行则完成了复制构造v1的常量动态数组v2的构造。

v1，v2元素值和size均相同，但是后者是常量，一经初始化后不可改变

问题2：测试模块2中这两行代码执行后, v1.size() 、 v2.size() 、 v1[0].size() 分别是多少？

答：v1.size=,v2.size=2,v1[0].size=3

问题3：测试模块1中，把 v1.at(0) = -1; 写成 v1[0] = -1; 能否实现同等效果？两种用法有何区别？

答：可以，修改之后运行截图如下

两种用法的区别：

前者v.at(index)会花费少量开销进行越界检查，如果出现越界现象则会抛出 out_of_range 异常；

而后者不会进行越界检查，如果出现越界现象可能难以排查，并引发内存被非法修改，程序崩溃等问题

综上，前者安全性更高，检查花费开销不大，性能略低于后者

问题4：测试模块2中执行 v1.at(0).push_back(-1); 后
（1） 用以下两行代码，能否输出-1？为什么？

答：可以，这两行代码的作用：获取v1数组的第一个元素的首地址（这个元素也是一个数组），然后用r.size-1获取这个数组最后一个元素值的索引

并用r.at函数访问

（2）r定义成用 const & 类型接收返回值，在内存使用上有何优势？有何限制？

答：优势：更加安全，外界程序不会改变常量r；而且&r为引用类型，直接指向原对象地址，而非创建一个副本，相对资源开销更小

限制：因为r为const类型，无法改变指向对象的状态，得到安全性的同时丢失了灵活性

问题5：观察程序运行结果，反向分析、推断：
（1） 标准库模板类 vector 的复制构造函数实现的是深复制还是浅复制？

答：深复制，深层复制复制出来的类是原类的副本，而浅复制仅仅是让新对象的指针指向原对象地址，因此如果改变原对象，复制出来的对象也会被牵连

代码中v1有一个元素值变为-1，而复制出来的v2元素值不变，可以看出是深复制
（2） vector<T>::at() 接口思考： 当 v 是 vector<int> 时， v.at(0) 返回值类型是什么？当 v 是 const
vector<int> 时， v.at(0) 返回值类型又是什么？据此推断 at() 是否必须提供带 const 修饰的重载版本？

答：当 v 是 vector<int> 时， v.at(0) 返回值类型是int &，可以直接修改返回值指向的数组元素值。

当v是const vector<int >时，v.at(0)返回const int &，虽然仍是引用类型，但是const使得无法修改原数组元素

必须提供带const修饰的副本，原因如下：

如果只有不带const修饰的at（），则无法通过at函数访问const vector对象中的元素

而如果只有带const修饰的at（），则普通vector对象即使访问得到了vector对象的元素值也无法进行修改编辑

两周形式都需要，所以必须提供重载版本

##任务3

###1.源代码

验证性任务不提供源代码

###2.运行测试截图

###3.回答问题

问题1：当前验证性代码中， vectorInt 接口 assign 实现是安全版本。如果把 assign 实现改成版本2，逐条指
出版本 2存在的安全隐患和缺陷。（提示：对比两个版本，找出差异化代码，加以分析）

// 版本2
vectorInt& vectorInt::assign(const vectorInt &vi) {
delete[] ptr;
n = vi.n;
ptr = new int[n];
for(int i = 0; i < n; ++i)
ptr[i] = vi.ptr[i];
return *this;
}

答：源代码如下

vectorInt& vectorInt::assign(const vectorInt &vi) {
if(this == &vi)
return *this;

int *ptr_tmp;
ptr_tmp = new int[vi.n];
for(int i = 0; i < vi.n; ++i)
ptr_tmp[i] = vi.ptr[i];

delete[] ptr;
n = vi.n;
ptr = ptr_tmp;
return *this;
}

差异：

问题2：当前验证性代码中，重载接口 at 内部代码完全相同。若把非 const 版本改成如下实现，可消除重复并
遵循"最小化接口"原则（未来如需更新接口，只更新const接口，另一个会同步）。

int& vectorInt::at(int index) {
return const_cast<int&>(static_cast<const vectorInt*>(this)->at(index));
}

查阅资料，回答：
（1） static_cast<const vectorInt*>(this) 的作用是什么？转换前后 this 的类型分别是什么？转换目
的？
（2） const_cast<int&> 的作用是什么？转换前后的返回类型分别是什么？转换目的？

答：（1）

static_cast<const vectorInt*>(this) 的作用：

static_cast 是 C++ 提供的静态类型转换运算符，通过这个运算符号把this指针的类型转换成const vectorInt*类型，即static_cast<B>（A）表示把A转成B
转换前 this 类型：vectorInt*（指向当前非 const 对象的指针）。
转换后 ：const vectorInt*（指向当前对象的 const 指针）。
转换目的：将当前非 const 对象的指针临时转为 const 指针，从而调用 const 版本的 at () 接口，重用这个函数的代码，避免代码重复。

（2）

const_cast<int&> 的作用：移除（cast away）const 限定符，将一个 const int& 类型的引用转换为 int& 类型的引用。

转换前返回类型：const vectorInt*

转换后：vectorint*

转换目的：使用了const版本的at接口，返回的是一个const vectorInt*指针，而我们这个是非const版本的at函数，因此

在使用了const版本的at函数代码后，通过const_cast把指针转回vectorInt*类型。

问题3： vectorInt 类封装了 begin() 和 end() 的const/非const接口。
（1）以下代码片段，分析编译器如何选择重载版本，并总结这两种重载分别适配什么使用场景。

vectorInt v1(5);
const vectorInt v2(5);
auto it1 = v1.begin(); // 调用哪个版本？
auto it2 = v2.begin(); // 调用哪个版本？

答：仅用const关键字区分重载函数的话，编译器会选择最近的函数：const调用const版本，非const调用非const版本

编译器会选择v1.begin调用非const版本，而v2.begin调用const版本

使用场景：const版本适用于"只读"模式，不会修改对象，安全性更高

而非const版本适用于需要修改原对象的情况

（2）拓展思考（选答*）：标准库迭代器本质上是指针的封装。 vectorInt 直接返回原始指针作为迭代器，这
种设计让你对迭代器有什么新的理解？

答：迭代器只是对对象数据的一个访问接口，只考虑数据并不关心复杂的对象，因此直接指向数据存储空间的指针十分符合他的功能，

只需要移动指针，再通过*符号就获取指针指向内存的数据，简介而高效

问题4：以下两个构造函数及 assign 接口实现，都包含内存块的赋值和复制操作。使用算法库 <algorithm> 改
成如下写法是否可以？回答这3行更新代码的功能。

vectorInt::vectorInt(int n_, int value): n{n_}, ptr{new int[n_]} {
std::fill_n(ptr, n, value); // 更新
}
vectorInt::vectorInt(const vectorInt &vi): n{vi.n}, ptr{new int[n]} {
std::copy_n(vi.ptr, vi.n, ptr); // 更新
}
vectorInt& vectorInt::assign(const vectorInt &vi) {
if(this == &vi)
return *this;
int *ptr_tmp;
ptr_tmp = new int[vi.n];
std::copy_n(vi.ptr, vi.n, ptr_tmp); // 更新
delete[] ptr;
n = vi.n;
ptr = ptr_tmp;
return *this;
}

答：可行，修改后运行截图

更新1.std::fill_n(ptr, n, value)

功能：从指针 ptr 指向的内存开始，连续填充 n 个 int 类型数据，每个数据的值为 value。

更新2.std::copy_n(vi.ptr, vi.n, ptr);

功能：从源指针 vi.ptr 指向的内存开始，复制 vi.n 个元素到指针 ptr 指向的内存。

更新3.std::copy_n(vi.ptr, vi.n, ptr_tmp);

功能：与更新二一致，但是是将原对象 vi 的数据复制到临时指针 ptr_tmp 指向的新内存，

避免直接复制到ptr指向内存可能引发的内存冲突非法改写问题

##任务4

###1.源代码

matrix.hpp

#pragma once

#include <iostream>
#include <algorithm>
#include <cstdlib>
using namespace std;

// 类Matrix声明
class Matrix {
public:
    Matrix(int rows_, int cols_, double value = 0); // 构造rows_*cols_矩阵对象, 初值value
    Matrix(int rows_, double value = 0);    // 构造rows_*rows_方阵对象, 初值value
    Matrix(const Matrix &x);    // 深复制
    ~Matrix();

    void set(const double *pvalue, int size);   // 按行复制pvalue指向的数据，要求size=rows*cols,否则报错退出
    void clear();   // 矩阵对象数据项置0
    
    const double& at(int i, int j) const;   // 返回矩阵对象索引(i,j)对应的数据项const引用（越界则报错后退出）
    double& at(int i, int j);   // 返回矩阵对象索引(i,j)对应的数据项引用（越界则报错后退出）
    
    int rows() const{return n_rows;} // 返回矩阵对象行数
    int cols() const{return n_cols;}   // 返回矩阵对象列数

    void print() const;   // 按行打印数据

private:
    int n_rows;      // 矩阵对象内元素行数
    int n_cols;       // 矩阵对象内元素列数
    double *ptr;    // 数据区
};

Matrix::Matrix(int rows_, int cols_, double value ): n_rows(rows_), n_cols(cols_) {
    
    if (rows_ <= 0 || cols_ <= 0) {
        cout << "Error: invalid matrix size\n";
        exit(1);
    }
    
    ptr = new double[rows_ * cols_];
    for (int i = 0; i < rows_ * cols_; ++i) 
        ptr[i] = value;
    
}


Matrix::Matrix(int rows_, double value )
    :Matrix::Matrix(rows_,rows_){}


Matrix::Matrix(const Matrix &x):n_rows(x.n_rows),n_cols(x.n_cols),ptr(new double[x.n_rows*x.n_cols]){
    /*仿：task3-vectorInt.cpp line41-44 
    vectorInt::vectorInt(const vectorInt &vi): n{vi.n}, ptr{new int[n]} {
    //for(auto i = 0; i < n; ++i)
      //  ptr[i] = vi.ptr[i];
    std::copy_n(vi.ptr, vi.n, ptr); */
    for(auto i=0;i<x.n_rows*x.n_cols;++i)
        ptr[i]=x.ptr[i];
}

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

void Matrix::set(const double *pvalue, int size){
    // 检查数据长度是否等于矩阵总元素数
    if (size != n_rows * n_cols) {
        cout<< "Error: size do not match\n";
        exit(1);
    }
    for (int i = 0; i < size; ++i) {
        ptr[i] = pvalue[i];
    }
}

void Matrix::clear(){
    for (int i = 0; i < n_rows * n_cols; ++i) 
        ptr[i] = 0;
}  // 矩阵对象数据项置0

const double& Matrix::at(int i, int j) const{
    /*仿task3 vectorInt.hpp line55-61
    const int& vectorInt::at(int index) const {
    if(index < 0 || index >= n) {
        std::cerr << "IndexError: index out of range\n";
        std::exit(1);
    }

    return ptr[index];
} */
    if (i < 0 || i >= n_rows || j < 0 || j >= n_cols) {
        std::cerr << "IndexError: index out of range\n";
        std::exit(1);
    }
    return ptr[i * n_cols + j];
    
}  // 返回矩阵对象索引(i,j)对应的数据项const引用（越界则报错后退出）
double& Matrix::at(int i, int j){
    /*仿照task3问题2*/ 
    return const_cast<double&>(
        static_cast<const Matrix*>(this)->at(i, j)
    );
} // 返回矩阵对象索引(i,j)对应的数据项引用（越界则报错后退出）
    
void Matrix::print() const {
    for (int i = 0; i < n_rows; ++i) {
        
        cout << at(i, 0);
        for (int j = 1; j < n_cols; ++j) {
            cout << ", " << at(i, j);
        }
        cout << endl; 
    }
}

task4.cpp

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

void test1();
void test2();
void output(const Matrix &m, int row_index);

int main() {
    std::cout << "测试1: \n";
    test1();

    std::cout << "\n测试2: \n";
    test2();
}

void test1() {
    double x[1000] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    int n, m;
    std::cout << "Enter n and m: ";
    std::cin >> n >> m;

    Matrix m1(n, m);    // 创建矩阵对象m1, 大小n×m
    m1.set(x, n*m);     // 用一维数组x的值按行为矩阵m1赋值

    Matrix m2(m, n);    // 创建矩阵对象m2, 大小m×n
    m2.set(x, m*n);     // 用一维数组x的值按行为矩阵m1赋值

    Matrix m3(n);       // 创建一个n×n方阵对象
    m3.set(x, n*n);     // 用一维数组x的值按行为矩阵m3赋值

    std::cout << "矩阵对象m1: \n";   m1.print();
    std::cout << "矩阵对象m2: \n";   m2.print();
    std::cout << "矩阵对象m3: \n";   m3.print();
}

void test2() {
    Matrix m1(2, 3, -1);
    const Matrix m2(m1);
    
    std::cout << "矩阵对象m1: \n";   m1.print();
    std::cout << "矩阵对象m2: \n";   m2.print();

    m1.clear();
    m1.at(0, 0) = 1;

    std::cout << "m1更新后: \n";
    std::cout << "矩阵对象m1第0行 "; output(m1, 0);
    std::cout << "矩阵对象m2第0行: "; output(m2, 0);
}

// 输出矩阵对象row_index行所有元素
void output(const Matrix &m, int row_index) {
    if(row_index < 0 || row_index >= m.rows()) {
        std::cerr << "IndexError: row index out of range\n";
        exit(1);
    }

    std::cout << m.at(row_index, 0);
    for(int j = 1; j < m.cols(); ++j)
        std::cout << ", " << m.at(row_index, j);
    std::cout << '\n';
}

###2.运行测试截图

##任务5

###1.源代码

//contact.hpp
#pragma once

#include <iostream>
#include <string>

// 联系人类
class Contact {
public:
    Contact(const std::string &name_, const std::string &phone_);

    const std::string &get_name() const;
    const std::string &get_phone() const;
    void display() const;

private:
   std::string name;    // 必填项
   std::string phone;   // 必填项
};

Contact::Contact(const std::string &name_, const std::string &phone_):name{name_}, phone{phone_} {
}

const std::string& Contact::get_name() const {
    return name;
}

const std::string& Contact::get_phone() const {
    return phone;
}

void Contact::display() const {
    std::cout << name << ", " << phone;
}

//contactBook.hpp
#pragma once

#include <iostream>
#include <string>

// 联系人类
class Contact {
public:
    Contact(const std::string &name_, const std::string &phone_);

    const std::string &get_name() const;
    const std::string &get_phone() const;
    void display() const;

private:
   std::string name;    // 必填项
   std::string phone;   // 必填项
};

Contact::Contact(const std::string &name_, const std::string &phone_):name{name_}, phone{phone_} {
}

const std::string& Contact::get_name() const {
    return name;
}

const std::string& Contact::get_phone() const {
    return phone;
}

void Contact::display() const {
    std::cout << name << ", " << phone;
}

//task5.cpp
#include "contactBook.hpp"

void test() {
    ContactBook contactbook;

    std::cout << "1. add contacts\n";
    contactbook.add("Bob", "18199357253");
    contactbook.add("Alice", "17300886371");
    contactbook.add("Linda", "18184538072");
    contactbook.add("Alice", "17300886371");

    std::cout << "\n2. display contacts\n";
    std::cout << "There are " << contactbook.size() << " contacts.\n";
    contactbook.display();

    std::cout << "\n3. find contacts\n";
    contactbook.find("Bob");
    contactbook.find("David");

    std::cout << "\n4. remove contact\n";
    contactbook.remove("Bob");
    contactbook.remove("David");
}

int main() {
    test();
}

###2.运行测试截图