实验任务1

button.cpp源码

#pragma once

#include <iostream>
#include <string>

using std::string;
using std::cout;

// 按钮类
class Button {
public:
    Button(const string &text);
    string get_label() const;
    void click();

private:
    string label;
};

Button::Button(const string &text): label{text} {
}

inline string Button::get_label() const {
    return label;
}

void Button::click() {
    cout << "Button '" << label << "' clicked\n";
}

window.hpp源码

#pragma once
#include "button.hpp"
#include <vector>
#include <iostream>

using std::vector;
using std::cout;
using std::endl;

// 窗口类
class Window{
public:
    Window(const string &win_title);
    void display() const;
    void close();
    void add_button(const string &label);

private:
    string title;
    vector<Button> buttons;
};

Window::Window(const string &win_title): title{win_title} {
    buttons.push_back(Button("close"));
}

inline void Window::display() const {
    string s(40, '*');

    cout << s << endl;
    cout << "window title: " << title << endl;
    cout << "It has " << buttons.size() << " buttons: " << endl;
    for(const auto &i: buttons)
        cout << i.get_label() << " button" << endl;
    cout << s << endl;
}

void Window::close() {
    cout << "close window '" << title << "'" << endl;
    buttons.at(0).click();
}

void Window::add_button(const string &label) {
    buttons.push_back(Button(label));
}

task1.cpp源码

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

using std::cout;
using std::cin;

void test() {
    Window w1("new window");
    w1.add_button("maximize");
    w1.display();
    w1.close();
}

int main() {
    cout << "用组合类模拟简单GUI:\n";
    test();
}

运行结果截图

问题一：

这个模拟简单GUI的示例代码中，自定义了几个类？使用到了标准库的哪几个类？，哪些
类和类之间存在组合关系？

自定义了以下两个类：
Button 类：表示一个简单的按钮，具有标签和点击操作。
Window 类：表示一个窗口，可以包含多个按钮，并提供显示和关闭窗口的功能。

用到了标准库的以下3个类：
std::string：用于存储文本字符串。
std::vector：用于存储按钮的集合，使得按钮能够动态数量增加。
std::cout：用于输出文本到标准输出。

类和类之间的组合关系如下：
Window 类中包含 Button 类的实例，具体实现是通过 vector Button buttons 成员变量。表示 Window 类具有多个 Button 对象，Window 类和 Button 类之间存在组合关系。Window 是一个组合类，Button 是被组合的类。

问题二：

在自定义类Button和Window中，有些成员函数定义时加了const, 有些设置成了inline。如
果你是类的设计者，目前那些没有加const或没有设置成inline的，适合添加const，适合设置成
inline吗？陈述你的答案和理由。

不适合.
没有添加const的成员函数它们的状态可能改变，不适合加入const.
没有添加inline的成员函数它们的功能和实现都并不复杂，不适合内联。
函数标记的const与inline取决于其逻辑复杂性和是否会更改对象的状态。

问题三：

类Window的定义中，有这样一行代码，其功能是？

string s(40, ''); 的功能是创建一个 string 类型的对象 s，其内容由 40 个重复的字符 '' 组成。
使用了 string 类的构造函数，其中第一个参数 40 指定了字符串的长度，第二个参数 '*' 指定了要填充的字符。因此，执行这行代码后，s 将是一个包含 40 个星号的字符串。这个字符串常用于在 display 方法中作为视觉分隔线，使输出更加美观和易读。

实验任务2

task2.cpp源码

#include <iostream>
#include <vector>

using namespace std;

void output1(const vector<int> &v) {
    for(auto &i: v)
        cout << i << ", ";
    cout << "\b\b \n";
}

void output2(const vector<vector<int>> v) {
    for(auto &i: v) {
        for(auto &j: i)
            cout << j << ", ";
        cout << "\b\b \n";
    }
}

void test1() {
    vector<int> v1(5, 42);
    const vector<int> v2(v1);

    v1.at(0) = -999;
    cout << "v1: ";  output1(v1);
    cout << "v2: ";  output1(v2);
    cout << "v1.at(0) = " << v1.at(0) << endl;
    cout << "v2.at(0) = " << v2.at(0) << endl;
}

void test2() {
    vector<vector<int>> v1{{1, 2, 3}, {4, 5, 6, 7}};
    const vector<vector<int>> v2(v1);

    v1.at(0).push_back(-999);
    cout << "v1: \n";  output2(v1);
    cout << "v2: \n";  output2(v2);

    vector<int> t1 = v1.at(0);
    cout << t1.at(t1.size()-1) << endl;
    
    const vector<int> t2 = v2.at(0);
    cout << t2.at(t2.size()-1) << endl;
}

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

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

