std::string::operator=

#include <string>

// (1) Copy assignment (Gán từ một std::string khác)
string& operator= (const string& str);

// (2) Move assignment (Gán di chuyển từ một std::string khác - từ C++11)
string& operator= (string&& str) noexcept;

// (3) Gán từ một chuỗi ký tự C-style
string& operator= (const char* s);

// (4) Gán từ một ký tự
string& operator= (char c);

// (5) Gán từ một initializer list (từ C++11)
string& operator= (initializer_list<char> il);

Gán một giá trị mới cho một đối tượng std::string, thay thế nội dung hiện tại của nó.

Tham số

str

• Một tham chiếu hằng (const reference) đến đối tượng std::string nguồn. (1)
• Một tham chiếu rvalue (rvalue reference) đến đối tượng std::string nguồn. (2)

s

• Con trỏ đến một chuỗi ký tự C-style (kết thúc bằng ký tự null). (3)

c

• Ký tự cần gán. (4)

il

• Một initializer_list chứa các ký tự. (5)

Giá trị trả về

*this

• Một tham chiếu đến chính đối tượng std::string hiện tại sau khi đã thực hiện phép gán.

Đặc điểm

1. Lớp std::string cung cấp nhiều phiên bản nạp chồng (overload) của toán tử = để có thể gán giá trị từ nhiều nguồn khác nhau:
   • Một std::string khác (copy assignment và move assignment)
   • Một chuỗi ký tự C-style (const char*)
   • Một ký tự đơn (char)
   • Một initializer list (từ C++11)
2. Quản lý bộ nhớ tự động: std::string tự động quản lý bộ nhớ cần thiết để lưu trữ chuỗi ký tự. Toán tử = sẽ đảm nhiệm việc cấp phát lại bộ nhớ nếu cần thiết khi gán giá trị mới.
3. Trả về tham chiếu: Tất cả các phiên bản của toán tử = đều trả về một tham chiếu đến đối tượng std::string hiện tại (*this) sau khi đã gán xong, cho phép thực hiện gán chuỗi (chained assignment).
4. Toán tử = của std::string sẽ tự động quản lý bộ nhớ, bạn không cần phải lo lắng về việc cấp phát hay giải phóng bộ nhớ thủ công.
5. Khi sử dụng move assignment, đối tượng nguồn sẽ ở trạng thái hợp lệ nhưng không xác định.
6. Toán tử = trả về tham chiếu đến chính đối tượng std::string hiện tại, cho phép bạn thực hiện gán chuỗi (chained assignment) như str1 = str2 = str3;.
7. Mặc dù std::basic_string hỗ trợ gán từ một phạm vi (range) thông qua constructor hoặc hàm assign(), toán tử = không hỗ trợ gán trực tiếp từ một phạm vi iterator.
8. Các phiên bản operator= có thể ném ra ngoại lệ, ví dụ như std::bad_alloc nếu không thể cấp phát đủ bộ nhớ, hoặc std::length_error nếu độ dài kết quả vượt quá max_size().
9. Phiên bản move assignment (5) được đánh dấu là noexcept, nghĩa là nó được đảm bảo không ném ra ngoại lệ.

Ví dụ

#include <iostream>
#include <string>

int main() {
  std::string str1 = "Hello";
  std::string str2;

  str2 = str1;             // Copy assignment
  std::cout << "str2: " << str2 << std::endl;

  str2 = std::move(str1);  // Move assignment
  std::cout << "str2 after move: " << str2 << std::endl;
  std::cout << "str1 after move: " << str1 << std::endl; // str1 có thể rỗng

  str2 = "World";         // Gán từ chuỗi ký tự C-style
  std::cout << "str2: " << str2 << std::endl;

  str2 = '!';             // Gán từ một ký tự
  std::cout << "str2: " << str2 << std::endl;

  str2 = {'1', '2', '3'}; // Gán từ initializer list
  std::cout << "str2: " << str2 << std::endl;

  return 0;
}

Các hàm liên quan

assign	Gán nội dung mới cho chuỗi, thay thế nội dung hiện tại của nó
operator+=	Nối thêm nội dung vào cuối chuỗi hiện tại
insert	Chèn thêm nội dung (ký tự, chuỗi, hoặc phạm vi) vào bên trong chuỗi tại một vị trí xác định
replace	Thay thế một phần của chuỗi bằng một nội dung mới
compare	So sánh chuỗi hiện tại với một chuỗi khác