std::string::assign

#include <string>

// (1) Gán một chuỗi string khác (copy assignment)
string& assign( const string& str );

// (2) Gán một chuỗi string khác (move assignment) (C++11)
string& assign( string&& str );

// (3) Gán một phần của chuỗi string khác
string& assign( const string& str, size_type subpos, size_type sublen = npos );

// (4) Gán một chuỗi ký tự C-style
string& assign( const charT* s );

// (5) Gán một phần của chuỗi ký tự C-style
string& assign( const charT* s, size_type n );

// (6) Gán một ký tự lặp lại nhiều lần
string& assign( size_type n, charT c );

// (7) Gán một phạm vi (range) (C++11)
template< class InputIt >
string& assign( InputIt first, InputIt last );

// (8) Gán một initializer list (C++11)
string& assign( std::initializer_list<charT> ilist );

Gán nội dung mới cho chuỗi, thay thế nội dung hiện tại của nó. Nó cung cấp nhiều tùy chọn linh hoạt để gán giá trị cho chuỗi, bao gồm gán từ một chuỗi khác, một chuỗi ký tự C-style, một phần của chuỗi, một ký tự lặp lại nhiều lần, một phạm vi (range) được xác định bởi iterator, hoặc một initializer list.

Tham số

str

• Chuỗi std::string nguồn (phiên bản 1, 2, 3).

subpos

• Vị trí bắt đầu của chuỗi con trong str cần gán (phiên bản 3).

sublen

• Số lượng ký tự cần gán từ chuỗi con trong str, bắt đầu từ subpos (phiên bản 3). Nếu sublen lớn hơn số ký tự còn lại từ subpos, hoặc nếu sublen là std::string::npos (giá trị mặc định), toàn bộ phần còn lại của str tính từ subpos sẽ được gán.

s

• Con trỏ đến chuỗi ký tự C-style (kết thúc bằng ký tự null) cần gán (phiên bản 4, 5).

n

• Số lượng ký tự đầu tiên từ chuỗi ký tự C-style s cần gán (phiên bản 5).
• Số lần lặp lại ký tự c (phiên bản 6).

c

• Ký tự cần gán (phiên bản 6).

first

• Input Iterator trỏ đến phần tử đầu tiên trong phạm vi cần gán (phiên bản 7).

last

• Input Iterator trỏ đến phần tử ngay sau phần tử cuối cùng trong phạm vi cần gán (phiên bản 7).

ilist

• initializer_list chứa các ký tự cần gán (phiên bản 8).

Giá trị trả về

*this

• 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. assign() thay đổi trực tiếp nội dung của chuỗi, không tạo ra một chuỗi mới.
2. std::string 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ớ khi sử dụng assign().
3. assign() có thể làm thay đổi size() và capacity() của chuỗi.
4. Nếu assign() gây ra việc cấp phát lại bộ nhớ, nó có thể làm vô hiệu hóa (invalidate) tất cả các iterator, con trỏ và tham chiếu đến các phần tử của chuỗi.
5. Các phiên bản của assign() có thể ném ra ngoại lệ nếu có lỗi xảy ra (ví dụ: std::bad_alloc nếu không thể cấp phát đủ bộ nhớ, std::length_error nếu độ dài kết quả vượt quá max_size()).
6. Phiên bản move assignment (2) (từ C++11) thường hiệu quả hơn copy assignment (1) vì nó di chuyển dữ liệu thay vì sao chép.
7. Phiên bản sử dụng initializer list (8) (từ C++11) cung cấp một cách tiện lợi để gán các giá trị ký tự tĩnh cho chuỗi.
8. assign() thường được sử dụng để:
   • Gán nội dung mới cho một chuỗi, thay thế hoàn toàn nội dung cũ.
   • Khởi tạo một chuỗi với giá trị xác định.
   • Sao chép một phần của chuỗi này sang chuỗi khác.
   • Tạo một chuỗi mới từ một chuỗi ký tự C-style hoặc một initializer list.
   • Gán một ký tự lặp lại nhiều lần cho chuỗi.

Ví dụ

#include <iostream>
#include <string>
#include <vector>

int main() {
  std::string str;

  // (1) Gán một chuỗi string khác (copy assignment)
  std::string str1 = "Hello";
  str.assign(str1);
  std::cout << "str after assign(str1): " << str << std::endl;

  // (2) Gán một chuỗi string khác (move assignment)
  std::string str2 = "World";
  str.assign(std::move(str2));
  std::cout << "str after assign(std::move(str2)): " << str << std::endl;
  // str2 ở trạng thái không xác định sau khi move

  // (3) Gán một phần của chuỗi string khác
  std::string str3 = "!!!Example!!!";
  str.assign(str3, 3, 7); // Gán 7 ký tự từ vị trí 3 của str3
  std::cout << "str after assign(str3, 3, 7): " << str << std::endl;

  // (4) Gán một chuỗi ký tự C-style
  str.assign("C-string example");
  std::cout << "str after assign(\"C-string example\"): " << str << std::endl;

  // (5) Gán một phần của chuỗi ký tự C-style
  const char* cstr = "*****";
  str.assign(cstr, 3); // Gán 3 ký tự đầu của cstr
  std::cout << "str after assign(cstr, 3): " << str << std::endl;

  // (6) Gán một ký tự lặp lại nhiều lần
  str.assign(4, '*'); // Gán 4 dấu sao
  std::cout << "str after assign(4, '*'): " << str << std::endl;

  // (7) Gán một phạm vi (range)
  std::vector<char> vec = {'a', 'b', 'c'};
  str.assign(vec.begin(), vec.end());
  std::cout << "str after assign(vec.begin(), vec.end()): " << str << std::endl;

  // (8) Gán một initializer list
  str.assign({'1', '2', '3'});
  std::cout << "str after assign({'1', '2', '3'}): " << str << std::endl;

  return 0;
}

Các hàm liên quan

=	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ó
append	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