运行结果截图

问题一：

测试1模块中，这三行代码的功能分别是？

vector v1(5, 42);
创建一个名为 v1 的整数向量,其大小为5，所有元素初始化42。
vector v2(v1);
创建一个名为 v2 的整数向量，并用 v1 的内容进行初始化。此时，v2 也会有 5 个元素，所有元素的值均为 42。
v1.at(0) = -999;
将 v1 向量的第一个元素（索引为 0）修改为 -999。这不会影响 v2，因为 v2 是根据 v1 的初始状态复制的。

问题二：

测试2模块中，这三行代码的功能分别是？

vector<vector> v1{{1, 2, 3}, {4, 5, 6, 7}};
功能：创建一个二维整数向量 v1，并初始化为包含两个子向量：第一个子向量为 {1, 2, 3}，第二个子向量为 {4, 5, 6, 7}。
const vector<vector> v2(v1);
功能：创建一个常量的二维整数向量 v2，并用 v1 的内容初始化。这表示 v2 是 v1 的一个副本，修改 v1 不会影响 v2。
v1.at(0).push_back(-999);
功能：向 v1 的第一个子向量（即 {1, 2, 3}）添加元素 -999。这会将 v1 的第一个子向量修改为 {1, 2, 3, -999}，而 v2 保持不变，仍为原始的数据。

问题三：

测试2模块中，这四行代码的功能分别是？

vector t1 = v1.at(0);
功能：获取 v1 的第一个子向量（现在是 {1, 2, 3, -999}），并将其赋值给整数向量 t1。此时，t1 包含 v1 的第一个子向量的所有元素。
cout << t1.at(t1.size()-1) << endl;
功能：输出 t1 的最后一个元素。由于 t1 是从 v1 获取的，而 v1 的第一个子向量的最后一个元素是 -999，所以下面的输出将是 -999。
const vector t2 = v2.at(0);
功能：获取 v2 的第一个子向量（保持不变的 {1, 2, 3}），并将其赋值给常量整数向量 t2。t2 是 v2 的第一个子向量的副本。
cout << t2.at(t2.size()-1) << endl;
功能：输出 t2 的最后一个元素。t2 包含 {1, 2, 3}，因此输出将是 3。

问题四：

根据执行结果，反向分析、推断：
标准库模板类vector内部封装的复制构造函数，其实现机制是深复制还是浅复制？
模板类vector的接口at(), 是否至少需要提供一个const成员函数作为接口？

在C++标准库中，vector 的复制构造函数采用深复制的实现机制。当使用一个 vector 初始化另一个 vector 时，所有的元素都会被复制到新的 vector 中，并且两个 vector 之间不会共享元素的存储空间。在 test1 中，当修改 v1 的元素（例如，将 v1.at(0) 设置为 -999），v2 的内容不会受到影响，仍然保持初始化时的值（42）。、

是，模板类 vector 的接口 at() 至少需要提供一个 const 成员函数作为接口。这样可以确保可以安全地访问 vector 中的元素，即使是在 const 对象上使用。如果有一个 const vector 对象，通过 at() 方法访问其中的元素，此时需要提供 const 重载的 at() 方法，以保证对元素的读取是安全的。

实验任务3

vectorInt.hpp源码

#pragma once

#include <iostream>
#include <cassert>

using std::cout;
using std::endl;

// 动态int数组对象类
class vectorInt{
public:
    vectorInt(int n);
    vectorInt(int n, int value);
    vectorInt(const vectorInt &vi);
    ~vectorInt();

    int& at(int index);
    const int& at(int index) const;

    vectorInt& assign(const vectorInt &v);
    int get_size() const;

private:
    int size;
    int *ptr;       // ptr指向包含size个int的数组
};

vectorInt::vectorInt(int n): size{n}, ptr{new int[size]} {
}

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

vectorInt::vectorInt(const vectorInt &vi): size{vi.size}, ptr{new int[size]} {
    for(auto i = 0; i < size; ++i)
        ptr[i] = vi.ptr[i];
}

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

const int& vectorInt::at(int index) const {
    assert(index >= 0 && index < size);

    return ptr[index];
}

int& vectorInt::at(int index) {
    assert(index >= 0 && index < size);

    return ptr[index];
}

