Qual è una possibile soluzione alternativa per l'affettamento degli oggetti in C++?

Question

Questo è il codice:

#include <string> 
#include <vector> 
#include <iostream> 
using namespace std; 
class A { 
public: 
    virtual const string f() const { return "A"; } 
}; 
class B : public A { 
public: 
    const string f() const { return "B"; } 
}; 
int main(int ac, char** av) { 
    vector<A> v; 
    v.push_back(B()); 
    cout << v.at(0).f() << endl; 
    return 0; 
} 

risultato atteso è B, ma è A. Come ho capito oggetto slicing è in corso. Come evitarlo? Devo memorizzare i puntatori in vector invece di istanze di oggetto? È questa l'unica scelta?

Answer 1

È necessario memorizzare i puntatori. Se questi si riferiscono a oggetti allocati dinamicamente, utilizzare i puntatori intelligenti .

Answer 2

Bene, nel codice è possibile utilizzare un vettore di B. Si noti che le funzioni virtuali verranno inviate correttamente solo se chiamate tramite un puntatore o un riferimento. Tuttavia, supponendo che si desideri veramente che il vettore contenga sia gli oggetti A che B, è necessario renderlo vettoriale di puntatori A e creare dinamicamente gli oggetti A e B.

Answer 3

Ordinato dal più semplice, al più complesso (ma più bello).

Soluzione 1:

vector<B> v; 
v.push_back(B()); 
cout << v.at(0).f() << endl; 

Soluzione 2:

vector<A*> v; 
v.push_back(new B()); 
cout << v.at(0)->f() << endl; 
while(!v.empty()) { delete v.back(); v.pop_back(); } 

Soluzione 3:

vector<boost::shared_ptr<A>> v; 
v.push_back(boost::make_shared<B>()); 
cout << v.at(0)->f() << endl; 

Se non w Affinché ciò accada, è necessario tenere in considerazione il fatto che oggetti diversi possono avere dimensioni diverse - quindi è necessaria una soluzione che possa funzionare con dimensioni variabili - il che rende l'archiviazione in heap un must.