實驗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:

實驗截圖：