Как хранить несколько производных классов в векторе без нарезки

Question

class Base 
{ 
    public : 
     void func() 
     { 
      cout << "Base func()" << endl; 
     } 
}; 

class DerivedA : public Base 
{ 
    public : 
     void func() 
     { 
      cout << "Derived A func()" << endl; 
     } 
}; 

class DerivedB : public Base 
{ 
    public : 
     void func() 
     { 
      cout << "Derived B func()" << endl; 
     } 
}; 

void main() 
{ 
    DerivedA a; 
    DerivedB b; 

    vector<shared_ptr<Base>> temp; 
    temp.push_back(make_shared<DerivedA> (a)); 
temp.push_back(make_shared<DerivedB> (b)); 

    for(auto ptr : temp) 
    ptr->func(); 
} 

Выход

Base func() 
Base func() 

но то, что я ожидал, это

Derived A func() 
Derived B func() 

Как я мог нажать на производный класс в базовый класс вектор без нарезки? Если нет способа решить эту проблему, существует ли какой-либо эквивалентный метод для хранения нескольких производных классов в один массив, такой как объект?

Answer 1

Make FUNC() как виртуальный в базовом классе

class Base 
{ 
    public : 
     virtual void func() 
     { 
      cout << "Base func()" << endl; 
     } 
}; 

Answer 2

Никакой нарезки не происходит. Вам нужно сделать func виртуальный в Base:

virtual void func() 
{ 
    cout << "Base func()" << endl; 
} 

Это говорит компилятору, чтобы искать func для динамического типа Base*.

Answer 3

Вы должны использовать virtual functions.

Вот пример того, как это работает:

virtual_functions.h

#pragma once 

class Base { 
public: 
    virtual void virtual_func(); // virtual function. 
    void non_virtual_func();  // non-virtual function. 
}; 

class Derived : public Base { 
public: 
    void virtual_func();   // virtual function. 
    void non_virtual_func();  // non-virtual function. 
}; 

virtual_functions.cpp

#include "virtual_functions.h" 

#include <iostream> 
using namespace std; 

void Base::virtual_func() { 
    cout << "Base::virtual_func\n"; 
} 

void Base::non_virtual_func() { 
    cout << "Base::non_virtual_func()\n"; 
} 


void Derived::virtual_func() { 
    cout << "Derived::virtual_func\n"; 
} 

void Derived::non_virtual_func() { 
    cout << "Derived::non_virtual_func()\n"; 
} 

main.cpp

#include "virtual_functions.h" 

int main() { 
    // Declare an object of type Derived. 
    Derived aDerived; 

    // Declare two pointers, 
    // one of type Derived * 
    // and the other of type Base *, 
    // and initialize them to point to derived. 

    Derived *pDerived = &aDerived; 
    Base *pBase = &aDerived; 

    // Call the functions. 
    pBase->virtual_func();  // Call virtual function. 
    pBase->non_virtual_func(); // Call nonvirtual function. 
    pDerived->virtual_func();  // Call virtual function. 
    pDerived->non_virtual_func(); // Call nonvirtual function. 

    return 0; 
} 

Вывод должен быть:

Derived :: virtual_func()
Base :: non_virtual_func()
Derived :: virtual_func()
Derived :: non_virtual_func()