Tabela Comparativa dos Operadores de Cast em C++

Uso do static_cast

O static_cast é indicado para conversões seguras entre tipos numéricos, para obter um ponteiro void* a partir de um ponteiro tipado (e vice-versa), e para converter um ponteiro de classe derivada para a classe base. Conversões diretas entre ponteiros de tipos diferentes não são permitidas por este operador.

#include <iostream>

using namespace std;

class Animal {
public:
    virtual void emitirSom() { cout << "Som genérico\n"; }
};

class Cachorro : public Animal {
public:
    void emitirSom() override { cout << "Au au!\n"; }
};

int main()
{
    double valor = 3.99;
    int inteiro = static_cast<int>(valor);
    cout << "Original: " << valor << ", Convertido: " << inteiro << endl;

    void *ptrVoid;
    int *ptrInt = static_cast<int *>(ptrVoid);
    ptrVoid = static_cast<void *>(&valor);

    Cachorro dog;
    dog.emitirSom();
    Animal *animalPtr = static_cast<Animal *>(&dog);
    animalPtr->emitirSom();

    return 0;
}

Uso do dynamic_cast

O dynamic_cast permite converter ponterios ou referências da classe base para a classe derivada em tempo de execução. Para que isso funcione, a classe base precisa ter pelo menos um método virtual, pois o compilador utiliza informações RTTI (Run-Time Type Information) durante a verificação.

#include <iostream>

using namespace std;

class Forma {
public:
    virtual void desenhar() { cout << "Desenhando forma\n"; }
};

class Circulo : public Forma {
public:
    void desenhar() override { cout << "Desenhando círculo\n"; }
};

int main()
{
    Circulo c;
    c.desenhar();

    Forma *formaPtr = dynamic_cast<Forma *>(&c);
    formaPtr->desenhar();

    Circulo *circuloPtr = dynamic_cast<Circulo *>(formaPtr);
    circuloPtr->desenhar();

    return 0;
}

Uso do const_cast

O const_cast é o único operador capaz de modificar o qualificador const de ponteiros e referências. Geralmente é utilizado para remover a constância de uma variável, porém essa prática pode ser perigosa e deve ser empregada com cautela.

int main()
{
    int valor = 42;
    const int *ptrConst = &valor;

    int *ptrMutavel = const_cast<int *>(ptrConst);

    const int *ptrNovamenteConst = const_cast<const int *>(ptrMutavel);

    return 0;
}

Uso do reinterpret_cast

O reinterpret_cast funciona de forma similar ao cast explícito da linguagem C, permitindo conversões praticamente ilimitadas entre tipos. Deve ser utilizado apenas como último recurso, quando nenhum dos demais operadores resolvre o problema.

int main()
{
    int valor = 100;
    int *ptrInteiro = &valor;

    float *ptrFloat = reinterpret_cast<float *>(ptrInteiro);

    return 0;
}