Hàm khởi tạo sao chép

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

Hàm khởi tạo bản sao tạo một đối tượng mới bằng cách sao chép một đối tượng hiện có. Hàm này được gọi khi bạn khởi tạo một đối tượng từ một đối tượng khác cùng kiểu, truyền một đối tượng theo giá trị hoặc trả về một đối tượng theo giá trị.

Hàm khởi tạo sao chép nhận một tham chiếu hằng đến đối tượng thuộc cùng lớp. Tham số này phải là tham chiếu: nếu truyền other theo giá trị thì bản thân thao tác đó cũng cần tạo một bản sao, khiến hàm khởi tạo sao chép được gọi lặp đi lặp lại mãi mãi. Tham số này là const vì thao tác tạo bản sao không bao giờ được thay đổi đối tượng gốc:

class Player {
    std::string name;
    int health;
public:
    Player(std::string n, int h) : name(n), health(h) {}
    
    // Hàm khởi tạo sao chép
    Player(const Player& other) {
        name = other.name;
        health = other.health;
    }
};

Player original("Hero", 100);
Player copy = original;    // Gọi hàm khởi tạo sao chép
Player another(original);  // Cũng gọi hàm khởi tạo sao chép

Nếu bạn không định nghĩa hàm khởi tạo sao chép, trình biên dịch sẽ tạo một hàm thực hiện sao chép nông: sao chép trực tiếp giá trị của từng thành viên. Cách này hoạt động tốt với các kiểu dữ liệu đơn giản, nhưng gây ra vấn đề khi lớp của bạn quản lý bộ nhớ động.

class Buffer {
    int* data;
    size_t size;
public:
    Buffer(size_t s) : size(s) {
        data = new int[size];
    }
    
    // Hàm khởi tạo sao chép sâu
    Buffer(const Buffer& other) : size(other.size) {
        data = new int[size];              // Cấp phát bộ nhớ mới
        for (size_t i = 0; i < size; i++)
            data[i] = other.data[i];       // Sao chép nội dung
    }
    
    ~Buffer() { delete[] data; }
};

Nếu không có hàm khởi tạo sao chép tùy chỉnh, cả hai đối tượng sẽ trỏ đến cùng một vùng nhớ. Khi một đối tượng bị hủy, đối tượng còn lại sẽ có con trỏ treo. Bản sao sâu cấp phát vùng nhớ mới và sao chép dữ liệu thực tế, đảm bảo mỗi đối tượng sở hữu tài nguyên riêng.

Thử thách

Dễ

Hãy xây dựng một hệ thống lưu lịch sử tin nhắn để minh họa tầm quan trọng của việc sao chép sâu (deep copy) khi lớp quản lý bộ nhớ động. Bạn sẽ tạo lớp MessageLog để lưu tin nhắn trong một mảng được cấp phát động, đồng thời triển khai hàm khởi tạo sao chép phù hợp để mỗi bản sao có vùng nhớ độc lập.

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

MessageLog.h: Định nghĩa lớp MessageLog để quản lý một tập hợp tin nhắn bằng bộ nhớ động. Lớp của bạn cần có:
- Các thành viên riêng tư: một con trỏ đến mảng chuỗi dùng để lưu tin nhắn, capacity là số tin nhắn tối đa và count là số tin nhắn hiện có
- Một hàm khởi tạo có tham số nhận sức chứa, cấp phát mảng trên heap và khởi tạo count bằng 0
- Một hàm khởi tạo sao chép thực hiện sao chép sâu: cấp phát vùng nhớ mới và sao chép tất cả tin nhắn từ đối tượng nguồn
- Một hàm hủy giải phóng vùng nhớ đã cấp phát và in ra "MessageLog destroyed"
- Một phương thức addMessage(string msg) thêm tin nhắn nếu còn chỗ
- Một phương thức getCount() trả về số tin nhắn hiện có
- Một phương thức getMessage(int index) trả về tin nhắn tại chỉ số đã cho
main.cpp: Minh họa rằng hàm khởi tạo sao chép tạo ra một bản sao độc lập. Đọc giá trị sức chứa và hai tin nhắn từ đầu vào, sau đó:
- Tạo một MessageLog có tên original với sức chứa đã nhập
- Thêm cả hai tin nhắn vào original
- Tạo một bản sao có tên backup bằng hàm khởi tạo sao chép
- Chỉ thêm tin nhắn thứ ba "New message" vào original
- In ra "Original count: <count>"
- In ra "Backup count: <count>"
- In tất cả tin nhắn từ backup, mỗi tin nhắn trên một dòng

Định dạng đầu vào sẽ là:

Dòng đầu tiên: sức chứa (số nguyên)
Dòng thứ hai: tin nhắn thứ nhất (chuỗi)
Dòng thứ ba: tin nhắn thứ hai (chuỗi)

Nếu bạn triển khai sao chép sâu đúng cách, bản sao lưu sẽ có 2 tin nhắn, còn đối tượng ban đầu có 3 tin nhắn, chứng tỏ chúng có vùng nhớ độc lập. Nếu không có hàm khởi tạo sao chép phù hợp, cả hai sẽ dùng chung một mảng và thay đổi ở đối tượng này sẽ ảnh hưởng đến đối tượng kia!

Thêm tệp tiêu đề vào main.cpp bằng #include "MessageLog.h".

Tự làm thử

#include <iostream>
#include <string>
#include "MessageLog.h"
using namespace std;

int main() {
    // Đọc đầu vào
    int capacity;
    cin >> capacity;
    cin.ignore();
    
    string msg1, msg2;
    getline(cin, msg1);
    getline(cin, msg2);

    // TODO: Tạo một MessageLog tên là 'original' với dung lượng đầu vào

    // TODO: Thêm cả hai thông điệp vào original

    // TODO: Tạo một bản sao tên là 'backup' bằng hàm khởi tạo sao chép

    // TODO: Chỉ thêm "New message" vào original

    // TODO: In ra "Original count: <count>"

    // TODO: In ra "Backup count: <count>"

    // TODO: In ra tất cả thông điệp từ backup, mỗi dòng một thông điệp

    return 0;
}