vectorInt& vectorInt::assign(const vectorInt &v) {  
    delete[] ptr;       // 释放对象中ptr原来指向的资源

    size = v.size;
    ptr = new int[size];

    for(int i = 0; i < size; ++i)
        ptr[i] = v.ptr[i];

    return *this;
}

int vectorInt::get_size() const {
    return size;
}

task3.cpp源码

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

using std::cin;
using std::cout;

void output(const vectorInt &vi) {
    for(auto i = 0; i < vi.get_size(); ++i)
        cout << vi.at(i) << ", ";
    cout << "\b\b \n";
}


void test1() {
    int n;
    cout << "Enter n: ";
    cin >> n;

    vectorInt x1(n);
    for(auto i = 0; i < n; ++i)
        x1.at(i) = i*i;
    cout << "x1: ";  output(x1);

    vectorInt x2(n, 42);
    vectorInt x3(x2);
    x2.at(0) = -999;
    cout << "x2: ";  output(x2);
    cout << "x3: ";  output(x3);
}

void test2() {
    const vectorInt  x(5, 42);
    vectorInt y(10, 0);

    cout << "y: ";  output(y);
    y.assign(x);
    cout << "y: ";  output(y);
    
    cout << "x.at(0) = " << x.at(0) << endl;
    cout << "y.at(0) = " << y.at(0) << endl;
}

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

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

运行结果截图

问题一：

vectorInt类中，复制构造函数（line14)的实现，是深复制还是浅复制？

vectorInt 类中的复制构造函数（vectorInt::vectorInt(const vectorInt &vi)) 实现的是 深复制。

问题二：

vectorInt类中，这两个at()接口，如果返回值类型改成int而非int&（相应地，实现部分也
同步修改），测试代码还能正确运行吗？如果把line18返回值类型前面的const掉，针对这个测试
代码，是否有潜在安全隐患？尝试分析说明。

改变 at() 返回 int 将使查找更安全，但失去直接修改数组元素的能力。
移除 const 会导致在 const 对象上进行不当修改的风险，并破坏 const 的初衷，从而引发潜在的安全问题。

问题三：

vectorInt类中，assign()接口，返回值类型可以改成vectorInt吗？你的结论，及，原因分
析。

将 assign() 的返回值类型改为 vectorInt 是语法上可行的，但不建议这样做，因为它会改变函数的设计意图（不再支持链式调用）并带来性能上的开销。保持返回类型为 vectorInt&（即引用）更符合 C++ 的设计原则，并能保持该方法的灵活性和效率。

实验任务4

Matrix.hpp源码：

#pragma once

#include <iostream>
#include <cassert>

using std::cout;
using std::endl;

// 类Matrix的声明
class Matrix {
public:
    Matrix(int n, int m);           // 构造函数，构造一个n*m的矩阵, 初始值为value
    Matrix(int n);                  // 构造函数，构造一个n*n的矩阵, 初始值为value
    Matrix(const Matrix &x);        // 复制构造函数， 使用已有的矩阵X构造
    ~Matrix();

    void set(const double *pvalue);         // 用pvalue指向的连续内存块数据按行为矩阵赋值
    void clear();                           // 把矩阵对象的值置0
    
    const double& at(int i, int j) const;   // 返回矩阵对象索引(i,j)的元素const引用
    double& at(int i, int j);               // 返回矩阵对象索引(i,j)的元素引用
    
    int get_lines() const;                  // 返回矩阵对象行数
    int get_cols() const;                   // 返回矩阵对象列数

    void display() const;                    // 按行显示矩阵对象元素值

private:
    int lines;      // 矩阵对象内元素行数
    int cols;       // 矩阵对象内元素列数
    double *ptr;
};

// 类Matrix的实现：待补足
// xxx
Matrix::Matrix(int n, int m) {
    lines = n;
    cols = m;
    ptr = new double[n * m];
}
Matrix::Matrix(int n) {
    lines = n;
    cols = n;
    ptr = new double[n*n];
}
Matrix::Matrix(const Matrix& x) {
    lines = x.lines;
    cols = x.cols;
    ptr = new double[lines*cols];
    for (int i = 0; i <lines*cols; i++) {
        ptr[i] = x.ptr[i];

    }

}
Matrix::~Matrix() {
    delete []ptr;
} 
void Matrix::set(const double* pvalue) {
    for (int i = 0; i < cols * lines; i++) {
        ptr[i] = pvalue[i];
    }
}
void Matrix::clear() {
    for (int i = 0; i < cols * lines; i++) {
        ptr[i] = 0;
    }
}
const double& Matrix::at(int i, int j)const {
    return ptr[j*lines+i];
}
double& Matrix::at(int i, int j) {
    return ptr[j * lines + i];
}
int Matrix::get_lines()const{
    return lines;
}
int Matrix::get_cols()const {
    return cols;
}
void Matrix::display() const{
    for (int i = 0; i < lines; i++) {
        for (int j = 0; j < cols; j++) {


            cout << ptr[i * cols + j] << ", " ;
      
        }
        cout << "\b\b \n";
 
    }
}

