类和对象_基础编程2

实验任务一：

源代码：

button.hpp

#pragma once
#include <iostream>
#include <string>
class Button {
public:
    Button(const std::string& label_);
    const std::string& get_label() const;
    void click();
private:
    std::string label;
};
Button::Button(const std::string& label_) : label{ label_ } {
}
inline const std::string& Button::get_label() const {
    return label;
}
inline void Button::click() {
    std::cout << "Button '" << label << "' clicked\n";
}

window.hpp

#pragma once
#include <iostream>
#include <vector>
#include <algorithm>
#include "button.hpp"
// 窗口类
class Window {
public:
    Window(const std::string& title_);
    void display() const;
    void close();
    void add_button(const std::string& label);
    void click_button(const std::string& label);
private:
    bool has_button(const std::string& label) const;
private:
    std::string title;
    std::vector<Button> buttons;
};
Window::Window(const std::string& title_) : title{ title_ } {
    buttons.push_back(Button("close"));
}
inline void Window::display() const {
    std::string s(40, '*');
    std::cout << s << std::endl;
    std::cout << "window : " << title << std::endl;
    int cnt = 0;
    for (const auto& button : buttons)
        std::cout << ++cnt << ". " << button.get_label() << std::endl;
    std::cout << s << std::endl;
}
inline void Window::close() {
    std::cout << "close window '" << title << "'" << std::endl;
    click_button("close");
}
inline bool Window::has_button(const std::string& label) const {
    for (const auto& button : buttons)
        if (button.get_label() == label)
            return true;

    return false;
}
inline void Window::add_button(const std::string& label) {
    if (has_button(label))
        std::cout << "button " << label << " already exists!\n";
    else
        buttons.push_back(Button(label));
}
inline void Window::click_button(const std::string& label) {
    for (auto& button : buttons)
        if (button.get_label() == label) {
            button.click();
            return;
        }

    std::cout << "no button: " << label << std::endl;
}

task1.cpp

#include "window.hpp"
#include <iostream>
void test() {
    Window w("Demo");
    w.add_button("add");
    w.add_button("remove");
    w.add_button("modify");
    w.add_button("add");
    w.display();
    w.close();
}
int main() {
    std::cout << "用组合类模拟简单GUI:\n";
    test();
}

运行结果截图：

 回答问题：

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

　　是组合关系。Window 类的私有成员std::vector<Button> buttons直接存储 Button 对象，Button 对象作为 Window 的组成部分存在：当 Window 对象被销毁时，其内部 vector 及 vector 中存储的所有 Button 对象会自动调用析构函数销毁；同时，Button 对象无法脱离 Window 独立存在。

问题2： bool has_button(const std::string &label) const; 被设计为私有。 思考并回答：

（1）若将其改为公有接口，有何优点或风险？

 　　优点：增加代码的灵活性，允许用户直接查询。风险：破坏类的封装性，增加类的维护成本。

（2）设计类时，如何判断一个成员函数应为 public 还是 private？（可从“用户是否需要”、“是否仅为内 部实现细节”、“是否易破坏对象状态”等角度分析。）

 　　　函数是类对外提供的核心功能（如 Window 的display、add_button，Button 的click），需设为 public；若函数仅为辅助功能（如has_button辅助add_button），外部用户无直接使用需求，则设为 private。

 　　　函数与类的内部逻辑强绑定，且可能随内部实现变更而调整，则设为 private；若函数不涉及内部细节，则设为 public。

　　　 若函数直接操作类的私有成员，调用后可能导致对象状态变化，则设为 private；若函数仅读取状态（如add_button有重复校验），则可设为 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仅返回私有成员label的 const 引用，无需创建新对象，无内存拷贝开销，性能高效。接口2会增加内存开销，影响性能。

　　安全性：接口1返回 const 引用可防止外部通过引用修改私有成员label，保证成员变量不可被外部篡改，安全性高。接口2安全性较低。

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

　　正常运行。差别：

