实验3 类和对象_基础编程2

实验任务1：

实验代码：

button.hpp:

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

实验截图：

 

问题1：

自定义的类：
Button：用于表示一个按钮，包含按钮的标签和点击行为。
Window：用于表示一个窗口，包含窗口的标题和一系列按钮。

使用到的标准库类：
std::string：用于处理和存储字符串数据。
std::vector：用于动态数组的管理，这里用来存储窗口中的按钮。
std::cout和 std::endl：用于输出流，方便调试和显示信息。

组合关系：
Window类中包含了一个 `std::vector<Button>成员变量 buttons，这表明 Window类和 Button 类之间存在组合关系。具体来说，一个 `Window` 对象可以拥有多个 `Button` 对象，而这些 `Button` 对象的生命周期依赖于 `Window` 对象。

问题2：

现有的成员函数修饰符：
Button::get_label被声明为 const，表示该方法不会修改对象的状态。
Button::click没有被声明为 const，因为理论上它可能会改变对象的状态（虽然在这个例子中它只是输出信息）。
Window::display 被声明为 const，表示该方法不会修改对象的状态。
Window::close没有被声明为 const，因为它调用了 `Button::click`，而 `Button::click` 可能会修改对象的状态。
Window::add_button 没有被声明为 `const`，因为它会修改 `Window` 对象的状态。

建议添加 `const` 和 `inline` 的成员函数：

1. Button::click 添加 const：
理由：当前 `Button::click` 只是输出一条消息，并没有修改 `Button` 对象的状态。因此，它可以被声明为 `const`。

2. Window::close`添加 `const`：
理由：虽然 `Window::close` 调用了 `Button::click`，但如果 `Button::click` 被声明为 `const`，那么 `Window::close` 也可以被声明为 `const`。

3. Window::add_button不适合添加 const：
理由：`Window::add_button` 修改了 `Window` 对象的状态（即向 `buttons` 向量中添加了一个新的 `Button` 对象），因此不能被声明为 `const`。

4. Window::display 保持 `const`：
理由：`Window::display` 不修改 `Window` 对象的状态，因此保持 `const` 是合适的。

5. Button::get_label`保持 `const`：
理由：`Button::get_label` 不修改 `Button` 对象的状态，因此保持 `const` 是合适的。

6. Button::click` 设置为 `inline`：
理由：`Button::click` 是一个非常简单的函数，通常适合内联以提高性能。

7. Window::display` 设置为 `inline`：
理由：`Window::display` 也是一个相对简单的函数，适合内联以提高性能。

问题3：

这行代码的功能是创建一个包含40个星号（`*`）的字符串 `s`。具体来说，`string s(40, '*');` 使用了 `std::string` 的构造函数，该构造函数接受两个参数：第一个参数是要创建的字符数，第二个参数是要重复的字符。因此，这行代码的结果是一个长度为40的字符串，每个字符都是星号。

在 `Window::display` 方法中，这个字符串被用来在输出中创建一个分隔线，以便更清晰地显示窗口的信息。具体作用如下：
创建分隔线：在窗口信息的顶部和底部各打印一行40个星号，形成一个视觉上的分隔线。
增强可读性：通过分隔线，使得窗口标题和按钮列表的显示更加清晰，便于用户阅读和理解。

总结：

问题一：

1. 自定义类：`Button` 和 `Window`。
2. 使用到的标准库类：`std::string`、`std::vector`、`std::cout` 和 `std::endl`。
3. 组合关系：`Window` 类和 `Button` 类之间存在组合关系。
问题二：

4. 成员函数的 `const` 和 `inline` 修饰符：
`Button::click` 可以添加 `const` 并设置为 `inline`。
`Window::close` 可以添加 `const`。
`Window::display` 已经是 `const`，可以设置为 `inline`。
Window::add_button`不能添加 `const`。
问题三：

5. `string s(40, '*');` 的功能：创建一个包含40个星号的字符串，用于在输出中创建分隔线，增强可读性。

 

实验任务2：

实验代码：

task2.cpp:

 

实验截图：

问题1

这三行代码的功能分别是：

1. `vector<int> v1(5, 42);`
这行代码创建了一个名为 `v1` 的 `vector<int>` 对象，该对象包含 5 个整数，每个整数的初始值都是 42。`v1` 的内容将是 `[42, 42, 42, 42, 42]`。

2. `const vector<int> v2(v1);`
这行代码使用 `v1` 的内容来初始化一个名为 `v2` 的常量 `vector<int>` 对象。`v2` 将成为 `v1` 的一个副本，但因为它是常量，所以其内容不能被修改。`v2` 的内容也将是 `[42, 42, 42, 42, 42]`。

3. `v1.at(0) = -999;`
 这行代码通过 `at(0)` 方法访问 `v1` 中索引为 0 的元素，并将其值设置为 -999。`at()` 方法提供了边界检查，如果索引超出范围，则会抛出 `std::out_of_range` 异常。修改后，`v1` 的内容变为 `[-999, 42, 42, 42, 42]`。

