Является ли такой снижающий сейф?

Question

Предположим, мы имеем следующий код:

#include <memory> 
#include <vector> 

struct BaseComponent 
{ 
    template <typename T> 
    T * as() 
    { 
     return static_cast<T*>(this); 
    } 

    virtual ~BaseComponent() {} 
}; 

template <typename T> 
struct Component : public BaseComponent 
{ 
    virtual ~Component() {} 
}; 

struct PositionComponent : public Component<PositionComponent> 
{ 
    float x, y, z; 

    virtual ~PositionComponent() {} 
}; 

int main() 
{ 
    std::vector<std::unique_ptr<BaseComponent>> mComponents; 
    mComponents.emplace_back(new PositionComponent); 

    auto *pos = mComponents[0]->as<PositionComponent>(); 
    pos->x = 1337; 

    return 0; 
} 

---

В Т * в качестве метода(), должен ли я использовать static_cast или dynamic_cast? есть времена, когда конверсия не сработает? Нужно ли мне вместо этого использовать dynamic_cast?

auto *ptr = dynamic_cast<T*>(this); 

    if(ptr == nullptr) 
     throw std::runtime_error("D'oh!"); 

    return ptr; 

Answer 1

Код, который вы представляете, является правильным и хорошо сформированным, но приведение в целом небезопасно. Если фактический объект не был PositionComponent, то компилятор с радостью предположил бы, что это так, и вы будете вызывать неопределенное поведение.

Если вы замените литой dynamic_cast, тогда компилятор сгенерирует код, который во время выполнения проверяет правильность преобразования.

Реальный вопрос, зачем вам это нужно. Есть причины, но чаще всего использование бросков является показателем проблем с вашим дизайном. Пересмотрите ли вы можете сделать лучше (то есть перепроектировать код так, что вам не нужно идти явное преобразование типов)

Answer 2

Поскольку вы используете unique_ptr<BaseComponent>, естественно, может быть раз, когда преобразование не: введение новых данных в векторе и потребления этих данных делаются в несвязанных местах, и таким образом, что компилятор не может обеспечить его соблюдение.

Вот пример недопустимого гипса:

struct AnotherComponent : public Component<AnotherComponent> 
{ 
    virtual ~AnotherComponent() {} 
}; 

std::vector<std::unique_ptr<BaseComponent>> mComponents; 
mComponents.emplace_back(new AnotherComponent); 
// !!! This code compiles, but it is fundamentally broken !!! 
auto *pos = mComponents[0]->as<PositionComponent>(); 
pos->x = 1337; 

В связи с этим, использованием dynamic_cast обеспечит лучшую защиту от неправильного использования функции as<T>. Обратите внимание, что неправильное использование не может быть преднамеренным: в любое время компилятор не может проверить тип для вас, и у вас есть потенциальное несоответствие типов, то следует предпочесть dynamic_cast<T>

Вот small demo, чтобы проиллюстрировать, как dynamic_cast бы предложить вам степень защиты.

Answer 3

Вы должны всегда использовать dynamic_cast при литье полиморфных объектов, которые производятся из базового слоя.

В случае, когда mComponents[0] не является PositionComponent (или его производным от этого класса), приведенный выше код не сработает. Поскольку вся цель иметь mComponents имеет указатель на BaseComponent, так что вы можете поместить в вектор другие объекты, кроме PositionComponent объектов, я бы сказал, что вам нужно заботиться об этом конкретном сценарии.

В общем, это «плохой запах», когда вы используете dynamic_cast (или вообще кастинг объектов, полученных из общего базового слоя). Обычно это означает, что объекты не должны храниться в общем контейнере, потому что они недостаточно тесно связаны.

Answer 4

В вашем случае нет никакого способа узнать, статически this ли правильный типа или нет. То, что вы можете это CRTP (Любопытно повторяющийся узор шаблона):

template <class T> 
struct BaseComponent 
{ 
    T* as() 
    { 
     return static_cast<T*>(this); 
    } 

    virtual ~BaseComponent() {} 
}; 

template <typename T> 
struct Component : public BaseComponent<T> 
{ 
    virtual ~Component() {} 
}; 

struct PositionComponent : public Component<PositionComponent> 
{ 
    float x, y, z; 

    virtual ~PositionComponent() {} 
}; 

Таким образом, вы можете сделать:

auto x = yourBaseComponent.as(); 

и имеете право ребенок типа статический.