1. 对象构造方式不同：
   • push_back(Button(xxx))：先显式创建一个 Button 临时对象（调用 Button 的构造函数），再将临时对象拷贝（或移动）到 vector 的内存空间中，存在 “临时对象创建→拷贝 / 移动” 的过程。
   • emplace_back(xxx)：直接在 vector 预留的内存空间中调用 Button 的构造函数创建对象，无需创建临时对象，也无需拷贝 / 移动操作，减少了中间步骤。
2. 依赖的构造函数不同：
   • push_back要求传入的参数是 Button 对象（或可转换为 Button 的对象），依赖 Button 的构造函数和拷贝 / 移动构造函数。
   • emplace_back可直接传入 Button 构造函数所需的参数（如label字符串），通过 “可变参数模板” 将参数转发给 Button 的构造函数，仅依赖 Button 的构造函数。
3. 性能差异：
   • emplace_back因避免了临时对象的创建和拷贝 / 移动，在对象构造成本较高（如成员变量复杂）时，性能优于push_back；在简单对象（如 Button 仅含 string 成员）场景下，性能差异不明显，但仍更高效

实验任务二：

源代码：

 

#include <iostream>
#include <vector>
void test1();
void test2();
void output1(const std::vector<int>& v);
void output2(const std::vector<int>& v);
void output3(const std::vector<std::vector<int>>& v);
int main() {
    std::cout << "深复制验证1: 标准库vector<int>\n";
    test1();
    std::cout << "\n深复制验证2: 标准库vector<int>嵌套使用\n";
    test2();
}
void test1() {
    std::vector<int> v1(5, 42);
    const std::vector<int> v2(v1);
    v1.at(0) = -1;
    std::cout << "**********拷贝构造后**********\n";
    std::cout << "v1: "; output1(v1);
    std::cout << "v2: "; output1(v2);
    std::cout << "**********修改v1[0]后**********\n";
    std::cout << "v1: "; output1(v1);
    std::cout << "v2: "; output1(v2);
}
void test2() {
    std::vector<std::vector<int>> v1{ {1, 2, 3}, {4, 5, 6, 7} };
    const std::vector<std::vector<int>> v2(v1);
    std::cout << "**********拷贝构造后**********\n";
    std::cout << "v1: "; output3(v1);
    std::cout << "v2: "; output3(v2);
    v1.at(0).push_back(-1);
    std::cout << "**********修改v1[0]后**********\n";
    std::cout << "v1: \n";  output3(v1);
    std::cout << "v2: \n";  output3(v2);
}
// 使用xx.at()+循环输出vector<int>数据项
void output1(const std::vector<int>& v) {
    if (v.size() == 0) {
        std::cout << '\n';
        return;
    }
    std::cout << v.at(0);
    for (auto i = 1; i < v.size(); ++i)
        std::cout << ", " << v.at(i);
    std::cout << '\n';
}
// 使用迭代器+循环输出vector<int>数据项
void output2(const std::vector<int>& v) {
    if (v.size() == 0) {
        std::cout << '\n';
        return;
    }
    auto it = v.begin();
    std::cout << *it;
    for (it = v.begin() + 1; it != v.end(); ++it)
        std::cout << ", " << *it;
    std::cout << '\n';
}
// 使用auto for分行输出vector<vector<int>>数据项
void output3(const std::vector<std::vector<int>>& v) {
    if (v.size() == 0) {
        std::cout << '\n';
        return;
    }
    for (auto& i : v)
        output2(i);
}

 

运行结果截图：

 

 回答问题：

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

　　v1赋值构造，v2拷贝构造。v1,v2都为10个值为42的数据项。

 

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

　　v1.size()=2；v2.size()=2；v1[0].size()=3.

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

　　能；区别：at（）会进行边界检查，较[ ]性能更高，更加安全。

问题4：测试模块2中执行 v1.at(0).push_back(-1); 后

（1） 用以下两行代码，能否输出-1？为什么？

　　能；原因：v1.at(0)会返回v1第0个元素（vector）的引用，所以push_back(-1)会在内层vector最后一个元素后插入一个值为-1的元素。r.at(r.size()-1)会获取内层vector的最后一个元素-1.

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

　　优势：避免不必要的拷贝，减少内存开销，访问效率更高。限制：const类型只能访问值，不能修改值。