问题2

这三行代码的功能分别是：

1. `vector<vector<int>> v1{{1, 2, 3}, {4, 5, 6, 7}};`
- 这行代码创建了一个名为 `v1` 的二维 `vector<int>` 对象，其中包含了两个子向量，第一个子向量包含 1, 2, 3，第二个子向量包含 4, 5, 6, 7。`v1` 的内容将是 `[[1, 2, 3], [4, 5, 6, 7]]`。

2. `const vector<vector<int>> v2(v1);`
这行代码使用 `v1` 的内容来初始化一个名为 `v2` 的常量二维 `vector<int>` 对象。`v2` 将成为 `v1` 的一个副本，但因为它是常量，所以其内容不能被修改。`v2` 的内容也将是 `[[1, 2, 3], [4, 5, 6, 7]]`。

3. `v1.at(0).push_back(-999);`
这行代码首先通过 `at(0)` 访问 `v1` 的第一个子向量，然后调用 `push_back(-999)` 方法将 -999 添加到该子向量的末尾。`push_back` 方法用于在向量的末尾添加一个新元素。修改后，`v1` 的内容变为 `[[1, 2, 3, -999], [4, 5, 6, 7]]`。

问题3

这四行代码的功能分别是：

1. `vector<int> t1 = v1.at(0);`
这行代码通过 `at(0)` 访问 `v1` 的第一个子向量，并将其赋值给一个新的 `vector<int>` 对象 `t1`。`t1` 成为了 `v1` 第一个子向量的一个副本。`t1` 的内容将是 `[1, 2, 3, -999]`。

2. `cout << t1.at(t1.size()-1) << endl;`
这行代码打印 `t1` 的最后一个元素。因为 `t1` 是 `v1` 第一个子向量的副本，而 `v1` 的第一个子向量在前面已经通过 `push_back` 添加了 -999，所以这行代码会输出 -999。

3. `const vector<int> t2 = v2.at(0);`
这行代码通过 `at(0)` 访问 `v2` 的第一个子向量，并将其赋值给一个新的常量 `vector<int>` 对象 `t2`。`t2` 成为了 `v2` 第一个子向量的一个副本，但由于 `v2` 是常量，`t2` 也是常量。`t2` 的内容将是 `[1, 2, 3]`。

4. `cout << t2.at(t2.size()-1) << endl;`
 这行代码打印 `t2` 的最后一个元素。因为 `t2` 是 `v2` 第一个子向量的副本，而 `v2` 的内容没有被修改过，所以这行代码会输出 3（即 `v2` 第一个子向量的最后一个元素）。

问题4

根据执行结果，反向分析、推断：

1. 标准库模板类 `vector` 内部封装的复制构造函数，其实现机制是深复制还是浅复制？
从 `test1` 和 `test2` 的输出结果可以看出，当 `v1` 被修改时，`v2` 的内容没有受到影响。这表明 `vector` 的复制构造函数实现了深复制。如果实现的是浅复制，那么修改 `v1` 会影响到 `v2`，因为它们会共享同一个内存区域。因此，`vector` 的复制构造函数实现的是深复制。

2. 模板类 `vector` 的接口 `at()`，是否至少需要提供一个 `const` 成员函数作为接口？
 是的，`vector` 的 `at()` 方法确实提供了 `const` 成员函数版本。这是为了允许在常量对象上安全地访问元素。在 `test2` 中，`v2` 是一个常量 `vector`，但仍然可以使用 `at()` 方法来访问其元素，这说明 `at()` 方法有 `const` 版本。这样设计的好处是可以确保在常量对象上不会发生意外的修改。因此，`vector` 的 `at()` 方法至少需要提供一个 `const` 成员函数作为接口。

实验任务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:

 

实验截图：

 问题1：

深复制。

分析：
在`vectorInt`类的复制构造函数中，首先创建了一个新的数组`ptr{new int[size]}`，然后将源对象的每个元素复制到新分配的数组中。这种实现方式确保了两个对象的数据是完全独立的，即使一个对象的数据发生变化，也不会影响另一个对象的数据。因此，这是一个深复制的例子。

问题2：

返回值类型改为int： 测试代码可能无法正确运行。
原因：当`at()`方法返回一个`int`类型的值时，它返回的是数组中元素的一个副本。这意味着对返回值的任何修改都不会影响原始数组中的数据。这将导致无法通过`at()`方法修改数组中的元素，从而可能导致某些功能失效，如`test1`中的`x2.at(0) = -999;`将不起作用。
去掉const：存在潜在的安全隐患。
原因：如果将`const int& at(int index) const`的返回值类型前面的`const`去掉，那么即使是在常量对象上调用此方法，也能通过返回的引用修改数组中的数据。这破坏了常量对象的不可变性原则，可能导致意外的行为或错误。

问题3：

不可以。

