Início / coding / Perguntas / 79437033
Accepted
Newline
Asked: 2025-02-14 00:26:53 +0800 CST

Como saber o deslocamento de bytes entre uma classe base e uma classe derivada?

  • 772

Tenho uma construção semelhante ao CRTP:

class Derived : public Base<Derived>

Preciso calcular um ponteiro para um Derivedobjeto a partir de um ponteiro para Base<Derived>objeto via reinterpret_cast. Não posso usar dynamic_castporque não estou usando funções virtuais aqui.

Os tipos são fornecidos, eu tenho o ponteiro para o Base<Derived>objeto. Preciso do deslocamento de bytes entre os dois tipos, para poder usar reinterpret_cast. Como faço isso (sem comportamento indefinido)? É possível fazer em tempo de compilação / salvar como uma static constexprvariável (estou usando C++20)?

c++

2 respostas

  1. Best Answer

    Não há necessidade de cálculos de deslocamento ou reinterpret_cast.

    Se você tiver certeza de que o objeto é realmente Derivedum, você pode simplesmente usar static_cast:

    Derived derived;
Base<Derived> * pBase = &derived;

Derived * pDerived = static_cast<Derived*>(pBase);

    Observe que se pBaseo comando acima não apontar realmente para um Derivedobjeto, usar static_castna última linha invocará undefined-behavior (UB) .

    Uma observação lateral:
    como @BenVoigt comentou abaixo , é comum adicionar um método auxiliar à classe base do CRTP que faz exatamente essa conversão.
    Ou seja, adicione algo como isto Base<Derived>(substitua Derivedse necessário pelo nome do parâmetro de modelo real em Base):

    template <typename Derived>
class Base {

    Derived * ToDerived() { return static_cast<Derived*>(this); }
    // ...
};
    • 5

  2. O padrão CRTP depende de um static_cast<> entre a classe base e o tipo derivado. O tipo de classe Derived é a única classe derivada do tipo de modelo Base instanciado. Portanto, é garantido que a static_cast<Derived*>(this)é seguro dentro da classe de modelo Base. É por isso que é comum ver código como:

    template<class Derived> class Value {
protected:
    Derived& derived() { return *static_cast<Derived*>(this); }
    int& value() { 
         return derived().value(); // calls Derived::value()!
    }
};

template<class Derived> class Inc : public Value<Derived> {
public:
    int operator++ () { 
        this->value()++; // calls protected Value::value()!
        return this->value();
    }
    int operator++ (int) { 
        auto r = this->value();
        ++this->value(); 
        return r;
    }
};

class obj : public Inc<obj> {
    int x = 0;
public:
    int& value() { return x; }
};
// class bad : public Inc<obj> {};
// wrong, Inc<obj> type is already an base class of obj

    Aqui, class objsó é necessário implementar a API da classe base value()para que a base intermediária class Incimplemente operadores de pré e pós incremento para ela.

    (@wohlstad obteve a primeira resposta, então pensei em preencher uma resposta um pouco mais detalhada)

    • 1

relate perguntas