问题5：观察程序运行结果，反向分析、推断：

（1） 标准库模板类 vector 的复制构造函数实现的是深复制还是浅复制？

　　深复制；v1中的值改变时，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& ；at() 必须提供带 const 修饰的重载版本，以同时支持非 const 容器的可修改访问和 const 容器的只读访问，兼顾灵活性与安全性。

实验任务三：

源代码：

#pragma once
#include <iostream>
// 动态int数组对象类
class vectorInt {
public:
    vectorInt();
    vectorInt(int n_);
    vectorInt(int n_, int value);
    vectorInt(const vectorInt& vi);
    ~vectorInt();
    int size() const;
    int& at(int index);
    const int& at(int index) const;
    vectorInt& assign(const vectorInt& vi);
    int* begin();
    int* end();
    const int* begin() const;
    const int* end() const;
private:
    int n;
    // 当前数据项个数
    int* ptr;  // 数据区
};
vectorInt::vectorInt() :n{ 0 }, ptr{ nullptr } {
}
vectorInt::vectorInt(int n_) : n{ n_ }, ptr{ new int[n] } {
}
vectorInt::vectorInt(int n_, int value) : n{ n_ }, ptr{ new int[n_] } {
    for (auto i = 0; i < n; ++i)
        ptr[i] = value;
}
vectorInt::vectorInt(const vectorInt& vi) : n{ vi.n }, ptr{ new int[n] } {
    for (auto i = 0; i < n; ++i)
        ptr[i] = vi.ptr[i];
}
vectorInt::~vectorInt() {
    delete[] ptr;
}
int vectorInt::size() const {
    return n;
}
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];
}
int& vectorInt::at(int index) {
    if (index < 0 || index >= n) {
        std::cerr << "IndexError: index out of range\n";
        std::exit(1);
    }
    return ptr[index];
}
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;
}
int* vectorInt::begin() {
    return ptr;
}
int* vectorInt::end() {
    return ptr + n;
}
const int* vectorInt::begin() const {
    return ptr;
}
const int* vectorInt::end() const {
    return ptr + n;
}

#include "vectorInt.hpp"
#include <iostream>
void test1();
void test2();
void output1(const vectorInt& vi);
void output2(const vectorInt& vi);
int main() {
    std::cout << "测试1: \n";
    test1();
    std::cout << "\n测试2: \n";
    test2();
}
void test1() {
    int n;
    std::cout << "Enter n: ";
    std::cin >> n;
    vectorInt x1(n);
    for (auto i = 0; i < n; ++i)
        x1.at(i) = (i + 1) * 10;
    std::cout << "x1: ";  output1(x1);
    vectorInt x2(n, 42);
    vectorInt x3(x2);
    x2.at(0) = -1;
    std::cout << "x2: ";  output1(x2);
    std::cout << "x3: ";  output1(x3);
}
void test2() {
    const vectorInt  x(5, 42);
    vectorInt y;
    y.assign(x);
    std::cout << "x: ";  output2(x);
    std::cout << "y: ";  output2(y);
}

// 使用xx.at()+循环输出vectorInt对象数据项
void output1(const vectorInt& vi) {
    if (vi.size() == 0) {
        std::cout << '\n';
        return;
    }
    std::cout << vi.at(0);
    for (auto i = 1; i < vi.size(); ++i)
        std::cout << ", " << vi.at(i);
    std::cout << '\n';
}
// 使用迭代器+循环输出vectorInt对象数据项
void output2(const vectorInt& vi) {
    if (vi.size() == 0) {
        std::cout << '\n';
        return;
    }
    auto it = vi.begin();
    std::cout << *it;
    for (it = vi.begin() + 1; it != vi.end(); ++it)
        std::cout << ", " << *it;
    std::cout << '\n';
}

运行结果截图：

回答问题：

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

　　（1）自赋值问题：版本2中 ptr[i] = vi.ptr[i]；自赋值可能会导致程序崩溃。安全版本：if(this !=&vi) 避免了自赋值问题。

　　（2）内存泄漏：版本2中当new int n[ ]执行失败时，会导致内存泄漏。安全版本：先创建一个新的，再将旧的销毁，如果内存分配失败，就会报错。

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