task4.cpp源码:

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

using std::cin;
using std::cout;
using std::endl;


const int N = 1000;

// 输出矩阵对象索引为index所在行的所有元素
void output(const Matrix &m, int index) {
    assert(index >= 0 && index < m.get_lines());

    for(auto j = 0; j < m.get_cols(); ++j)
        cout << m.at(index, j) << ", ";
    cout << "\b\b \n";
}


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

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

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

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

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

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

void test2() {
    Matrix m1(2, 3);
    m1.clear();
    
    const Matrix m2(m1);
    m1.at(0, 0) = -999;

    cout << "m1.at(0, 0) = " << m1.at(0, 0) << endl;
    cout << "m2.at(0, 0) = " << m2.at(0, 0) << endl;
    cout << "矩阵对象m1第0行: "; output(m1, 0);
    cout << "矩阵对象m2第0行: "; output(m2, 0);
}

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

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

运行测试截图

实验任务5

User.hpp源码:

#pragma once

#include<iostream>
#include<string>
#include<vector>
using namespace std;
class User {
public:
    User(const string& n, const string& p = "123456", const string& e = "");
    void set_email();
    void change_password();
    void display()const;
private:
    string name;
    string password;
    string email;

};
User::User(const string& n, const string& p, const  string& e) {
    name = n;
    password = p;
    email = e;
}
void User::set_email() {
    cout << "Enter email address:";
    string em;
    cin >> em;
    while (1) {
        if (em.find('@') == string::npos)
        {
            cout << "illegal email.Please re-enter email:";
            cin >> em;
        }
        else {
            email = em;
            cout << "email is set sucessfully..." << endl;
            break;
        }
    }
}
void User::change_password() {
    cout << "Enter old password: ";
    string ppassword;
    string newpassword;
    cin >> ppassword;
    int h = 1;
    while(h<3) {
        if (password == ppassword) {
            cout << "Enter newpassword:";

            cin >> newpassword;
            password = newpassword;
            cout << "new password is set sucessfully..." << endl;
            break;
        }
        else
        {
            cout << "password input error.Please re-enter again: ";
            cin >> ppassword;
            h++;
        }
    }
    if (h == 3)cout << "password input error.Please try after a while" << endl;
}
void User::display() const {
    cout << "name:   " << name << endl;
    cout << "pass:   ";
    for (int i = 0; i < password.length(); i++)
        cout << "*";
    cout << endl;
    cout << "email:  " << email << endl;

}

task5.cpp源码

#include "user.hpp"
#include <iostream>
#include <vector>
#include <string>

using std::cin;
using std::cout;
using std::endl;
using std::vector;
using std::string;

void test() {
    vector<User> user_lst;

    User u1("Alice", "2024113", "[email protected]");
    user_lst.push_back(u1);
    cout << endl;

    User u2("Bob");
    u2.set_email();
    u2.change_password();
    user_lst.push_back(u2);
    cout << endl;

    User u3("Hellen");
    u3.set_email();
    u3.change_password();
    user_lst.push_back(u3);
    cout << endl;

    cout << "There are " << user_lst.size() << " users. they are: " << endl;
    for (auto& i : user_lst) {
        i.display();
        cout << endl;
    }
}

int main() {
    test();
}

运行测试截图

实验任务6

date.h源码

#pragma once
#ifndef   DATE H
#define  DATE H
class Date {
private:
    int year;
    int month;
    int day;
    int totalDays;
public:
    Date(int year, int month, int day);
    int getYear()const { return year; }
    int getMonth()const { return month; }
    int getDay()const { return day; }
    int getMaxDay()const;
    bool isLeapYear()const {
        return year % 4 == 0 && year % 100 != 0 || year % 400 == 0;
    }
    void show()const;
    int distance(const Date& date)const {
        return totalDays - date.totalDays;
    }
};
#endif //DATE H

