Devo usare dynamic_cast quando chiamo una funzione che accetta la classe base?

Question

Ho alcune lezioni come questa:

interface class IA
{
};

interface class IB
{
};

public ref class C : public IA, public IB
{
};

public ref class D
{
    void DoSomething(IA^ aaa)
    {
    }

    void Run()
    {
        C^ bob = gcnew C();
        DoSomething(dynamic_cast<IA^>(bob));    // #1
        DoSomething(bob);           // #2
    }
};

Al momento cerco sempre di usare il casting dinamico quando chiamo una tale funzione (il # 1 sopra).
Tuttavia rende il codice abbastanza brutto, quindi voglio sapere se è effettivamente necessario.

Usi dynamic_cast in questo modo? In tal caso, qual è il motivo principale?

Answer 1

Poiché sappiamo che bob è di tipo C ^ , sappiamo al momento della compilazione che può essere trasferito in IA ^ in modo sicuro, e così dynamic_cast è equivalente a static_cast qui. Inoltre, anche il cast implicito che proponi è sicuro.

dynamic_cast è necessario solo quando si esegue l'upgrade da un tipo di base a un derivato.

Answer 2

Nel C ++ standard, usi dynamic_cast per percorrere la gerarchia, non verso l'alto. In questo caso, lo useresti per provare a convertire un IA o IB in un C:

IA^ temp = /* get a C in some way. */;
C^ tempC = dynamic_cast<C^>(temp);

Answer 3

No, penso che in C ++ / CLI non sia necessario il cast dinamico qui. Derivato * converte implicitamente in Base * a meno che non ci sia un'ambiguità w.r.t. eredità multipla. Lo stesso vale probabilmente per "quot-gc pointers". In C ++ un cast dinamico - durante l'upcasting - richiede classi polimorfiche (con almeno una funzione virtuale). Non so come C ++ / CLI lo gestisca, però. Penso che ogni classe CLI sia di default polimorfica.

Potresti voler rimuovere il tag C ++, comunque. ;)