查阅资料，回答：

（1） static_cast(this) 的作用是什么？转换前后 this 的类型分别是什么？转换目的？

　　作用：将当前对象的指针 this 从非 const 类型 vectorInt* 安全地转换为 const 类型 const vectorInt*。

　　转换前：this 的类型是 vectorInt*。可以调用对象的非 const 成员函数，并且可以修改对象的数据成员。

　　转换后：this 的类型被强制转换为 const vectorInt*。这意味着通过这个转换后的指针，只能调用对象的 const 成员函数，并且不能修改对象的数据成员。

　　转化目的：为了能够调用 at 函数的 const 重载版本。　

（2）const_cast<int&>的作用是什么？转换前后的返回类型分别是什么？转换目的？

　　作用：这个表达式的作用是去除 const 限定符。它将一个 const 引用（const int&）转换为一个非 const 引用（int&）。

　　转化前：static_cast<const vectorInt*>(this)->at(index) 的返回值类型是 const int&。这是一个指向 const int 的引用，意味着你不能通过这个引用去修改它所指向的值。

　　转化后：const_cast<int&>(...) 的结果类型是 int&。这是一个普通的、可修改的 int 引用。

　　转化目的：满足非 const 版本 at 函数的返回类型要求。

问题3：vectorInt类封装了begin()和end()的const/非const接口。

（1）以下代码片段，分析编译器如何选择重载版本，并总结这两种重载分别适配什么使用场景。

　　vectorInt v1(5);

　　const vectorInt v2(5);

　　auto it1 = v1.begin();    // 调用非const版本

　　auto it2 = v2.begin();    // 调用const版本

　　非const对象会优先匹配非const版本的迭代器，const类型对象只能匹配const版本的迭代器。

　　非const：需要遍历并可能修改容器内元素。

　　const：需要遍历和读取容器内元素，而不希望修改。

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

　　迭代器定义了如何遍历一个序列，而不是一种特定的数据类型。可以使用相同的遍历代码（例如 for 循环）来处理任何容器类型，而无需关心其内部存储细节。

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

　　更新1：std::fill_n(ptr, n, value);初始化新分配的内存，将内部数组的每个元素都被赋予为指定值 value。

　　更新2：std::copy_n(vi.ptr, vi.n, ptr); 实现深拷贝，将vi.ptr中的数据复制到ptr中。

　　更新3：std::copy_n(vi.ptr, vi.n, ptr_tmp);同更新2复制数据。

实验任务四：

源代码：

#pragma once
#pragma once
// 类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() {
        delete[] ptr;
    }
    
    // 深复制
    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;   // 返回矩阵对象行数
    int cols() const;   // 返回矩阵对象列数
    void print() const;   // 按行打印数据
private:
    int n_rows;
    int n_cols;
    double* ptr;
};

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

Matrix::Matrix(int rows_, int cols_, double value) :n_rows{ rows_ }, n_cols{ cols_ } {
    if (rows_ <= 0 || cols_ <= 0) {
        std::cout << "行和列必须为正\n";
        return;
    }
    ptr = new double[rows_ * cols_];
    for (int i =0; i <rows_ * cols_; i++) {
        ptr[i] = value;
    }
} // 构造rows_*cols_矩阵对象, 初值value

Matrix::Matrix(int rows_, double value) :Matrix(rows_, rows_, value) {}// 构造rows_*rows_方阵对象, 初值value

Matrix::Matrix(const Matrix& x) :n_rows{ x.n_rows }, n_cols{ x.n_cols } {
    ptr = new double[n_rows * n_cols];
    for (int i = 0;i <n_rows * n_cols;i++) {
        ptr[i] = x.ptr[i];
    }
}



