Việc sử dụng hàm tạo bản sao riêng tư trong C++

Question

Tại sao mọi người định nghĩa một hàm tạo bản sao riêng?

Khi nào làm cho hàm tạo bản sao và toán tử gán có thiết kế tốt?

Nếu không có thành viên nào trong lớp là con trỏ hoặc xử lý đối tượng duy nhất (như tên tệp), thì các trường hợp khác ở đó là nơi mà hàm tạo bản sao riêng tư là một ý tưởng hay?

Câu hỏi tương tự áp dụng cho toán tử gán. Cho rằng đa số C++ xoay quanh việc sao chép các đối tượng và đi qua tham chiếu, có thiết kế tốt nào liên quan đến hàm tạo bản sao riêng không?

Answer 1

Một số đối tượng đại diện cho các thực thể cụ thể không thể hoặc không nên sao chép. Ví dụ, bạn có thể ngăn chặn việc sao chép một đối tượng đại diện cho tệp nhật ký được ứng dụng sử dụng, tương ứng với kỳ vọng rằng một tệp nhật ký duy nhất sẽ được tất cả các phần của mã sử dụng. Việc sử dụng một đối tượng vô tình hoặc không được sao chép có thể dẫn đến nội dung không đúng thứ tự xuất hiện trong nhật ký, các bản ghi không chính xác của kích thước nhật ký hiện tại, nhiều lần thử (một số lỗi) để "cuộn" vào tên tệp nhật ký mới hoặc đổi tên tệp hiện có.

Sử dụng khác là thực thi sao chép thông qua chức năng ảo. Vì các hàm tạo không thể là virtual, một thực tế phổ biến là ngăn chặn truy cập trực tiếp vào trình tạo bản sao và cung cấp phương thức virtual Base* clone() trả về một bản sao của loại thời gian chạy thực tế mà con trỏ trỏ tới. Điều này ngăn chặn tình cờ cắt rằng Base b(derived) sẽ triển lãm.

Ví dụ khác: đối tượng con trỏ thông minh chết đơn giản chỉ xóa con trỏ được đưa ra trong hàm tạo: nếu nó không hỗ trợ tính tham chiếu hoặc một số cách xử lý nhiều chủ sở hữu khác và không muốn có rủi ro chuyển giao quyền sở hữu không mong muốn std::auto_ptr quyền sở hữu, sau đó chỉ đơn giản là ẩn các nhà xây dựng bản sao cho một con trỏ thông minh tuyệt vời đó là nhanh chóng và hiệu quả cho các trường hợp hạn chế, nơi nó có thể sử dụng. Một lỗi thời gian biên dịch về cố gắng sao chép nó có hiệu quả sẽ yêu cầu các lập trình viên "hey - nếu bạn thực sự muốn làm điều đó thay đổi tôi đến một con trỏ chia sẻ, nếu không trở lại!".

Answer 2

Bạn có thể muốn triển khai một số phương thức của lớp bằng cách sử dụng một hàm tạo bản sao, nhưng không để lộ nó bên ngoài lớp. Vì vậy, sau đó bạn làm cho nó riêng tư. Giống như bất kỳ phương pháp nào khác.

Answer 3

Một trường hợp sử dụng là mẫu đơn trong đó chỉ có thể có chính xác một phiên bản của một lớp. Trong trường hợp này, bạn cần tạo các hàm tạo và toán tử gán = private để không có cách nào tạo nhiều hơn một đối tượng. Cách duy nhất để tạo một đối tượng là thông qua hàm GetInstance() của bạn như hình dưới đây.

// An example of singleton pattern 
class CMySingleton 
{ 
public: 
    static CMySingleton& GetInstance() 
    { 
    static CMySingleton singleton; 
    return singleton; 
    } 

// Other non-static member functions 
private: 
    CMySingleton() {}         // Private constructor 
    ~CMySingleton() {} 
    CMySingleton(const CMySingleton&);     // Prevent copy-construction 
    CMySingleton& operator=(const CMySingleton&);  // Prevent assignment 
}; 

int main(int argc, char* argv[]) 
{ 
    // create a single instance of the class 
    CMySingleton &object = CMySingleton::GetInstance(); 

    // compile fail due to private constructor 
    CMySingleton object1; 
    // compile fail due to private copy constructor 
    CMySingleton object2(object); 
    // compile fail due to private assignment operator 
    object1 = object; 

    // .. 
    return 0; 
} 

Answer 4

Ngay cả khi nội dung của đối tượng không phải là con trỏ hoặc tham chiếu khác, ngăn người sao chép đối tượng vẫn có thể hữu ích. Có lẽ lớp học chứa rất nhiều dữ liệu và quá trình sao chép quá nặng.

