Làm thế nào để tiêu diệt một con trỏ thông minh sớm

Question

Tôi có một lớp có phương thức setter lấy một đối số unique_ptr. Đó unique_ptr được lưu như là một thành viên lớp.

class TestClass { 
    std::unique_ptr<Tester> sp; 

    void setTester_Way1(std::unique_ptr<Tester> te) { 
     auto deleter=std::move(sp); 
     sp=std::move(te); 
    } 

    void setTester_Way2(std::unique_ptr<Tester> te) { 
     sp=std::move(te); 
    } 
}; 

Cách nào là đúng để đặt con trỏ thông minh? Way2 có bị rò rỉ con trỏ ban đầu của sp không?

Answer 1

Cách 2 là tốt, khi bạn gán cho unique_ptr bất kỳ con trỏ nào hiện có thuộc sở hữu sẽ bị xóa an toàn.

Answer 2

Như Chris Drew nói Way2 là tốt. Một điều mặc dù là unique_ptr không thể sao chép/gán được vì vậy cách duy nhất để vượt qua một unique_ptr là tham chiếu, tham chiếu giá trị r hoặc theo giá trị với move(). Đang cố gắng làm:

int main() 
{ 
    TestClass t; 
    auto p = std::make_unique<int>(10); 
    t.setTester_Way2(p); 
} 

Will fail to compile. Mặc dù bạn có thể move()p vào chức năng (example).

Nếu bạn thay đổi setTester_Way2() thành void setTester_Way2(std::unique_ptr<int>& te)then it will compile. Nếu bạn thay đổi chức năng để có một tài liệu tham khảo rvalue và std::move() con trỏ vào funcnction:

class TestClass { 
    std::unique_ptr<int> sp; 
public: 

    void setTester_Way1(std::unique_ptr<int> te) { 
     auto deleter=std::move(sp); 
     sp=std::move(te); 
    } 

    void setTester_Way2(std::unique_ptr<int>&& te) { 
     sp=std::move(te); 
    } 
}; 

int main() 
{ 
    TestClass t; 
    auto p = std::make_unique<int>(10); 
    t.setTester_Way2(std::move(p)); 
} 

Then it will also compile.