Chuyển shared_ptr <Derived> as shared_ptr <Base>

Phương pháp tốt nhất để chuyển một shared_ptrkiểu dẫn xuất sang một hàm nhận shared_ptrkiểu cơ sở là gì?

Tôi thường chuyển shared_ptrs bằng cách tham khảo để tránh một bản sao không cần thiết:

int foo(const shared_ptr<bar>& ptr);

nhưng điều này không hiệu quả nếu tôi cố gắng làm điều gì đó như

int foo(const shared_ptr<Base>& ptr);

...

shared_ptr<Derived> bar = make_shared<Derived>();
foo(bar);

tôi có thể dùng

foo(dynamic_pointer_cast<Base, Derived>(bar));

nhưng điều này có vẻ không tối ưu vì hai lý do:

• A dynamic_castcó vẻ hơi thừa đối với một dàn diễn viên đơn giản có nguồn gốc từ cơ sở.
• Theo tôi hiểu, hãy dynamic_pointer_casttạo một bản sao (mặc dù là bản sao tạm thời) của con trỏ để chuyển tới hàm.

Có giải pháp nào tốt hơn không?

Cập nhật cho hậu thế:

Hóa ra là vấn đề thiếu tệp tiêu đề. Ngoài ra, những gì tôi đang cố gắng làm ở đây được coi là một phản vật chất. Nói chung là,

• Chức năng mà không ảnh hưởng đến tuổi thọ của một đối tượng (tức là đối tượng vẫn có giá trị trong suốt thời gian của hàm) nên phải mất một tài liệu tham khảo đồng bằng hoặc con trỏ, ví dụ int foo(bar& b).

• Các hàm sử dụng một đối tượng (tức là những người dùng cuối cùng của một đối tượng nhất định) phải nhận unique_ptrtheo giá trị, ví dụ int foo(unique_ptr<bar> b). Người gọi nên std::movenhập giá trị vào hàm.

• Các hàm kéo dài thời gian tồn tại của một đối tượng phải nhận shared_ptrtheo giá trị, ví dụ int foo(shared_ptr<bar> b). Lời khuyên thông thường để tránh các tham chiếu vòng tròn được áp dụng.

Xem bài nói chuyện Back to Basics của Herb Sutter để biết thêm chi tiết.

Mặc dù Basevà Derivedlà hiệp biến và con trỏ nguyên đối với họ sẽ hành động phù hợp, shared_ptr<Base>và shared_ptr<Derived>là không hiệp biến. Đây dynamic_pointer_castlà cách chính xác và đơn giản nhất để xử lý vấn đề này.

( Chỉnh sửa: static_pointer_cast sẽ thích hợp hơn vì bạn đang truyền từ nguồn gốc đến cơ sở, điều này an toàn và không yêu cầu kiểm tra thời gian chạy. Xem nhận xét bên dưới.)

Tuy nhiên, nếu foo()hàm của bạn không muốn tham gia vào việc kéo dài thời gian tồn tại (hay đúng hơn là tham gia vào quyền sở hữu chung của đối tượng), thì tốt nhất bạn nên chấp nhận một const Base&và bỏ shared_ptrqua khi chuyển nó đến foo().

void foo(const Base& base);
[...]
shared_ptr<Derived> spDerived = getDerived();
foo(*spDerived);

Ngoài ra, bởi vì shared_ptrcác loại không thể đồng biến, các quy tắc chuyển đổi ngầm định giữa các loại trả về đồng biến không áp dụng khi trả về các loại shared_ptr<T>.

Điều này cũng sẽ xảy ra nếu bạn quên chỉ định kế thừa công khai trên lớp dẫn xuất, tức là nếu giống như tôi, bạn viết thế này:

class Derived : Base
{
};

Có vẻ như bạn đang cố gắng quá nhiều. shared_ptrrẻ để sao chép; đó là một trong những mục tiêu của nó. Chuyển chúng đi xung quanh bằng cách tham khảo không thực sự đạt được nhiều thành tựu. Nếu bạn không muốn chia sẻ, hãy chuyển con trỏ thô.

Điều đó nói rằng, có hai cách để làm điều này mà tôi có thể nghĩ ra ngay từ đầu:

foo(shared_ptr<Base>(bar));
foo(static_pointer_cast<Base>(bar));

Ngoài ra, hãy kiểm tra xem #includetệp tiêu đề chứa khai báo đầy đủ của lớp dẫn xuất có trong tệp nguồn của bạn hay không.

Tôi đã có vấn đề này. Các std::shared<derived>sẽ không cast vào std::shared<base>. Tôi đã khai báo trước cả hai lớp để tôi có thể giữ các con trỏ đến chúng, nhưng vì tôi không có #includetrình biên dịch nên không thể thấy rằng một lớp được dẫn xuất từ ​​lớp kia.