Quy tắc 3 / 5 / 0

Thuộc phần Lập trình hướng đối tượng trong hành trình C++ của Coddy. Bài học 25 trên 104.

Khi lớp của bạn quản lý các tài nguyên như bộ nhớ động, bạn đã học rằng mình cần có hàm hủy, hàm khởi tạo sao chép và hàm khởi tạo di chuyển tùy chỉnh. Nhưng có một nguyên tắc giúp bạn quyết định nên triển khai những hàm thành viên đặc biệt nào: Quy tắc ba, năm và không.

Quy tắc ba nêu rằng: nếu bạn định nghĩa một trong ba thành phần sau, bạn nên định nghĩa cả ba:

Hàm hủy
Hàm khởi tạo sao chép
Toán tử gán sao chép

Quy tắc năm mở rộng điều này cho C++ hiện đại, bổ sung các thao tác di chuyển:

Hàm hủy
Hàm khởi tạo sao chép
Toán tử gán sao chép
Hàm khởi tạo di chuyển
Toán tử gán di chuyển

class Buffer {
    int* data;
    size_t size;
public:
    Buffer(size_t s) : size(s), data(new int[s]) {}
    
    ~Buffer() { delete[] data; }                          // 1. Hàm hủy
    Buffer(const Buffer& other);                          // 2. Hàm khởi tạo sao chép
    Buffer& operator=(const Buffer& other);               // 3. Phép gán sao chép
    Buffer(Buffer&& other) noexcept;                      // 4. Hàm khởi tạo di chuyển
    Buffer& operator=(Buffer&& other) noexcept;           // 5. Phép gán di chuyển
};

Cả hai toán tử gán đều tuân theo cùng một mẫu: kiểm tra để tránh tự gán, giải phóng tài nguyên cũ, nhận tài nguyên mới rồi trả về *this:

Buffer& Buffer::operator=(const Buffer& other) {   // Phép gán sao chép
    if (this != &other) {
        delete[] data;
        size = other.size;
        data = new int[size];
        std::copy(other.data, other.data + size, data);
    }
    return *this;
}

Buffer& Buffer::operator=(Buffer&& other) noexcept {   // Phép gán di chuyển
    if (this != &other) {
        delete[] data;
        data = other.data;
        size = other.size;
        other.data = nullptr;
        other.size = 0;
    }
    return *this;
}

Quy tắc số không (Rule of Zero) là cách tiếp cận đơn giản nhất: nếu lớp (class) của bạn không trực tiếp quản lý tài nguyên, đừng định nghĩa bất kỳ hàm (function) nào trong số này. Hãy để trình biên dịch tự tạo chúng, hoặc dùng con trỏ thông minh và bộ chứa chuẩn để quản lý tài nguyên thay bạn.

class Player {
    std::string name;              // std::string tự quản lý bộ nhớ của mình
    std::vector<int> scores;       // std::vector tự quản lý tài nguyên của mình
public:
    Player(std::string n) : name(n) {}
    // Không cần hàm hủy, hàm sao chép hay hàm di chuyển!
};

Tuân theo các quy tắc này giúp tránh bug như xóa hai lần, rò rỉ bộ nhớ và con trỏ treo xảy ra khi một số thao tác đã được định nghĩa nhưng những thao tác khác lại bị thiếu.

Thử thách

Dễ

Hãy tạo một lớp TextBuffer tuân theo Quy tắc năm hàm đặc biệt: triển khai cả năm hàm thành viên đặc biệt để quản lý đúng dữ liệu ký tự được cấp phát động. Qua đó, bạn sẽ thấy các thao tác sao chép và di chuyển phối hợp với nhau như thế nào để tạo nên một lớp quản lý tài nguyên vững chắc.

Bạn sẽ tạo hai tệp để sắp xếp code:

TextBuffer.h: Định nghĩa lớp TextBuffer lưu trữ văn bản trong một mảng ký tự được cấp phát động. Lớp của bạn cần có:
- Các thành viên riêng tư: con trỏ char* tên là data để lưu nội dung văn bản, và size_t length để lưu độ dài chuỗi, không tính ký tự kết thúc null
- Một hàm khởi tạo có tham số nhận chuỗi C (const char*), cấp phát bộ nhớ, sao chép nội dung và in ra "TextBuffer created: <text>"
- Một hàm hủy giải phóng bộ nhớ nếu con trỏ không phải null và in ra "TextBuffer destroyed"
- Một hàm khởi tạo sao chép thực hiện sao chép sâu và in ra "TextBuffer copied"
- Một toán tử gán sao chép xử lý phép gán cho chính nó, dọn dẹp dữ liệu hiện có, thực hiện sao chép sâu và in ra "TextBuffer copy-assigned". Trả về *this
- Một hàm khởi tạo di chuyển (được đánh dấu noexcept) chuyển quyền sở hữu và in ra "TextBuffer moved". Để đối tượng nguồn ở trạng thái rỗng hợp lệ
- Một toán tử gán di chuyển (được đánh dấu noexcept) xử lý phép gán cho chính nó, dọn dẹp dữ liệu hiện có, chuyển quyền sở hữu và in ra "TextBuffer move-assigned". Trả về *this
- Một phương thức getText() trả về văn bản đã lưu (trả về chuỗi rỗng "" nếu data là null)
- Một phương thức getLength() trả về độ dài
main.cpp: Minh họa hoạt động của cả năm hàm thành viên đặc biệt. Đọc một chuỗi văn bản từ đầu vào, sau đó:
- Tạo một TextBuffer tên là original với văn bản đầu vào
- Tạo copied bằng hàm khởi tạo sao chép từ original
- Tạo another với văn bản "Temporary"
- Dùng phép gán sao chép: another = original
- Tạo moved bằng cách gọi hàm khởi tạo di chuyển với nguồn là original, sử dụng std::move()
- Tạo target với văn bản "Target"
- Dùng phép gán di chuyển: target = std::move(copied)
- In ra "--- Final State ---"
- In ra "original: <text> (length: <len>)" cho từng bộ đệm: original, copied, moved, another, target

Sau các thao tác di chuyển, các đối tượng nguồn (original và copied) sẽ hiển thị văn bản rỗng với độ dài 0, còn các đối tượng đích sẽ chứa dữ liệu được chuyển đến. Qua đó, bạn sẽ thấy Quy tắc năm hàm đặc biệt hoạt động như thế nào: cả năm hàm phối hợp với nhau để đảm bảo quản lý tài nguyên an toàn.

Thêm <cstring> để dùng các hàm xử lý chuỗi như strlen và strcpy, và <utility> để dùng std::move().

Tự làm thử

#include <iostream>
#include <string>
#include <utility>
#include "TextBuffer.h"

using namespace std;

int main() {
    string input;
    getline(cin, input);

    // TODO: Tạo một TextBuffer tên là 'original' với văn bản đầu vào

    // TODO: Tạo 'copied' bằng hàm khởi tạo sao chép từ 'original'

    // TODO: Tạo 'another' với văn bản "Temporary"

    // TODO: Dùng phép gán sao chép: another = original

    // TODO: Tạo 'moved' bằng hàm khởi tạo di chuyển từ 'original', dùng std::move()

    // TODO: Tạo 'target' với văn bản "Target"

    // TODO: Dùng phép gán di chuyển: target = std::move(copied)

    // TODO: In ra "--- Final State ---"

    // TODO: In ra trạng thái của từng vùng đệm theo định dạng sau:
    // "original: <text> (length: <len>)"
    // In ra cho: original, copied, moved, another, target

    return 0;
}