Nạp chồng toán tử gán

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 44 trên 104.

toán tử gán bản sao (=) được gọi khi bạn gán một đối tượng hiện có cho một đối tượng khác. Khác với hàm khởi tạo bản sao (tạo một đối tượng mới), toán tử gán hoạt động với một đối tượng đã tồn tại và có thể có tài nguyên cần được dọn dẹp trước.

class Buffer {
    int* data;
    size_t size;
    
public:
    Buffer(size_t s) : size(s), data(new int[s]) {}
    ~Buffer() { delete[] data; }
    
    Buffer& operator=(const Buffer& other) {
        if (this != &other) {              // 1. Kiểm tra trường hợp tự gán
            delete[] data;                  // 2. Giải phóng tài nguyên hiện có
            size = other.size;              // 3. Sao chép dữ liệu
            data = new int[size];
            for (size_t i = 0; i < size; ++i)
                data[i] = other.data[i];
        }
        return *this;                       // 4. Trả về *this
    }
};

Phép kiểm tra tự gán (this != &other) rất quan trọng. Nếu không có phép kiểm tra này, b = b; sẽ xóa dữ liệu trước khi cố sao chép, dẫn đến hành vi không xác định.

Toán tử trả về *this theo dạng tham chiếu để hỗ trợ phép gán nối tiếp như a = b = c;. Cách này phù hợp với hành vi của các kiểu dữ liệu dựng sẵn.

Với các lớp quản lý tài nguyên, bạn thường sẽ triển khai cả toán tử gán sao chép và toán tử gán di chuyển:

Buffer& operator=(Buffer&& other) noexcept {
    if (this != &other) {
        delete[] data;           // Giải phóng tài nguyên hiện tại
        data = other.data;       // Chiếm quyền sở hữu tài nguyên
        size = other.size;
        other.data = nullptr;    // Giữ đối tượng nguồn ở trạng thái hợp lệ
        other.size = 0;
    }
    return *this;
}

Toán tử gán di chuyển chuyển quyền sở hữu thay vì sao chép, giúp các thao tác như vec[0] = createBuffer(); hiệu quả hơn nhiều.

Thử thách

Dễ

Hãy tạo một lớp DynamicString để quản lý mảng ký tự được cấp phát động và xử lý đúng cách việc gán giữa các đối tượng đã tồn tại. Đây là tình huống thực tế, trong đó bạn cần chuyển dữ liệu chuỗi an toàn từ đối tượng này sang đối tượng khác mà không gây rò rỉ bộ nhớ hoặc con trỏ treo.

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

DynamicString.h: Định nghĩa lớp DynamicString lưu trữ chuỗi kiểu C bằng bộ nhớ động. Lớp của bạn cần quản lý:
- Một con trỏ char* riêng tư để lưu dữ liệu chuỗi
- Một size_t riêng tư để lưu độ dài
- Một hàm khởi tạo nhận const char* và tạo một bản sao sâu
- Một hàm hủy giải phóng đúng cách bộ nhớ đã cấp phát
- Một toán tử gán sao chép tạo bản sao sâu và xử lý trường hợp tự gán
- Một toán tử gán di chuyển chuyển quyền sở hữu một cách hiệu quả
- Một phương thức c_str() trả về chuỗi nội bộ (const)
- Một phương thức length() trả về độ dài chuỗi (const)
Toán tử gán sao chép cần thực hiện đủ bốn bước thiết yếu: kiểm tra trường hợp tự gán, dọn dẹp tài nguyên hiện có, sao chép dữ liệu mới và trả về *this. Toán tử gán di chuyển cần lấy con trỏ từ đối tượng nguồn và để đối tượng nguồn ở trạng thái rỗng hợp lệ (nullptr với độ dài 0).
main.cpp: Đọc ba chuỗi từ đầu vào (mỗi chuỗi trên một dòng riêng). Tạo ba đối tượng DynamicString: str1 với đầu vào thứ nhất, str2 với đầu vào thứ hai và str3 với đầu vào thứ ba.
Minh họa các toán tử gán:
1. In trạng thái ban đầu của cả ba chuỗi
2. Dùng toán tử gán sao chép: str1 = str2;
3. In str1 và str2 sau khi gán sao chép (cả hai phải có cùng nội dung)
4. Dùng toán tử gán di chuyển: str2 = std::move(str3);
5. In str2 sau khi gán di chuyển và độ dài của str3 (phải là 0 sau khi di chuyển)
Định dạng đầu ra:
```
Initial:
str1: <value>
str2: <value>
str3: <value>
After copy (str1 = str2):
str1: <value>
str2: <value>
After move (str2 = std::move(str3)):
str2: <value>
str3 length: 0
```

Dùng <cstring> cho strlen và strcpy. Đánh dấu toán tử gán di chuyển bằng noexcept. Thêm <utility> vào main.cpp để dùng std::move. Đừng quên các header guard trong tệp header.

Tự làm thử

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

using namespace std;

int main() {
    // Đọc ba chuỗi từ đầu vào
    string input1, input2, input3;
    getline(cin, input1);
    getline(cin, input2);
    getline(cin, input3);

    // Tạo ba đối tượng DynamicString
    DynamicString str1(input1.c_str());
    DynamicString str2(input2.c_str());
    DynamicString str3(input3.c_str());

    // TODO: In ra trạng thái ban đầu của cả ba chuỗi
    // Định dạng:
    // Initial:
    // str1: <value>
    // str2: <value>
    // str3: <value>

    // TODO: Dùng phép gán sao chép: str1 = str2;

    // TODO: In ra str1 và str2 sau phép gán sao chép
    // Định dạng:
    // After copy (str1 = str2):
    // str1: <value>
    // str2: <value>

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

    // TODO: In ra str2 sau khi di chuyển và độ dài của str3
    // Định dạng:
    // After move (str2 = std::move(str3)):
    // str2: <value>
    // str3 length: 0

    return 0;
}