分析：
原因：assign()`方法通常用于将一个对象的内容替换为另一个对象的内容，并且通常设计为链式调用的一部分，即允许连续调用多个方法。例如，`obj1.assign(obj2).someMethod();`。为了支持这样的链式调用，`assign()`方法需要返回当前对象的引用`*this`，而不是一个新的`vectorInt`对象。如果返回类型改为`vectorInt`，则每次调用`assign()`都会创建并返回一个新的`vectorInt`对象，这不仅增加了内存开销，而且破坏了链式调用的可能性。此外，这样做也不符合C++中常见容器类（如`std::vector`）的设计模式。

实验任务4：

实验代码：

matrix.hpp:

#pragma once

#include <iostream>
#include <cassert>
#include <cstring> // 用于memcpy


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的实现：待补足


Matrix::Matrix(int n, int m) : lines(n), cols(m) {
    ptr = new double[lines * cols];
    clear();
}

Matrix::Matrix(int n) : Matrix(n, n) {}

Matrix::Matrix(const Matrix& x) : lines(x.lines), cols(x.cols) {
    ptr = new double[lines * cols];
    memcpy(ptr, x.ptr, lines * cols * sizeof(double));
}

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

void Matrix::set(const double* pvalue) {
    memcpy(ptr, pvalue, lines * cols * sizeof(double));
}

void Matrix::clear() {
    memset(ptr, 0, lines * cols * sizeof(double));
}

const double& Matrix::at(int i, int j) const {
    assert(i >= 0 && i < lines && j >= 0 && j < cols);
    return ptr[i * cols + j];
}

double& Matrix::at(int i, int j) {
    assert(i >= 0 && i < lines && j >= 0 && j < cols);
    return ptr[i * cols + j];
}

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 << at(i, j) << " ";
        }
        cout << endl;
    }
}

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>


class User {
private:
    std::string name;
    std::string password;
    std::string email;

public:
    // 构造函数
    User(const std::string& name, const std::string& password = "123456", const std::string& email = "");

    // 设置邮箱
    void set_email();

    // 修改密码
    void change_password();

    // 显示用户信息
    void display() const;

private:
    // 检查邮箱是否合法
    bool is_valid_email(const std::string& email) const;

    // 检查密码是否正确
    bool check_password(const std::string& input) const;
};

// 构造函数
User::User(const std::string& name, const std::string& password, const std::string& email)
    : name(name), password(password), email(email) {}

// 设置邮箱
void User::set_email() {
    std::string new_email;std::cout << "Enter email address: ";
    do {
        std::cin >> new_email;
        if (!is_valid_email(new_email)) {
            std::cout << "illegal email. Please re-enter email:"; 
        }
        else {
            email = new_email;
            std::cout << "email is set successfully…\n";
            break;
        }
    } while (true);
}

// 修改密码
void User::change_password() {
    int attempts = 0;
    std::string old_password;
    do {
        std::cout << "Enter old password: ";
        std::cin >> old_password;
        if (check_password(old_password)) {
            std::string new_password;
            std::cout << "Enter new password: ";
            std::cin >> new_password;
            password = new_password;
            std::cout << "new password is set successfully…\n";
            return;
        }
        else {
            std::cout << "passsword inpit error. Please re-enter again.";
            attempts++;
        }
        if (attempts >= 3) {
            std::cout << "passsword inpit error. Please try again after a while.\n";
            return;
        }
    } while (true);
}

// 显示用户信息
void User::display() const {
    std::cout << "name:  " << name << "\n";
    std::cout << "pass:  ";
    for (size_t i = 0; i < password.length(); ++i) {
        std::cout << "*";
    }
    std::cout << "\n";
    std::cout << "email: " << email << "\n";
}


// 检查邮箱是否合法
bool User::is_valid_email(const std::string& email) const {
    return email.find('@') != std::string::npos;
}

// 检查密码是否正确
bool User::check_password(const std::string& input) const {
    return input == password;
}

task5.cpp:

// task5.cpp

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

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

//以下test1、2为测试
using namespace std;
// 测试1
void test1() {
    string s1{ "hello" };
    string s2(s1.size(), '*'); // 构造字符串对象s2, 包含和s1长度相同的*
    cout << "s1: " << s1 << endl;
    cout << "s2: " << s2 << endl;
}
// 测试2
void test2() {
    vector<string> v{ "xyz@gmail.com", "xyz.gmail.com" };
    bool is_valid;
    for (auto& s : v) {
        auto pos = s.find("@"); // 在字符串对象s中查找子串@, 如果找到，返回位置索引npos；否则, 返回常量值npos
            if (pos == s.npos)
                is_valid = false;
            else
                is_valid = true;
        cout << s << "\t" << boolalpha << is_valid << endl;
    }
}

void test() {
    vector<User> user_lst;

    User u1("Alice", "2024113", "Alice@hotmail.com");
    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() {
    cout << "测试1:" << endl;
    test1();
    cout << "\n测试2:" << endl;
    test2();
    test(); }

实验截图：

 

实验任务6：

实验代码：

date.h:

 

date.cpp:

 

account.h:

 

account.cpp:

 

6_25.cpp:

 

实验截图：