Answer 5

Một ví dụ rất xấu:

class Vehicle : { int wheels; Vehicle(int w) : wheels(w) {} } 

class Car : public Vehicle { Engine * engine; public Car(Engine * e) : Vehicle(4), engine(e) } 

... 

Car c(new Engine()); 

Car c2(c); // Now both cars share the same engine! 

Vehicle v; 
v = c; // This doesn't even make any sense; all you have is a Vehicle with 4 wheels but no engine. 

có nghĩa là gì để "sao chép" một chiếc xe hơi? (Có phải ô tô là mô hình ô tô, hay một chiếc xe hơi? Sao chép nó có bảo quản việc đăng ký xe không?)

Điều gì có nghĩa là gán xe cho người khác?

Nếu các thao tác vô nghĩa (hoặc đơn giản là không thực hiện), điều chuẩn cần làm là làm cho hàm tạo bản sao và toán tử gán riêng, gây ra lỗi biên dịch nếu chúng được sử dụng thay vì hành vi lạ.

Answer 6

"virtual constructor idiom" là trường hợp quan trọng khi cần có trình tạo bản sao riêng tư hoặc được bảo vệ. Một vấn đề nảy sinh trong C++, nơi bạn được đưa con trỏ tới một lớp cơ sở, của một đối tượng thực sự được kế thừa từ lớp cơ sở này và bạn muốn tạo một bản sao của nó. Việc gọi hàm tạo bản sao sẽ không gọi hàm tạo bản sao của lớp kế thừa, nhưng thực sự gọi hàm tạo bản sao của lớp cơ sở.

Quan sát:

class Base { 

public: 
    Base(const Base & ref){ std::cout << "Base copy constructor" ; } 
}; 

class Derived : public Base { 

public: 
    Derived(const Derived & ref) : Base(ref) { std::cout << "Derived copy constructor"; } 
} 

Base * obj = new Derived; 
Base * obj2 = new Derived(*obj); 

Đoạn mã trên sẽ tạo ra kết quả:

"Base copy constructor" 

Đây rõ ràng không phải là hành vi lập trình viên muốn! Các lập trình viên đã cố gắng để sao chép một đối tượng thuộc loại "Có nguồn gốc" nhưng thay vào đó đã trở lại một đối tượng của loại "Base" !!

Sự cố được khắc phục bằng cách sử dụng thành ngữ đã nói ở trên. Quan sát các ví dụ viết ở trên, lại ghi vào sử dụng thành ngữ này:

class Base { 

public: 
    virtual Base * clone() const = 0; //this will need to be implemented by derived class 

protected: 
    Base(const Base & ref){ std::cout << "Base copy constructor" ; } 
}; 

class Derived : public Base { 

public: 
    virtual Base * clone() const { 

    //call private copy constructor of class "Derived" 
    return static_cast<Base *>(new Derived(*this)); 
    } 

//private copy constructor: 
private: 
    Derived(const Derived & ref) : Base(ref) { std::cout << "Derived copy constructor"; } 
} 

Base * obj = new Derived; 
Base * obj2 = obj->clone(); 

Đoạn mã trên sẽ tạo ra kết quả:

"Base copy constructor" 
"Derived copy constructor" 

Nói cách khác, các đối tượng đó được xây dựng vào loại mong muốn " Có nguồn gốc ", và không thuộc loại" Base "!

Như bạn có thể thấy, trong kiểu gốc, trình tạo bản sao được cố tình tạo riêng tư, vì nó sẽ là thiết kế API xấu để cho các lập trình viên khả năng vô tình cố gọi hàm sao chép theo cách thủ công, thay vì sử dụng giao diện thông minh được cung cấp bởi clone(). Nói một cách khác, một hàm tạo bản sao có thể gọi trực tiếp có thể khiến các lập trình viên mắc sai lầm được đề cập trong phần 1. Trong trường hợp này, thực hành tốt nhất sẽ có hàm khởi tạo sao chép được ẩn và chỉ truy cập gián tiếp bằng cách sử dụng phương thức "sao chép" () ".

Answer 7

Lý do phổ biến để tạo bản sao chép và gán bản sao riêng tư là vô hiệu hoá việc thực hiện mặc định các hoạt động này. Tuy nhiên, trong C++ 0x có cú pháp đặc biệt = xóa cho mục đích đó. Vì vậy, trong C++ 0x làm bản sao ctor riêng dường như được sắp xếp lại cho các trường hợp rất kỳ lạ.

Sao chép ctors và bài tập là cú pháp khá đường; vì vậy một "đường tư nhân" như vậy có vẻ như là triệu chứng của tham lam :)