void Matrix::set(const double* pvalue, int size) {
    if (size != n_rows * n_cols) {
        std::cout << "size数值错误\n";
        return;
    }
    if (pvalue == nullptr) {
        std::cout << "pvalue为空\n";
        return;
    }
    for (int i =0;i <size;i++) {
        ptr[i] = pvalue[i];
    }
}
void Matrix::clear() {
    for (int i = 0;i < n_cols * n_rows;i++) {
        ptr[i] = 0;
    }
}
const double& Matrix::at(int i, int j) const {
    if (i < 0 || i >= n_rows || j < 0 || j >= n_cols) {
        std::cout << "越界\n";
        exit(0);
    }
    return ptr[i * n_cols + j];
}
double& Matrix::at(int i, int j) {
    if (i < 0 || i >= n_rows || j < 0 || j >= n_cols) {
        std::cout << "越界\n";
        exit(0);
    }
    return ptr[i * n_cols+j];
}
int Matrix::rows() const {
    return n_rows;
}
int Matrix::cols() const {
    return n_cols;
}
void Matrix::print() const {
    for (int i = 0;i < n_rows;i++) {
        std::cout << at(i, 0);
        for (int j = 1;j <n_cols;j++) {
            std::cout << "," << at(i, j);
        }
        std::cout << '\n';
    }
    std::cout << '\n';
}

#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.set(x, n * m);
    Matrix m2(m, n);
    m2.set(x, m * n);
    Matrix m3(n);
    m3.set(x, n * n);
    // 创建矩阵对象m1, 大小n×m
     // 用一维数组x的值按行为矩阵m1赋值
    // 创建矩阵对象m2, 大小m×n
     // 用一维数组x的值按行为矩阵m1赋值
    // 创建一个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";
        std::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';
}

运行结果截图：

拓展思考：

　零成本：

1. 性能成本为零：如前所述，std::vector 的核心操作（operator[], size(), 迭代器遍历）的性能与手动管理的数组完全相同。
2. 内存成本接近零：仅仅多占用了一点微小的内存。

实验任务五：

源代码：

 

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

#pragma once

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include "contact.hpp"

// 通讯录类
class ContactBook {
public:
    void add(const std::string& name, const std::string& phone); // 添加联系人
    void remove(const std::string& name); // 移除联系人
    void find(const std::string& name) const; // 查找联系人
    void display() const; // 显示所有联系人
    size_t size() const;
private:
    int index(const std::string& name) const;  // 返回联系人在contacts内索引，如不存在，返回 - 1
    void sort(); // 按姓名字典序升序排序通讯录
private:
    std::vector<Contact> contacts;
};

    void ContactBook::add(const std::string& name, const std::string& phone) {
        if (index(name) == -1) {
        contacts.push_back(Contact(name, phone));
        std::cout << name << " add successfully.\n";
        sort();
        return;
        }
    std::cout << name << " already exists. fail to add!\n";
    }
     void ContactBook::remove(const std::string & name) {
         int i = index(name);
         if (i == -1) {
             std::cout << name << " not found, fail to remove!\n";
             return;
         }
         contacts.erase(contacts.begin() + i);
         std::cout << name << " remove successfully.\n";
     }
     void ContactBook::find(const std::string& name) const {
         int i = index(name);
         if (i == -1) {
             std::cout << name << " not found!\n";
             return;
         }
         contacts[i].display();
         std::cout << '\n';
     }
     void ContactBook::display() const {
         for (auto& c : contacts){
             c.display();
             std::cout << '\n';
         }
     }
     size_t ContactBook::size() const {
         return contacts.size();
     }
     int ContactBook::index(const std::string& name)const {
         int ans = -1,j=0;
         for (auto &i : contacts) {
             if (name == i.get_name()) ans = j;
             j++;
         }
         return ans;
     }
     bool cmp(const Contact& a, const Contact& b) {
         return a.get_name() < b.get_name();
     }
     void ContactBook::sort() {
         std::sort(contacts.begin(), contacts.end(),cmp);
     }

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

运行结果截图：

 

 实验总结：

1.零成本抽象：编写代码时应该优先选择标准库函数。

2.组合是‘整体包含部分’的 has-a 关系，深复制是‘内存独立副本’的保障。浅复制因共享内存会导致悬挂指针、数据篡改等问题，而深复制通过独立分配内存并拷贝数据，确保了对象间的完全独立性。

3.类的设计，需要从功能实现、封装性、异常安全等多维度优化，最终目标是让类在各种场景下都能正确、高效地工作。