Giới thiệu
C ++ xử lý các biến của các loại do người dùng định nghĩa với ngữ nghĩa giá trị . Điều này có nghĩa là các đối tượng được sao chép hoàn toàn trong các bối cảnh khác nhau và chúng ta nên hiểu "sao chép một đối tượng" thực sự có nghĩa là gì.
Chúng ta hãy xem xét một ví dụ đơn giản:
class person
{
std::string name;
int age;
public:
person(const std::string& name, int age) : name(name), age(age)
{
}
};
int main()
{
person a("Bjarne Stroustrup", 60);
person b(a); // What happens here?
b = a; // And here?
}
(Nếu bạn bối rối bởi name(name), age(age)phần này, đây được gọi là danh sách khởi tạo thành viên .)
Chức năng thành viên đặc biệt
Sao chép một personđối tượng có nghĩa là gì? Các mainchức năng cho thấy hai kịch bản sao chép khác nhau. Việc khởi tạo person b(a);được thực hiện bởi hàm tạo sao chép . Công việc của nó là xây dựng một đối tượng mới dựa trên trạng thái của một đối tượng hiện có. Việc chuyển nhượng b = ađược thực hiện bởi toán tử gán sao chép . Công việc của nó nói chung phức tạp hơn một chút, vì đối tượng mục tiêu đã ở trong một số trạng thái hợp lệ cần được xử lý.
Vì chúng tôi tự khai báo cả hàm tạo sao chép cũng như toán tử gán (cũng không phải hàm hủy), chúng được định nghĩa ngầm cho chúng tôi. Trích dẫn từ tiêu chuẩn:
[...] sao chép hàm tạo và toán tử gán sao chép, [...] và hàm hủy là các hàm thành viên đặc biệt. [ Lưu ý : Việc triển khai sẽ ngầm khai báo các hàm thành viên này cho một số loại lớp khi chương trình không khai báo rõ ràng chúng.
Việc thực hiện sẽ ngầm định nghĩa chúng nếu chúng được sử dụng. [...] ghi chú cuối ] [n3126.pdf phần 12 §1]
Theo mặc định, sao chép một đối tượng có nghĩa là sao chép các thành viên của nó:
Hàm tạo sao chép được định nghĩa ngầm định cho lớp không liên kết X thực hiện một bản sao thành viên của các tiểu dự án của nó. [n3126.pdf phần 12.8 §16]
Toán tử gán sao chép được định nghĩa ngầm định cho lớp không liên kết X thực hiện gán sao chép thành viên của các tiểu dự án của nó. [n3126.pdf phần 12.8 §30]
Định nghĩa ngầm
Các hàm thành viên đặc biệt được định nghĩa ngầm định persontrông như thế này:
// 1. copy constructor
person(const person& that) : name(that.name), age(that.age)
{
}
// 2. copy assignment operator
person& operator=(const person& that)
{
name = that.name;
age = that.age;
return *this;
}
// 3. destructor
~person()
{
}
Sao chép thành viên là chính xác những gì chúng ta muốn trong trường hợp này:
namevà ageđược sao chép, vì vậy chúng ta có được một personđối tượng độc lập, độc lập . Hàm hủy được định nghĩa ngầm luôn trống. Điều này cũng tốt trong trường hợp này vì chúng tôi không có được bất kỳ tài nguyên nào trong hàm tạo. Các hàm hủy của các thành viên được gọi ngầm sau khi hàm personhủy kết thúc:
Sau khi thực thi phần thân của hàm hủy và phá hủy bất kỳ đối tượng tự động nào được phân bổ trong phần thân, một hàm hủy cho lớp X gọi các hàm hủy cho các thành viên [...] trực tiếp của X [n3126.pdf 12.4 §6]
Quản lý tài nguyên
Vậy khi nào chúng ta nên khai báo các hàm thành viên đặc biệt một cách rõ ràng? Khi lớp của chúng ta quản lý một tài nguyên , nghĩa là khi một đối tượng của lớp chịu trách nhiệm về tài nguyên đó. Điều đó thường có nghĩa là tài nguyên được thu nhận trong hàm tạo (hoặc được truyền vào hàm tạo) và được giải phóng trong hàm hủy.
Chúng ta hãy quay ngược thời gian để chuẩn C ++. Không có điều gì như vậy std::string, và các lập trình viên đã yêu con trỏ. Các personlớp có thể nhìn như thế này:
class person
{
char* name;
int age;
public:
// the constructor acquires a resource:
// in this case, dynamic memory obtained via new[]
person(const char* the_name, int the_age)
{
name = new char[strlen(the_name) + 1];
strcpy(name, the_name);
age = the_age;
}
// the destructor must release this resource via delete[]
~person()
{
delete[] name;
}
};
Ngay cả ngày nay, mọi người vẫn viết các lớp theo phong cách này và gặp rắc rối: " Tôi đã đẩy một người vào một vectơ và bây giờ tôi gặp lỗi bộ nhớ điên rồ! " Hãy nhớ rằng theo mặc định, sao chép một đối tượng có nghĩa là sao chép các thành viên của nó, nhưng sao chépname thành viên sao chép một con trỏ, không phải mảng ký tự mà nó trỏ tới! Điều này có một số tác dụng khó chịu:
- Thay đổi thông qua
a có thể được quan sát thông qua b.
- Một lần
b bị phá hủy, a.namelà một con trỏ lơ lửng.
- Nếu
a bị phá hủy, xóa con trỏ lơ lửng sẽ mang lại hành vi không xác định .
- Vì bài tập không tính đến
name chỉ ra trước khi chuyển nhượng, sớm hay muộn bạn sẽ bị rò rỉ bộ nhớ ở mọi nơi.
Định nghĩa rõ ràng
Vì sao chép thành viên không có hiệu ứng mong muốn, chúng ta phải xác định rõ ràng hàm tạo sao chép và toán tử gán gán sao chép để tạo các bản sao sâu của mảng ký tự:
// 1. copy constructor
person(const person& that)
{
name = new char[strlen(that.name) + 1];
strcpy(name, that.name);
age = that.age;
}
// 2. copy assignment operator
person& operator=(const person& that)
{
if (this != &that)
{
delete[] name;
// This is a dangerous point in the flow of execution!
// We have temporarily invalidated the class invariants,
// and the next statement might throw an exception,
// leaving the object in an invalid state :(
name = new char[strlen(that.name) + 1];
strcpy(name, that.name);
age = that.age;
}
return *this;
}
Lưu ý sự khác biệt giữa khởi tạo và gán: chúng ta phải phá bỏ trạng thái cũ trước khi gán nameđể tránh rò rỉ bộ nhớ. Ngoài ra, chúng tôi phải bảo vệ chống lại việc tự gán mẫu x = x. Nếu không có kiểm tra đó, delete[] namesẽ xóa mảng chứa chuỗi nguồn , bởi vì khi bạn viết x = x, cả hai this->namevà that.namechứa cùng một con trỏ.
An toàn ngoại lệ
Thật không may, giải pháp này sẽ thất bại nếu new char[...]ném ngoại lệ do cạn kiệt bộ nhớ. Một giải pháp có thể là giới thiệu một biến cục bộ và sắp xếp lại các câu lệnh:
// 2. copy assignment operator
person& operator=(const person& that)
{
char* local_name = new char[strlen(that.name) + 1];
// If the above statement throws,
// the object is still in the same state as before.
// None of the following statements will throw an exception :)
strcpy(local_name, that.name);
delete[] name;
name = local_name;
age = that.age;
return *this;
}
Điều này cũng quan tâm đến việc tự giao mà không cần kiểm tra rõ ràng. Một giải pháp mạnh mẽ hơn nữa cho vấn đề này là thành ngữ sao chép và trao đổi , nhưng tôi sẽ không đi sâu vào chi tiết về an toàn ngoại lệ ở đây. Tôi chỉ đề cập đến các ngoại lệ để đưa ra quan điểm sau: Viết các lớp quản lý tài nguyên là khó.
Tài nguyên không thể quét
Một số tài nguyên không thể hoặc không được sao chép, chẳng hạn như xử lý tệp hoặc mutexes. Trong trường hợp đó, chỉ cần khai báo hàm tạo sao chép và toán tử gán gán sao chép privatemà không đưa ra định nghĩa:
private:
person(const person& that);
person& operator=(const person& that);
Ngoài ra, bạn có thể kế thừa từ boost::noncopyablehoặc khai báo chúng là đã xóa (trong C ++ 11 trở lên):
person(const person& that) = delete;
person& operator=(const person& that) = delete;
Quy tắc của ba
Đôi khi bạn cần triển khai một lớp quản lý tài nguyên. (Không bao giờ quản lý nhiều tài nguyên trong một lớp, điều này sẽ chỉ dẫn đến đau.) Trong trường hợp đó, hãy nhớ quy tắc ba :
Nếu bạn cần phải khai báo rõ ràng hàm hủy, sao chép hàm tạo hoặc toán tử gán gán sao chép, có lẽ bạn cần khai báo rõ ràng cả ba hàm này.
(Thật không may, "quy tắc" này không được thi hành theo tiêu chuẩn C ++ hoặc bất kỳ trình biên dịch nào tôi biết.)
Quy tắc của năm
Từ C ++ 11 trở đi, một đối tượng có thêm 2 hàm thành viên đặc biệt: hàm tạo di chuyển và phép gán di chuyển. Quy tắc của năm tiểu bang để thực hiện các chức năng là tốt.
Một ví dụ với chữ ký:
class person
{
std::string name;
int age;
public:
person(const std::string& name, int age); // Ctor
person(const person &) = default; // Copy Ctor
person(person &&) noexcept = default; // Move Ctor
person& operator=(const person &) = default; // Copy Assignment
person& operator=(person &&) noexcept = default; // Move Assignment
~person() noexcept = default; // Dtor
};
Quy tắc không
Quy tắc 3/5 cũng được gọi là quy tắc 0/3/5. Phần không của quy tắc nói rằng bạn được phép không viết bất kỳ hàm thành viên đặc biệt nào khi tạo lớp của bạn.
Khuyên bảo
Hầu hết thời gian, bạn không cần phải tự mình quản lý tài nguyên, bởi vì một lớp hiện có như std::stringđã làm điều đó cho bạn. Chỉ cần so sánh mã đơn giản bằng cách sử dụng một std::stringthành viên với giải pháp thay thế dễ bị lỗi và dễ bị lỗi bằng cách sử dụng a char*và bạn sẽ bị thuyết phục. Miễn là bạn tránh xa các thành viên con trỏ thô, quy tắc ba không có khả năng liên quan đến mã của riêng bạn.
c++-faqthẻ wiki trước khi bạn bỏ phiếu đóng cửa .