实验3
实验3
任务1
1.源代码
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_;
};
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";
}
window.hpp
点击查看代码
#pragma once
#include "button.hpp"
#include <iostream>
#include <vector>
#include <algorithm>
// 窗口类
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<Button> 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;
}
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();
return 0;
}
2.运行截图

3.问题回答
问题1:
- 是组合关系,在声明std::vector< Button> buttons_ 中,采用的是值类型,并且当windows对象被创建时,buttons_也随之创建,buttons_的生命周期完全受windows控制,说明是组合关系。
问题2:
- 如果改成公有接口,优点是外部对象可以直接使用has_button了,风险是暴露了Window类内部的东西,has_button属于window类内部具体实现的细节,判断该窗口内是否有某个按钮,不应该暴露在外。
- 设计类时,从用户是否需要来看,如果用户需要显式地操作这个功能,那就是public,如果只是内部实现,用private;从是否仅为内部实现细节来看,一个成员函数如果仅是内部实现细节,就比如这里的has_button判断是否有这个按钮,就可以用private
问题3:
- 接口1是引用返回,接口2是值返回。在性能上,接口1不会进行深拷贝,减少了内存的分配,并且引用返回效率是比较高的,开销小;在安全性上,值返回的是副本,复制了一个字符串,外部怎么修改都不会影响原对象,这里接口1为了不让外部修改内部用了const &,接口2在安全性上较佳。
问题4:
-
改之后可以正常运行,push_back():先创建一个Button临时对象,再将这个对象复制或移动到vector容器中,emplace_back()直接在vector容器中构造Button,而没有显式地创建临时对象。我查阅了cppreference,里面给了一个示例,输出结果如下,可以发现用push_back()的话多输出一行I am being moved.意思就是它会多调用一个移动构造函数,它需要传入一个已经构造好的对象。
![task1-1]()
-
用标准库改写window::has_button()是可以运行的,std::any_of用于判断指定范围内是否至少有一个元素满足给定条件,接受的参数是两个迭代器和一个Lambda表达式,返回值是如果至少有一个元素满足条件就是true,否则为false。在这里也是实现查找是否有某个按钮的作用。

- 用标准库改写window::click_button()也是可以运行的,std::find_if()的功能是在指定范围内查找第一个满足给定条件的元素,接受的参数是两个迭代器和一个Lambda表达式,如果找到就返回true,未找到false

任务2
1.源代码
task2
点击查看代码
#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();
return 0;
}
void test1() {
std::vector<int> v1(5, 42);
const std::vector<int> 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<int>> v1{{1, 2, 3}, {4, 5, 6, 7}};
const std::vector<std::vector<int>> 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<int>数据项
void output1(const std::vector<int> &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<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);
}
2.运行截图

3.问题回答
问题1:
- 第一行使用vector的填充构造函数,有5个42;第二行使用复制构造函数,也有5个42。
问题2:
- v1.size()=2,v2.size()=2,v1[0].size()=3
问题3:
- 写成 v1.at(0) = -1;可以实现同等效果,区别在于at()成员函数有越界检查功能,安全性更高,直接用下标访问的话速度上有优势
问题4:
- 可以输出-1,v1[0].push_back(-1)将-1放在了第一个内层vector的末尾,然后再用常量引用r绑定到v1[0],r.size()-1获取最后一个元素下标,再用r[]访问。
- 使用const &接收对象,优点是可以避免复制整个vector,减少内存占用,减小开销;限制在于不能修改对象,而且需要保证原对象的生命周期
问题5
- 标准库模板类vector的复制构造函数实现的是深拷贝,因为可以看到修改v1[0]后,v2不改变,说明各自有独立存储空间;对于嵌套vector,即std::vector<std::vector
> v1而言内部的vector也会调用自己的复制构造函数 - 当 v 是 vector
时, v.at(0) 返回值类型是int &,当 v 是 const
vector时, v.at(0) 返回值类型是const int &。所以标准库std::vector的at()接口是否必须提供带const修饰的重载版本,否则如果是一个const vector对象就没有办法调用了。
任务3
1、源代码
vectorInt.hpp
点击查看代码
#pragma once
#include <iostream>
#include <stdexcept>
// 动态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_;
}
task3.cpp
点击查看代码
#include "vectorInt.hpp"
#include <iostream>
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';
}
2、运行截图

3、问题回答
问题1:
- 两段代码的差异在于,原来的代码是先申请新内存并完成数据复制,再释放原来的内存,版本2则是反过来的,然后版本1还有对地址是否相同的判断。观察两次输出可得,test3()在版本2中会输出垃圾值,说明版本2有安全隐患,具体体现在我先把原来的内存释放掉之后,没有对pdata_里面的元素进行初始化,然后再进行自赋值,读取时会产生未定义行为。运行截图如下:

问题2:
- static_cast<const vectorInt*>(this)的作用是将this指针转换成指向const对象的指针,转换前只是一个指向非const对象的指针,因为at()有两个重载,分别是int& at(int index);和const int& at(int index) const;这种转换明确指示了要用const的at()
- const_cast<int&>作用在于去除引用类型中的const限定,转换前是const int&,转换后成为int&,目的是返回一个可以修改的整数引用。
问题3:
- v1是非const对象,因此编译器优先选择int* begin();,v2是const对象,因此编译器选择const int* begin() const;非const版本在需要修改内容的场景下使用,比如遍历并修改元素这种,const版本就是不允许修改,在类似只读这种场景下使用。
- 拓展:我自己的一些理解是普通的指针就可以是迭代器,标准库迭代器为使用者提供了统一的访问方式
问题4:
- 更新1:作用是代替之前的手动for循环,用填充实现动态数组的初始化
- 更新2:替代原来的复制循环,实现的功能是复制数组元素,仍然维持深拷贝功能
- 更新3:替换手动循环,进行数据复制
任务4:
1、源代码
matrix.h
点击查看代码
#pragma once
// 类Matrix声明
class Matrix {
public:
Matrix(int n_rows, int n_cols, double value = 0); // 构造n_rows*n_cols_矩阵对象, 初值value
Matrix(int n_rows, double value = 0); // 构造n_rows*n_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; // 返回矩阵对象行数
int cols() const; // 返回矩阵对象列数
void print() const; // 按行打印数据
private:
int n_rows_; // 矩阵对象内元素行数
int n_cols_; // 矩阵对象内元素列数
double *pdata_; // 数据区
};
matrix.cpp
点击查看代码
#include "matrix.h"
#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <stdexcept>
Matrix::Matrix(int n_rows, int n_cols, double value)
: n_rows_{n_rows}, n_cols_{n_cols}, pdata_{new double[n_rows*n_cols]} {
std::fill_n(pdata_, n_rows*n_cols, value);
}
Matrix::Matrix(int n_rows, double value): Matrix(n_rows, n_rows, value) {
}
// 待实现:拷贝构造(深拷贝)
Matrix::Matrix(const Matrix &x):n_rows_{x.n_rows_},n_cols_{x.n_cols_},pdata_{new double[x.n_rows_*x.n_cols_]}{
std::copy_n(x.pdata_,n_rows_*n_cols_,pdata_);
}
// 待实现:释放指针指向的内存资源
Matrix::~Matrix() {
delete[] pdata_;
}
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) {
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];
}
int Matrix::rows() const {
return n_rows_;
}
int Matrix::cols() const {
return n_cols_;
}
// 待实现:按行打印数据
void Matrix::print() const {
int i,j;
for(i=0;i<n_rows_;i++)
{
for(j=0;j<n_cols_;j++)
{
if(j>0)
std::cout << ", " ;
std::cout << at(i,j);
}
std::cout << '\n';
}
}
task4.cpp
点击查看代码
#include <cstdlib>
#include <iostream>
#include <stdexcept>
#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';
}
2、运行截图

3、问题回答
- set接口只能检查传入的size是否与矩阵元素个数一致,比如传入2 3,那么矩阵需要6个元素,传入的set是6,这两个数字一定是相等的,但是数组的实际长度不一定相等,此时copy_n尝试读取6个元素,但只有5个,会发生数组越界。
- 可以改成std::vector接口,vector容器对象自己记录元素数量,用x.size()就可以返回当前容器中实际包含的元素数量
任务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_; // 必填项
};
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_;
}
contactbook.hpp
点击查看代码
# pragma once
#include "contact.hpp"
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
// 通讯录类
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<Contact> 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
inline int ContactBook::index(const std::string &name) const{
for(int i=0;i<contacts_.size();i++)
{
if(contacts_[i].get_name()==name)
return i;
}
return -1;
}
// 待补足2:void ContactBook::sort();实现
// 按姓名字典序升序排序通讯录
inline void ContactBook::sort(){
std::sort(contacts_.begin(),contacts_.end(),[](const Contact &a,const Contact &b){return a.get_name()<b.get_name();});
}
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");
std::cout << "\n5. display contacts\n";
std::cout << "There are " << contactbook.size() << " contacts.\n";
contactbook.display();
}
int main() {
test();
}
2、运行截图

实验总结
- task4小小的疑问:判断是否越界是否应用if(i < 0 || i >= n_rows_ || j < 0 || j >= n_cols_)呢,虽然结果暂不影响


浙公网安备 33010602011771号