date.cpp源码

#include"date.h"
#include<iostream>
#include<cstdlib>
using namespace std;
namespace {
    const int DAYS_BEFORE_MONTH[] = { 0,31,59,90,120,151,181,212,243,273,304,334,365 };
}
Date::Date(int year, int month, int day) :year{ year }, month{ month }, day{ day } {
    if (day <= 0 || day > getMaxDay()) {
        cout << "Invalid date:";
        show();
        cout << endl;
        exit(1);
    }
    int years = year - 1;
    totalDays = years * 365 + years / 4 - years / 100 + years / 400 + DAYS_BEFORE_MONTH[month - 1] + day;
    if (isLeapYear() && month > 2)totalDays++;
}
int Date::getMaxDay()const {
    if (isLeapYear() && month == 2)
        return 29;
    else
        return DAYS_BEFORE_MONTH[month] - DAYS_BEFORE_MONTH[month - 1];
}
void Date::show()const {
    cout << getYear() << "-" << getMonth() << "-" << getDay();
}

account.h源码

#pragma once
#ifndef  ACCOUNT H
#define  ACCOUNT H
#include"date.h"
#include<string>
class SavingsAccount {
private:
    std::string id;
    double balance;
    double rate;
    Date lastDate;
    double accumulation;
    static double total;

    void record(const Date& date, double amount, const std::string& desc);

    void error(const std::string& msg)const;

    double accumulate(const Date& date)const {
        return accumulation + balance * date.distance(lastDate);
    }
public:
    SavingsAccount(const Date& date, const std::string& id, double rate);
    const std::string& getId()const { return id; }
    double getBalance()const { return balance; }
    double getRate()const { return rate; }
    static double getTotal() { return total; }

    void deposit(const Date& date, double amount, const std::string& desc);

    void withdraw(const Date& date, double amount, const std::string& desc);

    void settle(const Date& date);

    void show()const;
};
#endif//  ACCOUNT H

account.cpp源码

#include"account.h"
#include<iostream>
#include<cmath>
using namespace std;
double SavingsAccount::total = 0;

SavingsAccount::SavingsAccount(const Date& date, const string& id, double rate) :id{ id }, balance{ 0 }, rate{ rate }, lastDate{ date }, accumulation{ 0 } {
    date.show();
    cout << "\t#" << id << "created" << endl;
}

void SavingsAccount::record(const Date& date, double amount, const string& desc) {
    accumulation = accumulate(date);
    lastDate = date;
    amount = floor(amount * 100 + 0.5) / 100;
    balance+= amount;
    total += amount;
    date.show();
    cout << "\t#" << id << "\t" << amount << "\t" << balance << "\t" << desc << endl;
}

void SavingsAccount::error(const string& msg)const {
    cout << "Error(#" << id << "):" << msg << endl;
}

void SavingsAccount::deposit(const Date& date, double amount, const string& desc) {
    record(date, amount, desc);
}

void SavingsAccount::withdraw(const Date& date, double amount, const string& desc) {
    if (amount > getBalance())
        error("not enough money");
    else
        record(date, -amount, desc);
}

void SavingsAccount::settle(const Date& date) {
    double interest = accumulate(date) * rate / date.distance(Date(date.getYear() - 1, 1, 1));
    if (interest != 0)
        record(date, interest, "interest");
    accumulation = 0;
}

void SavingsAccount::show()const {
    cout << id << "\tBalance:" << balance;
}

6_25.cpp源码

#include"account.h"
#include<iostream>
using namespace std;
int main() {
    Date date(2008, 11, 1);

    SavingsAccount accounts[] = {
        SavingsAccount(date,"03755217",0.015),SavingsAccount(date,"02342342",0.015)
    };
    const int n = sizeof(accounts) / sizeof(SavingsAccount);

    accounts[0].deposit(Date(2008, 11, 5), 5000, "salary");
    accounts[1].deposit(Date(2008, 11, 25), 10000, "sell stock 0323");

    accounts[0].deposit(Date(2008, 12, 5), 5500, "salary");
    accounts[1].withdraw(Date(2008, 12, 20), 4000, "buy a laptop");

    cout << endl;
    for (int i = 0; i < n; i++) {
        accounts[i].settle(Date(2009, 1, 1));
        accounts[i].show();
        cout << endl;
    }
    cout << "Total:" << SavingsAccount::getTotal() << endl;
    return 0;
}

运行测试截图