Ngữ nghĩa di chuyển và giá trị rvalue

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

Trong C++, mỗi biểu thức là một lvalue (có danh tính tồn tại lâu dài, có thể lấy địa chỉ) hoặc một rvalue (tạm thời, sắp bị hủy). Hiểu rõ sự khác biệt này sẽ giúp bạn nắm được ngữ nghĩa di chuyển, một cách tối ưu mạnh mẽ giúp tránh sao chép không cần thiết.

Tham chiếu rvalue, được khai báo bằng &&, chỉ liên kết với các đối tượng tạm thời. Nhờ vậy, bạn có thể “lấy” tài nguyên từ những đối tượng sắp biến mất:

#include <iostream>
#include <utility>

class Buffer {
    int* data;
    size_t size;
public:
    Buffer(size_t s) : data(new int[s]), size(s) {
        std::cout << "Constructed\n";
    }
    
    // Hàm khởi tạo di chuyển (move constructor): chiếm lấy tài nguyên
    Buffer(Buffer&& other) noexcept 
        : data(other.data), size(other.size) {
        other.data = nullptr;  // Giữ đối tượng nguồn ở trạng thái hợp lệ
        other.size = 0;
        std::cout << "Moved\n";
    }
    
    ~Buffer() { delete[] data; }
};

int main() {
    Buffer b1(1000);
    Buffer b2(std::move(b1));  // Kích hoạt hàm khởi tạo di chuyển
}

Hàm std::move không thực sự di chuyển bất cứ thứ gì. Nó chỉ ép kiểu lvalue thành tham chiếu rvalue, báo hiệu rằng bạn sẵn sàng từ bỏ các tài nguyên của đối tượng. Việc di chuyển thực sự diễn ra trong hàm khởi tạo di chuyển hoặc toán tử gán di chuyển.

Ngữ nghĩa di chuyển cải thiện đáng kể hiệu suất khi làm việc với các đối tượng chiếm nhiều tài nguyên như vùng chứa hoặc chuỗi. Thay vì sao chép sâu hàng megabyte dữ liệu, bạn chỉ cần chuyển quyền sở hữu con trỏ, một thao tác có thời gian thực hiện không đổi bất kể kích thước dữ liệu.

Thử thách

Dễ

Hãy xây dựng một lớp DataBuffer quản lý tài nguyên để minh họa cách ngữ nghĩa di chuyển hoạt động. Bạn sẽ thấy việc di chuyển tài nguyên thay vì sao chép có thể cải thiện đáng kể hiệu suất khi chuyển quyền sở hữu bộ nhớ được cấp phát động.

Bạn sẽ chia code thành ba tệp:

DataBuffer.h: Định nghĩa lớp DataBuffer quản lý một mảng số nguyên được cấp phát động.
Lớp của bạn cần có các thành viên riêng tư để lưu con trỏ dữ liệu (int*), kích thước (size_t) và tên (std::string) nhằm giúp theo dõi bộ đệm nào đang được thao tác.

Khai báo các thành phần sau:
- Một hàm khởi tạo nhận tên kiểu std::string và kích thước kiểu size_t, cấp phát mảng và in ra: [name] constructed with size [size]
- Một hàm khởi tạo di chuyển nhận tham chiếu giá trị phải, lấy quyền sở hữu tài nguyên và in ra: [name] moved from [source_name] (trong đó bộ đệm nhận tài nguyên sẽ lấy tên của nguồn)
- Một hàm hủy in ra [name] destroyed (hoặc empty destroyed nếu bộ đệm đã được di chuyển)
- Một phương thức getSize() trả về kích thước hiện tại
- Một phương thức getName() trả về tên của bộ đệm
Nhớ đánh dấu hàm khởi tạo di chuyển bằng noexcept và để đối tượng nguồn ở trạng thái rỗng nhưng hợp lệ (nullptr, kích thước 0, tên "empty").
DataBuffer.cpp: Cài đặt tất cả phương thức đã khai báo trong tệp tiêu đề. Khi hàm hủy chạy, chỉ xóa dữ liệu nếu con trỏ không phải null. Thêm <iostream> để in ra.
main.cpp: Đọc hai đầu vào:
1. Tên của bộ đệm (chuỗi)
2. Kích thước của bộ đệm (số nguyên)
Tạo một DataBuffer với tên và kích thước đã cho. Sau đó, tạo bộ đệm thứ hai bằng cách di chuyển từ bộ đệm thứ nhất qua std::move(). Sau khi di chuyển, in trạng thái của cả hai bộ đệm:
- Original: [name] size=[size]
- New: [name] size=[size]
Thêm <utility> để dùng std::move.

Ví dụ, với đầu vào Alpha và 100:

Alpha constructed with size 100
Alpha moved from Alpha
Original: empty size=0
New: Alpha size=100
Alpha destroyed
empty destroyed

Với đầu vào Buffer và 50:

Buffer constructed with size 50
Buffer moved from Buffer
Original: empty size=0
New: Buffer size=50
Buffer destroyed
empty destroyed

Lưu ý cách hàm khởi tạo di chuyển chuyển quyền sở hữu bộ nhớ đã cấp phát mà không sao chép dữ liệu. Bộ đệm ban đầu ở trạng thái rỗng nhưng hợp lệ. Khi cả hai bộ đệm bị hủy ở cuối chương trình, chỉ bộ đệm vẫn sở hữu bộ nhớ mới thực sự xóa bộ nhớ đó.

Tự làm thử

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

int main() {
    std::string name;
    int size;
    
    std::cin >> name;
    std::cin >> size;
    
    // TODO: Tạo DataBuffer với tên và kích thước đã cho
    
    // TODO: Tạo bộ đệm thứ hai bằng cách di chuyển từ bộ đệm thứ nhất bằng std::move()
    
    // TODO: In ra trạng thái của cả hai bộ đệm:
    // Ban đầu: [name] size=[size]
    // Mới: [name] size=[size]
    
    return 0;
}