Получить производный тип через виртуальную функцию базового класса

Поддержка ковариантных типов возврата C++ будет работать только в том случае, если вы уже знаете производный тип. Чтобы преобразовать базовый класс в возможно производный класс, просто используйте dynamic_cast<derived>(base_ref), чтобы определить, соответствует ли base_ref фактический производный тип:

int main () {
    base* pd = new derived();
    derived& x = dynamic_cast<derived&>(*pd); // Will throw an exception if pd 
                                          // isn't a 'derived'
    x.fn();
    return 0;
}

Или альтернативно:

int main () {
    base* pd = new derived();
    derived* x = dynamic_cast<derived*>(pd); // Will return nullptr if pd isn't
                                         // a 'derived'
    if(x) {
        x->fn();
    }
    else {
        // dynamic_cast<derived*> failed ...
    }
    return 0;
}

c++ поддерживает ковариантные возвращаемые типы для производных классы, но, как описывают другие ответы, вы не можете получить его, вызвав здесь базовый класс (pd->get_this()).

Вы также можете использовать статический полиморфизм для проверки соответствия типов во время компиляции, если это возможно. не использовать RTTI, обработку исключений или жесткую привязку типов (без накладных расходов vtable).

Статический тип pd — base *. Таким образом, когда компилятор ищет функцию-член get_this(), он находит только base::get_this(). Тип возвращаемого значения base::get_this() — base&, который нельзя преобразовать в derived&. Отсюда ошибка.

Я хотел бы добавить к ответу Новелократа, сославшись на раздел 10.3, параграф 8 документа рабочий проект стандарта C++ (нажмите здесь), в котором объясняется, в каком случае статический тип возвращаемого указателя — Derived*, а не Base*. По сути, если бы вы вызывали get_this() через указатель на производный класс, вы бы получили правильный тип без ошибки компилятора.

Вот цитата из стандарта вместе с примером (тоже из стандарта):

Если возвращаемый тип D::f отличается от возвращаемого типа B::f, тип класса в возвращаемом типе D::f должен быть полным в точке объявления D::f или должен быть классом тип D. Когда переопределяющая функция вызывается как последняя переопределяющая переопределяющая функция, ее результат преобразуется в тип, возвращаемый (статически выбранной) переопределяемой функцией (5.2.2). [Пример:

class B { };
class D : private B { friend class Derived; };
struct Base {
    virtual void vf1();
    virtual void vf2();
    virtual void vf3();
    virtual B* vf4();
    virtual B* vf5();
    void f();
};

struct No_good : public Base {
    D* vf4(); // error: B (base class of D) inaccessible
};

class A;
struct Derived : public Base {
    void vf1(); // virtual and overrides Base::vf1()
    void vf2(int); // not virtual, hides Base::vf2()
    char vf3(); // error: invalid difference in return type only
    D* vf4(); // OK: returns pointer to derived class
    A* vf5(); // error: returns pointer to incomplete class
    void f();
};

void g() {
    Derived d;
    Base* bp = &d; // standard conversion:
    // Derived* to Base*
    bp->vf1(); // calls Derived::vf1()
    bp->vf2(); // calls Base::vf2()
    bp->f(); // calls Base::f() (not virtual)
    B* p = bp->vf4(); // calls Derived::pf() and converts the
    // result to B*
    Derived* dp = &d;
    D* q = dp->vf4(); // calls Derived::pf() and does not
    // convert the result to B*
    dp->vf2(); // ill-formed: argument mismatch
}

C++ поддерживает ковариантный возвращаемый тип. Это означает, что когда вы вызываете get_this() для объекта derived через указатель base, будет вызываться реализация производного.

Однако это не означает, что вызов base::get_this даст вам derived&. Тип возвращаемого значения base::get_this — base&. если вы хотите получить объект derived, вам придется вызвать get_this через указатель derived (или преобразовать base& в derived&). Обратите внимание, что именно так работает ковариация возвращаемого типа в Java, C++, D...

base* pbase = new base();
base* pderived = new derived();
derived* pderived2 = new derived();

base& a = pbase->get_this();        // call implementation in base, return base&
base& b = pderived->get_this();     // call implementation in derived, return base&
derived& c = pderived2->get_this(); // call implementation in derived, return derived&

Я нашел простое решение, но если есть возможность, я бы мастера оценить:

class base{ 
    type = 1;
    virtual int getType() final {
        return type;
    }
}

class derived1 : public base {
    derived1(){
        type = 2;
    }
}

Таким образом, вы можете вызвать метод 'int getType()' любого из производных классов. Поскольку тип задается в конструкторе, нет риска неправильного поведения. Чтобы повысить удобство использования, я создал предопределенные «типы».

Я использую, но не знаю, МакГайвери!