Tại sao không trình biên dịch C++ tối ưu hóa dynamic_cast này từ một lớp học cuối cùng?

Question

xem xét lớp phân cấp này:

struct Animal { virtual ~Animal(); }; 
struct Cat : virtual Animal {}; 
struct Dog final : virtual Animal {}; 

sự hiểu biết của tôi là đưa final trên class Dog đảm bảo rằng không ai có thể tạo ra một lớp kế thừa từ Dog, trong đó, hệ quả tất yếu, có nghĩa là không ai có thể tạo ra một lớp mà LÀ-A Dog và IS-A Cat cùng một lúc.

Hãy xem xét hai dynamic_cast s này:

Dog *to_final(Cat *c) { 
    return dynamic_cast<Dog*>(c); 
} 

Cat *from_final(Dog *d) { 
    return dynamic_cast<Cat*>(d); 
} 

GCC, ICC, và MSVC bỏ qua final vòng loại và tạo ra một cuộc gọi đến __dynamic_cast; điều này thật đáng tiếc nhưng không đáng ngạc nhiên.

gì làm tôi ngạc nhiên là Clang và Zapcc cả generate mã tối ưu cho from_final ("luôn luôn trả nullptr"), nhưng tạo ra một cuộc gọi đến __dynamic_cast cho to_final.

Đây có phải là thực sự là một cơ hội tối ưu hóa nhỡ (trong một trình biên dịch mà rõ ràng ai đó đặt một số nỗ lực vào tôn trọng final vòng loại trong phôi), hoặc là tối ưu hóa không thể trong trường hợp này vì một lý do tế nhị mà tôi vẫn không nhìn thấy?

Answer 1

Ok, tôi đào qua Clang của source code to find this method:

/// isAlwaysNull - Return whether the result of the dynamic_cast is proven 
/// to always be null. For example: 
/// 
/// struct A { }; 
/// struct B final : A { }; 
/// struct C { }; 
/// 
/// C *f(B* b) { return dynamic_cast<C*>(b); } 
bool CXXDynamicCastExpr::isAlwaysNull() const 
{ 
    QualType SrcType = getSubExpr()->getType(); 
    QualType DestType = getType(); 

    if (const PointerType *SrcPTy = SrcType->getAs<PointerType>()) { 
    SrcType = SrcPTy->getPointeeType(); 
    DestType = DestType->castAs<PointerType>()->getPointeeType(); 
    } 

    if (DestType->isVoidType()) // always allow cast to void* 
    return false; 

    const CXXRecordDecl *SrcRD = 
    cast<CXXRecordDecl>(SrcType->castAs<RecordType>()->getDecl()); 

    //******************************************************************** 
    if (!SrcRD->hasAttr<FinalAttr>()) // here we check for Final Attribute 
    return false; // returns false for Cat 
    //******************************************************************** 

    const CXXRecordDecl *DestRD = 
    cast<CXXRecordDecl>(DestType->castAs<RecordType>()->getDecl()); 

    return !DestRD->isDerivedFrom(SrcRD); // search ancestor types 
} 

Tôi nhận được một chút mệt mỏi từ phân tích mã, nhưng nó không có vẻ với tôi rằng bạn from_final là không chỉ đơn giản là luôn luôn là null vì cuối cùng Thuộc tính, nhưng ngoài ra vì rằng Cat không nằm trong chuỗi bản ghi có nguồn gốc Dog. Cấp, nếu nó không có thuộc tính final, sau đó nó sẽ thoát sớm (như khi nó Cat là một Src), nhưng nó không nhất thiết phải luôn là rỗng.

Tôi đoán có một vài lý do cho việc này. Đầu tiên là dynamic_cast cast cả chuỗi lên và xuống. Khi bản ghi nguồn có thuộc tính cuối cùng, bạn có thể chỉ cần kiểm tra chuỗi nếu Dest là tổ tiên (vì không thể có các lớp dẫn xuất từ ​​Nguồn).

Nhưng nếu lớp học không kết thúc thì sao? Tôi nghi ngờ có thể có nhiều hơn với nó. Có lẽ nhiều thừa kế làm cho tìm kiếm lên phôi khó khăn hơn so với phôi? Không dừng mã trong trình gỡ lỗi, tất cả những gì tôi có thể làm là suy đoán.

Điều này tôi biết: isAlwaysNull là chức năng thoát sớm. Đó là một khẳng định hợp lý rằng nó đang cố gắng để chứng minh rằng kết quả là luôn luôn null. Bạn không thể chứng minh một tiêu cực (như họ nói), nhưng bạn có thể bác bỏ một tích cực.

---

Có lẽ bạn có thể kiểm tra lịch sử Git cho tệp và gửi email cho người đã viết chức năng đó. (hoặc ít nhất là thêm kiểm tra final).