实验任务1 代码:
class Button { public: Button(const std::string &label); const std::string& get_label() const; void click();
private: std::string label_; };
inline 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"; }
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();
return 0; }
// 窗口类 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;
std::string title_; std::vector buttons_; }; inline 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; } 截图: 问题1:是组合(Composition)关系。 声明方式:在 Window 类中,buttons_ 被声明为 std::vector(即存储 Button 的值,而不是 Button* 或 std::shared_ptr 等指针/引用)。 生命周期管理:因为存储的是值对象,Window 对象在构造时会直接包含这些 Button 对象的内存。当 Window 对象被销毁时,buttons_ 这个 vector 也会被销毁,进而自动调用其中所有 Button 对象的析构函数。Button 的生命周期严格受限于 Window 的生命周期,这符合组合关系“同生共死”(强拥有)的特征。如果是聚合关系,通常会使用指针来存储对象,对象的生命周期可能独立于容器。 问题2:① 若将其改为公有接口,有何优点或风险? 优点:外部代码(用户)可以直接查询窗口是否包含某个特定按钮,便于实现外部逻辑判断(例如:外部逻辑根据是否含有某按钮来决定后续操作)。 风险:暴露了内部实现细节。has_button 的底层实现是遍历 buttons_(O(n) 复杂度)。如果公有化,外部频繁调用可能导致性能问题;此外,如果未来 Window 内部为了提升性能将 buttons_ 改为 std::unordered_map,虽然接口不变,但外部如果过度依赖查询行为可能会产生耦合。更严重的是,如果外部能查询状态,可能会让外部逻辑变得复杂且与 Window 内部状态紧密绑定,破坏封装性。 ② 设计类时,如何决策一个成员函数应为 public 还是 private? 可以从以下几个角度分析: 用户是否需要:该函数是否是提供给外部用户完成特定业务功能的必要操作?(如 add_button, click_button 是必须的)。 是否仅为内部实现细节:该函数是否仅仅是为了辅助类内部其他公有方法而存在的?(has_button 显然只是为了辅助 add_button 去重,是内部辅助函数)。 是否易破坏对象状态:公有函数如果被误用是否会破坏类的封装性或不变量?has_button 是 const 函数,不破坏状态,但暴露了内部数据结构的大小和查找方式(时间复杂度)。隐藏内部辅助函数是良好的封装习惯。 问题3:接口1:const std::string& get_label() const; 性能:优。返回引用,不发生字符串内存的拷贝(拷贝构造),调用开销极小。 安全性:相对较低。返回的是内部成员 label_ 的引用。如果外部代码不小心保存了这个引用,而原始的 Button 对象被销毁(例如从 vector 中删除),或者 Window 对象被销毁,这个引用就会变成悬空引用(Dangling Reference),导致未定义行为(崩溃)。 接口2:std::string get_label() const; 性能:较差。返回的是一个临时值,每次调用都会发生一次字符串拷贝,如果字符串很长,会有显著的性能开销。 安全性:高。返回的是副本,外部怎么修改或持有这个返回的字符串都不会影响 Button 内部的状态,也不存在悬空引用的风险。 精炼陈述:在性能敏感且能确保返回值生命周期不超过原对象的场景下,优先使用 const std::string&;但在需要保证安全性和避免生命周期管理复杂性的现代 C++ 中,通常会选择返回值(std::string),或利用 C++17 的 std::string_view(需谨慎对待生命周期),若确实需要返回引用,应保证接口契约明确,提醒调用者不要持有引用。 问题4:把 xx.push_back(Button(xxx)) 改成 xx.emplace_back(xxx),观察程序是否正常运行;查阅资料,回答两种写法的差别。 是否正常运行:正常运行。代码逻辑完全一致。 差别: push_back(Button(xxx)):会先在栈上(或临时对象区)构造一个临时的 Button 对象,然后将这个临时对象拷贝(或移动)到 vector 的末尾内存中,最后销毁临时对象。 emplace_back(xxx):原地构造(In-place construction)。它直接把参数 xxx(这里是 const std::string& 或 const char*)完美转发给 vector 管理的内存空间,直接在容器的末尾内存上调用 Button 的构造函数。省去了临时对象的创建和拷贝/移动的开销,效率更高。 ② 用标准库改写 Window::has_button() 实现,是否可以?简述 std::any_of() 功能、参数和返回值意义。 是否可以:完全可以,且代码更简洁,符合现代 C++ 风格。 3:可以。std::find_if() 简述: 功能:在给定范围内查找第一个满足特定条件(谓词)的元素。 参数:三个参数。前两个是迭代器(first, last)表示查找区间;第三个是一个一元谓词,用于判断元素是否符合查找条件。 返回值:返回一个迭代器。如果找到了满足条件的元素,返回指向该第一个匹配元素的迭代器;如果遍历完整个区间都没有找到,则返回 last(即 buttons_.end())。 实验2: 代码: #include include void test1(); void test2(); void output1(const std::vector &v); void output2(const std::vector &v); void output3(const std::vector<std::vector>& v); int main() { std::cout << "深复制验证1: 标准库vector\n"; test1(); std::cout << "\n深复制验证2: 标准库vector嵌套使用\n"; test2(); return 0; } void test1() { std::vector v1(5, 42); const std::vector v2(v1); std::cout << "拷贝构造后\n"; std::cout << "v1: "; output1(v1); std::cout << "v2: "; output1(v2); v1[0] = -1; std::cout << "修改v1[0]后\n"; std::cout << "v1: "; output1(v1); std::cout << "v2: "; output1(v2); } void test2() { std::vector<std::vector> v1{{1, 2, 3}, {4, 5, 6, 7}}; const std::vector<std::vector> v2(v1); std::cout << "拷贝构造后\n"; std::cout << "v1:\n"; output3(v1); std::cout << "v2:\n"; output3(v2); v1[0].push_back(-1); std::cout << "修改v1[0]后\n"; std::cout << "v1:\n"; output3(v1); std::cout << "v2:\n"; output3(v2); } // 使用索引+循环,遍历输出vector数据项 void output1(const std::vector &v) { if(v.size() == 0) { std::cout << '\n'; return; } std::cout << v[0]; for(auto i = 1; i < v.size(); ++i) std::cout << ", " << v[i]; std::cout << '\n'; } // 使用迭代器+循环,遍历输出vector数据项 void output2(const std::vector &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>数据项 void output3(const std::vector<std::vector>& v) { if(v.size() == 0) { std::cout << '\n'; return; } for(auto &i: v) output2(i); } 截图: 问题1:构造分析: std::vector v1(5, 42); 完成了 填充构造函数(Fill Constructor)。它创建了一个包含 5 个元素的 vector,每个元素的值都被初始化为 42。 const std::vector v2(v1); 完成了 拷贝构造函数(Copy Constructor)。它使用已有的 v1 来初始化 v2,创建了一个 v1 的深拷贝(副本),并且 v2 被声明为 const,意味着之后不能通过 v2 修改其内部元素。 数据项数量:v1 和 v2 各包含 5 个值为 42 的数据项。 问题2:v1.size() = 2 v2.size() = 2 v1[0].size() = 3 问题3:能否实现同等效果:能。两者都会将 v1 的第一个元素修改为 -1。 区别: 边界检查(安全性):at() 会进行边界检查。如果索引越界(例如 v1.at(10) 当 v1 只有 5 个元素时),at() 会抛出 std::out_of_range 异常。而 operator[] 不进行边界检查,越界访问会导致未定义行为(通常是程序崩溃或读取到垃圾内存)。 性能:operator[] 因为省去了边界检查,理论上执行速度会略微快一点点(但在现代编译器优化下,差别往往可以忽略不计)。 使用场景:在确定索引绝对合法(如循环中遍历)时使用 [];在不确定索引是否合法,或者需要捕获错误以防崩溃时,使用 at()。 问题4:能否输出:能。 为什么:v1[0] 返回的是内层 vector 的引用。const std::vector &r = v1[0]; 使用 const 引用 r 绑定了这个内层 vector。此时 v1[0] 已经通过 push_back(-1) 变为了 {1, 2, 3, -1}。r 作为引用,实时反映了底层对象的变化。r.size() 为 4,r[3] 即最后一个元素,值为 -1。这里 const 只是限制不能通过 r 去修改它,但不影响读取。 ② r 定义成用 const & 类型接收返回值,在内存使用上有何优势?有何限制? 优势:使用引用(&)接收返回值,避免了对象的拷贝。如果直接写 const std::vector r = v1[0];,会调用 vector 的拷贝构造函数,分配新的内存并复制所有元素。使用引用 const std::vector &r 仅仅是给原对象起了一个别名,不发生内存分配和拷贝,开销极小(特别是在存放大量数据的容器中非常关键)。 限制:因为 r 是引用,它的生命周期受限于原对象 v1[0] 的生命周期。如果原对象(比如外层的 v1 被销毁,或者 v1 进行了扩容导致内存重新分配),r 就会变成悬空引用(Dangling Reference),此时再访问 r 会导致未定义行为。另外,加了 const 后,只能通过 r 读取数据,不能通过 r 修改数据(如 r.push_back 或 r[0]=1 都是不允许的)。 问题5: 标准库模板类 vector 的复制构造函数实现的是深拷贝还是浅拷贝? 推断:深拷贝(Deep Copy)。 理由:从 test1 和 test2 的运行结果来看,在拷贝构造出 v2 之后,修改 v1 的内容(v1[0] = -1 或 v1[0].push_back(-1)),v2 的内容没有任何改变。如果 vector 是浅拷贝(仅复制指针),那么 v1 和 v2 将共享同一块底层数组内存,修改 v1 必然会导致 v2 也跟着变。因为互不影响,说明 vector 的拷贝构造会为新对象重新分配堆内存,并将原对象的所有元素逐一复制过去。 ② vector::at() 接口思考: 当 v 是 vector 时,v.at(0) 返回值类型是 int&(整型的引用)。 当 v 是 const vector 时,v.at(0) 返回值类型是 const int&(常整型的引用)。 据此推断标准库 std::vector 的 at() 接口是否必须提供带 const 修饰的重载版本? 必须提供。因为 C++ 的 const 成员函数只能返回 const 引用(或者值),不能返回非 const 引用,否则就破坏了 const 对象的不可变性(允许通过返回值修改 const 对象)。为了让 const vector 能够调用 at() 进行只读访问,并且让非 const vector 调用 at() 时能够返回可修改的引用,标准库必须为 at() 提供两个重载版本: reference at(size_type pos); (非 const 版本,返回 T&) const_reference at(size_type pos) const; (const 版本,返回 const T&) 实验3:#include "vectorInt.hpp" include void test1(); void test2(); void test3(); void output1(const vectorInt &vi); void output2(const vectorInt &vi); int main() { std::cout << "测试1: 构造、更新\n"; test1(); std::cout << "\n测试2: const对象、赋值\n"; test2(); std::cout << "\n测试3: 赋值\n"; test3(); return 0; } 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); y.at(0) = -1; std::cout << "x: "; output2(x); std::cout << "y: "; output2(y); } void test3() { vectorInt x(5, 42); std::cout << "x: "; output2(x); x.assign(x); std::cout << "x: "; output2(x); } // 使用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'; } pragma once include include // 动态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 *pdata_; // 数据区 }; inline vectorInt::vectorInt():n_{0}, pdata_{nullptr} { } inline vectorInt::vectorInt(int n): n_{n}, pdata_{new int[n]} { } inline vectorInt::vectorInt(int n, int value): n_{n}, pdata_{new int[n]} { for(auto i = 0; i < n_; ++i) pdata_[i] = value; } inline vectorInt::vectorInt(const vectorInt &vi): n_{vi.n_}, pdata_{new int[n_]} { for(auto i = 0; i < n_; ++i) pdata_[i] = vi.pdata_[i]; } inline vectorInt::~vectorInt() { delete [] pdata_; } inline int vectorInt::size() const { return n_; } inline const int& vectorInt::at(int index) const { if(index < 0 || index >= n_) throw std::out_of_range("vectorInt::at: index out of range"); return pdata_[index]; } inline int& vectorInt::at(int index) { if(index < 0 || index >= n_) throw std::out_of_range("vectorInt::at: index out of range"); return pdata_[index]; } inline vectorInt& vectorInt::assign(const vectorInt &vi) { if(this == &vi) return *this; int *ptr; ptr = new int[vi.n_]; for(int i = 0; i < vi.n_; ++i) ptr[i] = vi.pdata_[i]; delete[] pdata_; n_ = vi.n_; pdata_ = ptr; return *this; } inline int* vectorInt::begin() { return pdata_; } inline int* vectorInt::end() { return pdata_ + n_; } inline const int* vectorInt::begin() const { return pdata_; } inline const int* vectorInt::end() const { return pdata_ + n_; } 截图: 问题1:运行结果有无异常:有异常。在 test3 中,x.assign(x) 会导致程序崩溃(产生未定义行为,通常是抛出段错误或内存访问违规)。 安全隐患和缺陷: 自赋值问题(Self-assignment):版本2一开始直接执行 delete[] pdata_;。如果发生自赋值(如 x.assign(x)),pdata_ 被释放,但 vi 就是 *this 自己,所以 vi.pdata_ 也同时变成了悬空指针。接下来的 new int[n_] 分配新内存后,尝试从已释放的 vi.pdata_ 读取数据,导致访问非法内存,程序崩溃。 异常安全性(Exception Safety)差:如果在 new int[n_] 时因内存不足抛出 std::bad_alloc 异常,此时原有的 pdata_ 已经被 delete[] 释放,原对象的数据被破坏且无法恢复,对象处于无效状态。 版本1(安全版本)的优越性:版本1采用了“先分配新内存,拷贝数据,再释放旧内存”的策略(Copy-and-Swap 思想的变体),完美解决了自赋值问题(靠 if(this == &vi) return *this; 提前拦截)以及异常安全问题。 问题2:① static_cast<const vectorInt*>(this) 的作用是什么?转换前后 this 的类型分别是什么?转换目的? 作用:将非 const 的 this 指针安全地转换为 const 指针。 类型变化:转换前,在非 const 成员函数中,this 的类型是 vectorInt* const(指针本身是常量,指向 vectorInt);转换后,类型变为 const vectorInt* const(指向 const vectorInt)。 转换目的:非 const 版本的 at 函数为了复用 const 版本中已经写好的边界检查逻辑,需要调用 ->at(index)。但 this 是非 const 的,而 at(index) const 是一个 const 成员函数,它要求调用者必须是一个 const 对象/指针。通过 static_cast 强转为 const 指针,就能合法地调用 const 版本的 at 函数。 ② const_cast<int&> 的作用是什么?转换前后的返回类型分别是什么?转换目的? 作用:移除常量性(Cast away constness)。 类型变化:转换前,static_cast<...>(this)->at(index) 返回的是 const int&;转换后,变为 int&。 转换目的:因为非 const 版本的 at 函数的签名要求返回 int&(允许外部修改)。而 const 版本的 at 返回的是 const int&(禁止修改)。由于我们知道 this 原本就是非 const 对象(只是我们临时把它强转成 const 骗过了编译器),内部数据其实是可以修改的。使用 const_cast 去掉常属性,将原本只读的引用转成可读写的引用,从而满足返回值类型的要求。 问题3: ① 分析编译器如何选择重载版本,并总结使用场景: auto it1 = v1.begin();:v1 是非 const 对象,编译器优先匹配非 const 成员函数,调用 int* begin();。返回 int*。 auto it2 = v2.begin();:v2 是 const 对象,编译器只能匹配 const 成员函数,调用 const int* begin() const;。返回 const int*。 总结使用场景: 非 const 版本:用于需要修改容器内元素的场景,或者容器本身是非 const 对象时。 const 版本:用于只读访问容器内元素的场景,确保即使容器是非 const 的,只要用 const 引用/指针接收迭代器,就无法通过迭代器修改数据,保证了安全性。 ② 拓展思考:标准库迭代器本质上是指针的封装。这种设计让你对迭代器有什么新的理解? 理解:迭代器是泛化的指针。vectorInt 直接用原生指针作为迭代器,展示了迭代器的底层本质——提供一种类似指针的操作(如 * 解引用、++ 移动、!= 比较),来遍历和操作容器内的元素。标准库的迭代器(如 std::vector::iterator 虽然可能是类对象)只是在此基础上进行了更复杂的封装,提供了迭代器分类(如随机访问迭代器)、类型安全(防止指针类型不匹配)以及统一不同容器(链表、树)的遍历接口。它体现了 C++ 的“概念抽象”思想:不论底层数据结构是什么,只要满足迭代器协议,就可以配合算法使用。 问题4:可以。 std::fill_n(pdata_, n_, value); 功能:将从 pdata_ 开始的 n_ 个连续内存空间,全部填充为指定的 value。用于替换原始的 for 循环赋值。 std::copy(vi.pdata_, vi.pdata_ + vi.n_, pdata_); 功能:将源区间 [vi.pdata_, vi.pdata_ + vi.n_) 内的元素,逐个拷贝到以 pdata_ 为目的地址的起始位置。用于替换拷贝构造中的 for 循环。 std::copy(vi.pdata_, vi.pdata_ + vi.n_, ptr); 功能:在 assign 函数中,将源对象的数据拷贝到新申请的临时内存 ptr 中。用于替换赋值操作中的 for 循环。 注意:截图中的 assign 改写(更新3,虽然截图中只注释了 for 循环但没有写出 std::copy 语句)如果是要用 std::copy,其语法应与拷贝构造相同,即 std::copy(vi.pdata_, vi.pdata_ + vi.n_, ptr);。这 3 行更新代码本质上都是用标准库算法代替了手写的底层 for 循环,使得代码更简洁,且通常有更好的编译器优化。 实验4: 代码: include "matrix.h" include include include include Matrix::Matrix(int n_rows, int n_cols, double value) n_rows_{n_rows}, n_cols_{n_cols}, pdata_{new double[n_rowsn_cols]} { std::fill_n(pdata_, n_rowsn_cols, value); } Matrix::Matrix(int n_rows, double value): Matrix(n_rows, n_rows, value) { } // 待实现:拷贝构造(深拷贝) Matrix::Matrix(const Matrix &x) { } // 待实现:释放指针指向的内存资源 Matrix::~Matrix() { } void Matrix::set(const double *pvalue, int size) { if(size != n_rows_ * n_cols_) throw std::invalid_argument("size must match"); std::copy_n(pvalue, size, pdata_); } void Matrix::clear() { std::fill_n(pdata_, n_rows_ * n_cols_, 0); } const double& Matrix::at(int i, int j) const { if(i < 0 || i > n_rows_ || j < 0 || j > n_cols_) throw std::out_of_range("i must be [0, n_rows_ - 1] and j must be [0, n_cols_ - 1]"); return pdata_[i * n_cols_ + j]; } // 待实现:返回矩阵对象索引(i,j)对应的数据项引用(越界则抛出异常) // 参考前一个接口和task3的问题2 double& Matrix::at(int i, int j) { } int Matrix::rows() const { return n_rows_; } int Matrix::cols() const { return n_cols_; } // 待实现:按行打印数据 void Matrix::print() const { } pragma once // 类Matrix声明 class Matrix { public: Matrix(int n_rows, int n_cols, double value = 0); // 构造n_rowsn_cols_矩阵对象, 初值value Matrix(int n_rows, double value = 0); // 构造n_rowsn_rows方阵对象, 初值value Matrix(const Matrix &x); // 拷贝构造(深拷贝) ~Matrix(); // 释放指针指向的内存资源 void set(const double pvalue, int size); // 按行拷贝pvalue指向的数据,要求size=rowscols,否则抛出异常 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 *pdata_; // 数据区 }; include include include include "matrix.h" 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(); return 0; } 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, 5, -1); const Matrix m2(m1); std::cout << "矩阵m1: \n"; m1.print(); std::cout << "矩阵m2: \n"; m2.print(); m1.clear(); m1.at(0, 0) = 1; m1.at(0, 1) = 2; 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()) throw std::out_of_range("row_index must in [0, m.rows()-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:暴露了非常严重的潜在风险(内存越界读取风险)。 使用现代 C++ 标准库容器(最佳实践) 将接口参数改为 const std::vector& 或 std::span(C++20)。 cpp // 使用 vector 明确传递长度 void set(const std::vector& data); // 或使用 std::span 包装指针和长度 (C++20) include void set(std::span data); 优点:彻底杜绝了裸指针越界问题。在 set 内部可以直接利用 data.size() 检查容量是否匹配矩阵所需大小,如果不够直接抛出 std::invalid_argument 异常。 实验5: 代码:#pragma once include include // 联系人类 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_; // 必填项 }; inline Contact::Contact(const std::string &name, const std::string &phone):name_{name}, phone_{phone} { } inline const std::string& Contact::get_name() const { return name_; } inline const std::string& Contact::get_phone() const { return phone_; } inline void Contact::display() const { std::cout << name_ << ", " << phone_; } pragma once include "contact.hpp" include include include include // 通讯录类 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; // 返回联系人在vector内索引,如不存在,返回-1 void sort(); // 按姓名字典序升序排序通讯录 private: std::vector contacts_; }; inline 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"; } inline 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"; } inline 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'; } inline void ContactBook::display() const { for(auto &c: contacts_) { c.display(); std::cout << '\n'; } } inline size_t ContactBook::size() const { return contacts_.size(); } // 待补足1:int index(const std::string &name) const;实现 // 返回联系人在contacts内索引; 如不存在,返回-1 // 待补足2:void ContactBook::sort();实现 // 按姓名字典序升序排序通讯录 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"); std::cout << "\n5. display contacts\n"; std::cout << "There are " << contactbook.size() << " contacts.\n"; contactbook.display(); } int main() { test(); } 截图:
inline 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; }
截图:
问题1:是组合(Composition)关系。
声明方式:在 Window 类中,buttons_ 被声明为 std::vector
生命周期管理:因为存储的是值对象,Window 对象在构造时会直接包含这些 Button 对象的内存。当 Window 对象被销毁时,buttons_ 这个 vector 也会被销毁,进而自动调用其中所有 Button 对象的析构函数。Button 的生命周期严格受限于 Window 的生命周期,这符合组合关系“同生共死”(强拥有)的特征。如果是聚合关系,通常会使用指针来存储对象,对象的生命周期可能独立于容器。 问题2:① 若将其改为公有接口,有何优点或风险?
优点:外部代码(用户)可以直接查询窗口是否包含某个特定按钮,便于实现外部逻辑判断(例如:外部逻辑根据是否含有某按钮来决定后续操作)。
风险:暴露了内部实现细节。has_button 的底层实现是遍历 buttons_(O(n) 复杂度)。如果公有化,外部频繁调用可能导致性能问题;此外,如果未来 Window 内部为了提升性能将 buttons_ 改为 std::unordered_map,虽然接口不变,但外部如果过度依赖查询行为可能会产生耦合。更严重的是,如果外部能查询状态,可能会让外部逻辑变得复杂且与 Window 内部状态紧密绑定,破坏封装性。
② 设计类时,如何决策一个成员函数应为 public 还是 private? 可以从以下几个角度分析:
用户是否需要:该函数是否是提供给外部用户完成特定业务功能的必要操作?(如 add_button, click_button 是必须的)。
是否仅为内部实现细节:该函数是否仅仅是为了辅助类内部其他公有方法而存在的?(has_button 显然只是为了辅助 add_button 去重,是内部辅助函数)。
是否易破坏对象状态:公有函数如果被误用是否会破坏类的封装性或不变量?has_button 是 const 函数,不破坏状态,但暴露了内部数据结构的大小和查找方式(时间复杂度)。隐藏内部辅助函数是良好的封装习惯。 问题3:接口1:const std::string& get_label() const;
性能:优。返回引用,不发生字符串内存的拷贝(拷贝构造),调用开销极小。
安全性:相对较低。返回的是内部成员 label_ 的引用。如果外部代码不小心保存了这个引用,而原始的 Button 对象被销毁(例如从 vector 中删除),或者 Window 对象被销毁,这个引用就会变成悬空引用(Dangling Reference),导致未定义行为(崩溃)。
接口2:std::string get_label() const;
性能:较差。返回的是一个临时值,每次调用都会发生一次字符串拷贝,如果字符串很长,会有显著的性能开销。
安全性:高。返回的是副本,外部怎么修改或持有这个返回的字符串都不会影响 Button 内部的状态,也不存在悬空引用的风险。
精炼陈述:在性能敏感且能确保返回值生命周期不超过原对象的场景下,优先使用 const std::string&;但在需要保证安全性和避免生命周期管理复杂性的现代 C++ 中,通常会选择返回值(std::string),或利用 C++17 的 std::string_view(需谨慎对待生命周期),若确实需要返回引用,应保证接口契约明确,提醒调用者不要持有引用。 问题4:把 xx.push_back(Button(xxx)) 改成 xx.emplace_back(xxx),观察程序是否正常运行;查阅资料,回答两种写法的差别。
是否正常运行:正常运行。代码逻辑完全一致。
差别:
push_back(Button(xxx)):会先在栈上(或临时对象区)构造一个临时的 Button 对象,然后将这个临时对象拷贝(或移动)到 vector 的末尾内存中,最后销毁临时对象。
emplace_back(xxx):原地构造(In-place construction)。它直接把参数 xxx(这里是 const std::string& 或 const char*)完美转发给 vector 管理的内存空间,直接在容器的末尾内存上调用 Button 的构造函数。省去了临时对象的创建和拷贝/移动的开销,效率更高。
② 用标准库改写 Window::has_button() 实现,是否可以?简述 std::any_of() 功能、参数和返回值意义。
是否可以:完全可以,且代码更简洁,符合现代 C++ 风格。
3:可以。std::find_if() 简述:
功能:在给定范围内查找第一个满足特定条件(谓词)的元素。
参数:三个参数。前两个是迭代器(first, last)表示查找区间;第三个是一个一元谓词,用于判断元素是否符合查找条件。
返回值:返回一个迭代器。如果找到了满足条件的元素,返回指向该第一个匹配元素的迭代器;如果遍历完整个区间都没有找到,则返回 last(即 buttons_.end())。
实验2: 代码: #include
void test1(); void test2(); void output1(const std::vector &v); void output2(const std::vector &v); void output3(const std::vector<std::vector>& v);
int main() { std::cout << "深复制验证1: 标准库vector\n"; test1();
std::cout << "\n深复制验证2: 标准库vector嵌套使用\n"; test2();
void test1() { std::vector v1(5, 42); const std::vector v2(v1);
std::cout << "拷贝构造后\n"; std::cout << "v1: "; output1(v1); std::cout << "v2: "; output1(v2);
v1[0] = -1;
std::cout << "修改v1[0]后\n"; std::cout << "v1: "; output1(v1); std::cout << "v2: "; output1(v2); }
void test2() { std::vector<std::vector> v1{{1, 2, 3}, {4, 5, 6, 7}}; const std::vector<std::vector> v2(v1);
std::cout << "拷贝构造后\n"; std::cout << "v1:\n"; output3(v1); std::cout << "v2:\n"; output3(v2);
v1[0].push_back(-1);
std::cout << "修改v1[0]后\n"; std::cout << "v1:\n"; output3(v1); std::cout << "v2:\n"; output3(v2); }
// 使用索引+循环,遍历输出vector数据项 void output1(const std::vector &v) { if(v.size() == 0) { std::cout << '\n'; return; }
std::cout << v[0]; for(auto i = 1; i < v.size(); ++i) std::cout << ", " << v[i]; std::cout << '\n'; }
// 使用迭代器+循环,遍历输出vector数据项 void output2(const std::vector &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>数据项 void output3(const std::vector<std::vector>& v) { if(v.size() == 0) { std::cout << '\n'; return; }
for(auto &i: v) output2(i); }
问题1:构造分析:
std::vector v1(5, 42); 完成了 填充构造函数(Fill Constructor)。它创建了一个包含 5 个元素的 vector,每个元素的值都被初始化为 42。
const std::vector v2(v1); 完成了 拷贝构造函数(Copy Constructor)。它使用已有的 v1 来初始化 v2,创建了一个 v1 的深拷贝(副本),并且 v2 被声明为 const,意味着之后不能通过 v2 修改其内部元素。
数据项数量:v1 和 v2 各包含 5 个值为 42 的数据项。 问题2:v1.size() = 2
v2.size() = 2
v1[0].size() = 3 问题3:能否实现同等效果:能。两者都会将 v1 的第一个元素修改为 -1。
区别:
边界检查(安全性):at() 会进行边界检查。如果索引越界(例如 v1.at(10) 当 v1 只有 5 个元素时),at() 会抛出 std::out_of_range 异常。而 operator[] 不进行边界检查,越界访问会导致未定义行为(通常是程序崩溃或读取到垃圾内存)。
性能:operator[] 因为省去了边界检查,理论上执行速度会略微快一点点(但在现代编译器优化下,差别往往可以忽略不计)。
使用场景:在确定索引绝对合法(如循环中遍历)时使用 [];在不确定索引是否合法,或者需要捕获错误以防崩溃时,使用 at()。 问题4:能否输出:能。
为什么:v1[0] 返回的是内层 vector 的引用。const std::vector &r = v1[0]; 使用 const 引用 r 绑定了这个内层 vector。此时 v1[0] 已经通过 push_back(-1) 变为了 {1, 2, 3, -1}。r 作为引用,实时反映了底层对象的变化。r.size() 为 4,r[3] 即最后一个元素,值为 -1。这里 const 只是限制不能通过 r 去修改它,但不影响读取。
② r 定义成用 const & 类型接收返回值,在内存使用上有何优势?有何限制?
优势:使用引用(&)接收返回值,避免了对象的拷贝。如果直接写 const std::vector r = v1[0];,会调用 vector 的拷贝构造函数,分配新的内存并复制所有元素。使用引用 const std::vector &r 仅仅是给原对象起了一个别名,不发生内存分配和拷贝,开销极小(特别是在存放大量数据的容器中非常关键)。
限制:因为 r 是引用,它的生命周期受限于原对象 v1[0] 的生命周期。如果原对象(比如外层的 v1 被销毁,或者 v1 进行了扩容导致内存重新分配),r 就会变成悬空引用(Dangling Reference),此时再访问 r 会导致未定义行为。另外,加了 const 后,只能通过 r 读取数据,不能通过 r 修改数据(如 r.push_back 或 r[0]=1 都是不允许的)。 问题5: 标准库模板类 vector 的复制构造函数实现的是深拷贝还是浅拷贝?
推断:深拷贝(Deep Copy)。
理由:从 test1 和 test2 的运行结果来看,在拷贝构造出 v2 之后,修改 v1 的内容(v1[0] = -1 或 v1[0].push_back(-1)),v2 的内容没有任何改变。如果 vector 是浅拷贝(仅复制指针),那么 v1 和 v2 将共享同一块底层数组内存,修改 v1 必然会导致 v2 也跟着变。因为互不影响,说明 vector 的拷贝构造会为新对象重新分配堆内存,并将原对象的所有元素逐一复制过去。
② vector::at() 接口思考:
当 v 是 vector 时,v.at(0) 返回值类型是 int&(整型的引用)。
当 v 是 const vector 时,v.at(0) 返回值类型是 const int&(常整型的引用)。
据此推断标准库 std::vector 的 at() 接口是否必须提供带 const 修饰的重载版本?
必须提供。因为 C++ 的 const 成员函数只能返回 const 引用(或者值),不能返回非 const 引用,否则就破坏了 const 对象的不可变性(允许通过返回值修改 const 对象)。为了让 const vector 能够调用 at() 进行只读访问,并且让非 const vector 调用 at() 时能够返回可修改的引用,标准库必须为 at() 提供两个重载版本:
reference at(size_type pos); (非 const 版本,返回 T&) const_reference at(size_type pos) const; (const 版本,返回 const T&)
实验3:#include "vectorInt.hpp"
void test1(); void test2(); void test3(); void output1(const vectorInt &vi); void output2(const vectorInt &vi);
int main() { std::cout << "测试1: 构造、更新\n"; test1();
std::cout << "\n测试2: const对象、赋值\n"; test2();
std::cout << "\n测试3: 赋值\n"; test3();
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);
y.at(0) = -1; std::cout << "x: "; output2(x); std::cout << "y: "; output2(y); }
void test3() { vectorInt x(5, 42); std::cout << "x: "; output2(x);
x.assign(x); std::cout << "x: "; output2(x); }
// 使用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'; }
// 动态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 *pdata_; // 数据区 };
inline vectorInt::vectorInt():n_{0}, pdata_{nullptr} { }
inline vectorInt::vectorInt(int n): n_{n}, pdata_{new int[n]} { }
inline vectorInt::vectorInt(int n, int value): n_{n}, pdata_{new int[n]} { for(auto i = 0; i < n_; ++i) pdata_[i] = value; }
inline vectorInt::vectorInt(const vectorInt &vi): n_{vi.n_}, pdata_{new int[n_]} { for(auto i = 0; i < n_; ++i) pdata_[i] = vi.pdata_[i]; }
inline vectorInt::~vectorInt() { delete [] pdata_; }
inline int vectorInt::size() const { return n_; }
inline const int& vectorInt::at(int index) const { if(index < 0 || index >= n_) throw std::out_of_range("vectorInt::at: index out of range");
return pdata_[index]; }
inline int& vectorInt::at(int index) { if(index < 0 || index >= n_) throw std::out_of_range("vectorInt::at: index out of range");
inline vectorInt& vectorInt::assign(const vectorInt &vi) { if(this == &vi) return *this;
int *ptr; ptr = new int[vi.n_]; for(int i = 0; i < vi.n_; ++i) ptr[i] = vi.pdata_[i];
delete[] pdata_;
n_ = vi.n_; pdata_ = ptr; return *this; }
inline int* vectorInt::begin() { return pdata_; }
inline int* vectorInt::end() { return pdata_ + n_; }
inline const int* vectorInt::begin() const { return pdata_; }
inline const int* vectorInt::end() const { return pdata_ + n_; }
问题1:运行结果有无异常:有异常。在 test3 中,x.assign(x) 会导致程序崩溃(产生未定义行为,通常是抛出段错误或内存访问违规)。
安全隐患和缺陷:
自赋值问题(Self-assignment):版本2一开始直接执行 delete[] pdata_;。如果发生自赋值(如 x.assign(x)),pdata_ 被释放,但 vi 就是 *this 自己,所以 vi.pdata_ 也同时变成了悬空指针。接下来的 new int[n_] 分配新内存后,尝试从已释放的 vi.pdata_ 读取数据,导致访问非法内存,程序崩溃。 异常安全性(Exception Safety)差:如果在 new int[n_] 时因内存不足抛出 std::bad_alloc 异常,此时原有的 pdata_ 已经被 delete[] 释放,原对象的数据被破坏且无法恢复,对象处于无效状态。 版本1(安全版本)的优越性:版本1采用了“先分配新内存,拷贝数据,再释放旧内存”的策略(Copy-and-Swap 思想的变体),完美解决了自赋值问题(靠 if(this == &vi) return *this; 提前拦截)以及异常安全问题。
问题2:① static_cast<const vectorInt*>(this) 的作用是什么?转换前后 this 的类型分别是什么?转换目的?
作用:将非 const 的 this 指针安全地转换为 const 指针。
类型变化:转换前,在非 const 成员函数中,this 的类型是 vectorInt* const(指针本身是常量,指向 vectorInt);转换后,类型变为 const vectorInt* const(指向 const vectorInt)。
转换目的:非 const 版本的 at 函数为了复用 const 版本中已经写好的边界检查逻辑,需要调用 ->at(index)。但 this 是非 const 的,而 at(index) const 是一个 const 成员函数,它要求调用者必须是一个 const 对象/指针。通过 static_cast 强转为 const 指针,就能合法地调用 const 版本的 at 函数。
② const_cast<int&> 的作用是什么?转换前后的返回类型分别是什么?转换目的?
作用:移除常量性(Cast away constness)。
类型变化:转换前,static_cast<...>(this)->at(index) 返回的是 const int&;转换后,变为 int&。
转换目的:因为非 const 版本的 at 函数的签名要求返回 int&(允许外部修改)。而 const 版本的 at 返回的是 const int&(禁止修改)。由于我们知道 this 原本就是非 const 对象(只是我们临时把它强转成 const 骗过了编译器),内部数据其实是可以修改的。使用 const_cast 去掉常属性,将原本只读的引用转成可读写的引用,从而满足返回值类型的要求。 问题3: ① 分析编译器如何选择重载版本,并总结使用场景:
auto it1 = v1.begin();:v1 是非 const 对象,编译器优先匹配非 const 成员函数,调用 int* begin();。返回 int*。
auto it2 = v2.begin();:v2 是 const 对象,编译器只能匹配 const 成员函数,调用 const int* begin() const;。返回 const int*。
总结使用场景:
非 const 版本:用于需要修改容器内元素的场景,或者容器本身是非 const 对象时。
const 版本:用于只读访问容器内元素的场景,确保即使容器是非 const 的,只要用 const 引用/指针接收迭代器,就无法通过迭代器修改数据,保证了安全性。
② 拓展思考:标准库迭代器本质上是指针的封装。这种设计让你对迭代器有什么新的理解?
理解:迭代器是泛化的指针。vectorInt 直接用原生指针作为迭代器,展示了迭代器的底层本质——提供一种类似指针的操作(如 * 解引用、++ 移动、!= 比较),来遍历和操作容器内的元素。标准库的迭代器(如 std::vector::iterator 虽然可能是类对象)只是在此基础上进行了更复杂的封装,提供了迭代器分类(如随机访问迭代器)、类型安全(防止指针类型不匹配)以及统一不同容器(链表、树)的遍历接口。它体现了 C++ 的“概念抽象”思想:不论底层数据结构是什么,只要满足迭代器协议,就可以配合算法使用。 问题4:可以。
std::fill_n(pdata_, n_, value);
功能:将从 pdata_ 开始的 n_ 个连续内存空间,全部填充为指定的 value。用于替换原始的 for 循环赋值。
std::copy(vi.pdata_, vi.pdata_ + vi.n_, pdata_);
功能:将源区间 [vi.pdata_, vi.pdata_ + vi.n_) 内的元素,逐个拷贝到以 pdata_ 为目的地址的起始位置。用于替换拷贝构造中的 for 循环。
std::copy(vi.pdata_, vi.pdata_ + vi.n_, ptr);
功能:在 assign 函数中,将源对象的数据拷贝到新申请的临时内存 ptr 中。用于替换赋值操作中的 for 循环。
注意:截图中的 assign 改写(更新3,虽然截图中只注释了 for 循环但没有写出 std::copy 语句)如果是要用 std::copy,其语法应与拷贝构造相同,即 std::copy(vi.pdata_, vi.pdata_ + vi.n_, ptr);。这 3 行更新代码本质上都是用标准库算法代替了手写的底层 for 循环,使得代码更简洁,且通常有更好的编译器优化。
实验4: 代码:
Matrix::Matrix(int n_rows, double value): Matrix(n_rows, n_rows, value) { }
// 待实现:拷贝构造(深拷贝) Matrix::Matrix(const Matrix &x) { }
// 待实现:释放指针指向的内存资源 Matrix::~Matrix() { }
void Matrix::set(const double *pvalue, int size) { if(size != n_rows_ * n_cols_) throw std::invalid_argument("size must match");
std::copy_n(pvalue, size, pdata_); }
void Matrix::clear() { std::fill_n(pdata_, n_rows_ * n_cols_, 0); }
const double& Matrix::at(int i, int j) const { if(i < 0 || i > n_rows_ || j < 0 || j > n_cols_) throw std::out_of_range("i must be [0, n_rows_ - 1] and j must be [0, n_cols_ - 1]");
return pdata_[i * n_cols_ + j]; }
// 待实现:返回矩阵对象索引(i,j)对应的数据项引用(越界则抛出异常) // 参考前一个接口和task3的问题2 double& Matrix::at(int i, int j) {
}
int Matrix::rows() const { return n_rows_; }
int Matrix::cols() const { return n_cols_; }
// 待实现:按行打印数据 void Matrix::print() const {
// 类Matrix声明 class Matrix { public: Matrix(int n_rows, int n_cols, double value = 0); // 构造n_rowsn_cols_矩阵对象, 初值value Matrix(int n_rows, double value = 0); // 构造n_rowsn_rows方阵对象, 初值value Matrix(const Matrix &x); // 拷贝构造(深拷贝) ~Matrix(); // 释放指针指向的内存资源
void set(const double pvalue, int size); // 按行拷贝pvalue指向的数据,要求size=rowscols,否则抛出异常 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 *pdata_; // 数据区 };
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, 5, -1); const Matrix m2(m1);
std::cout << "矩阵m1: \n"; m1.print(); std::cout << "矩阵m2: \n"; m2.print();
m1.clear(); m1.at(0, 0) = 1; m1.at(0, 1) = 2;
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()) throw std::out_of_range("row_index must in [0, m.rows()-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:暴露了非常严重的潜在风险(内存越界读取风险)。 使用现代 C++ 标准库容器(最佳实践) 将接口参数改为 const std::vector& 或 std::span(C++20)。
cpp // 使用 vector 明确传递长度 void set(const std::vector& data);
// 或使用 std::span 包装指针和长度 (C++20)
void set(std::span data); 优点:彻底杜绝了裸指针越界问题。在 set 内部可以直接利用 data.size() 检查容量是否匹配矩阵所需大小,如果不够直接抛出 std::invalid_argument 异常。
实验5: 代码:#pragma once
// 联系人类 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_; // 必填项 };
inline Contact::Contact(const std::string &name, const std::string &phone):name_{name}, phone_{phone} { }
inline const std::string& Contact::get_name() const { return name_; }
inline const std::string& Contact::get_phone() const { return phone_; }
inline void Contact::display() const { std::cout << name_ << ", " << phone_; }
// 通讯录类 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; // 返回联系人在vector内索引,如不存在,返回-1 void sort(); // 按姓名字典序升序排序通讯录
private: std::vector contacts_; };
inline 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"; }
inline 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"; }
inline 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'; }
inline void ContactBook::display() const { for(auto &c: contacts_) { c.display(); std::cout << '\n'; } }
inline size_t ContactBook::size() const { return contacts_.size(); }
// 待补足1:int index(const std::string &name) const;实现 // 返回联系人在contacts内索引; 如不存在,返回-1
// 待补足2:void ContactBook::sort();实现 // 按姓名字典序升序排序通讯录
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");
std::cout << "\n5. display contacts\n"; std::cout << "There are " << contactbook.size() << " contacts.\n"; contactbook.display(); }
int main() { test(); } 截图: