Posso avere contenitori polimorfici con la semantica del valore in C++ 11?

Question

Questo è un sequel di un related post che ha chiesto l'eterna domanda:

Posso avere contenitori polimorfi con semantica di valore in C++?

La domanda è stata posta in modo leggermente errato. Sarebbe dovuto essere più simile a:

Posso avere contenitori STL di un tipo di base memorizzato in base al valore in cui gli elementi mostrano un comportamento polimorfico?

Se si pone la domanda in termini di C++, la risposta è "no". Ad un certo punto, triterai gli oggetti memorizzati in base al valore.

Ora ripeto la domanda, ma rigorosamente in termini di C++ 11. Con le modifiche al linguaggio e alle librerie standard, è ora possibile memorizzare oggetti polimorfici in base al valore in un contenitore STL?

Sono ben consapevole della possibilità di memorizzare un puntatore intelligente per la classe base nel contenitore - questo non è quello che sto cercando per, come sto cercando di costruire oggetti nello stack senza utilizzando new.

Considerate se si vuole (dal post linked) come base, C++ esempio:

#include <iostream> 

using namespace std; 

class Parent 
{ 
    public: 
     Parent() : parent_mem(1) {} 
     virtual void write() { cout << "Parent: " << parent_mem << endl; } 
     int parent_mem; 
}; 

class Child : public Parent 
{ 
    public: 
     Child() : child_mem(2) { parent_mem = 2; } 
     void write() { cout << "Child: " << parent_mem << ", " << child_mem << endl; } 

     int child_mem; 
}; 

int main(int, char**) 
{ 
    // I can have a polymorphic container with pointer semantics 
    vector<Parent*> pointerVec; 

    pointerVec.push_back(new Parent()); 
    pointerVec.push_back(new Child()); 

    pointerVec[0]->write();  
    pointerVec[1]->write();  

    // Output: 
    // 
    // Parent: 1 
    // Child: 2, 2 

    // But I can't do it with value semantics 

    vector<Parent> valueVec; 

    valueVec.push_back(Parent()); 
    valueVec.push_back(Child());  // gets turned into a Parent object :(

    valueVec[0].write();   
    valueVec[1].write();   

    // Output: 
    // 
    // Parent: 1 
    // Parent: 2 

} 

Answer 1

Solo per divertimento, basandomi sul commento di James su un sistema basato su modelli, ho realizzato questa implementazione simile a Vector. Mancano molte funzionalità e potrebbero essere bacati, ma è un inizio!

#include <iostream> 
#include <vector> 
#include <boost/shared_ptr.hpp> 

template <typename T> 
class Vector 
{ 
public: 
    T &operator[] (int i) const { return p[i]->get(); } 
    template <typename D> 
    void push_back(D &x) { p.push_back(ptr_t(new DerivedNode<D>(x))); } 

private: 
    class Node 
    { 
    public: 
     virtual T &get() = 0; 
    }; 

    template <typename D> 
    class DerivedNode : public Node 
    { 
    public: 
     DerivedNode(D &x) : x(x) {} 
     virtual D &get() { return x; } 
    private: 
     D x; 
    }; 

    typedef boost::shared_ptr<Node> ptr_t; 
    std::vector<ptr_t> p; 
}; 

/////////////////////////////////////// 

class Parent 
{ 
    public: 
     Parent() : parent_mem(1) {} 
     virtual void write() const { std::cout << "Parent: " << parent_mem << std::endl; } 
     int parent_mem; 
}; 

class Child : public Parent 
{ 
    public: 
     Child() : child_mem(2) { parent_mem = 2; } 
     void write() const { std::cout << "Child: " << parent_mem << ", " << child_mem << std::endl; } 

     int child_mem; 
}; 


int main() 
{ 
    Vector<Parent> v; 

    v.push_back(Parent()); 
    v.push_back(Child()); 

    v[0].write(); 
    v[1].write(); 
} 

Answer 2

Non si può certo avere una matrice polimorfico (o vector). Il requisito che gli elementi di una matrice siano memorizzati in modo contiguo nella memoria è fondamentalmente incompatibile con il fatto che diversi tipi di classi derivate possono avere dimensioni diverse.

Nessuno dei contenitori di libreria standard consente di archiviare oggetti di tipi di classi derivate differenti in un singolo contenitore.

Answer 3

Prima di tutto, le vostre esigenze non sono ancora perfettamente chiare. Presumo che tu voglia "memoria in linea" per il contenitore; quindi, ad esempio, in un valore "polimorfo" vector, tutti gli elementi sarebbero adiacenti in memoria (con solo il riempimento intermedio necessario per l'allineamento corretto).

Ora, è possibile se si è disposti a fornire un elenco completo di tutti i tipi che si inseriranno nel contenitore in fase di compilazione. L'implementazione più semplice sarebbe quella di utilizzare un'unione di tutti i tipi possibili come tipo del backing array, che garantirebbe dimensioni e allineamento appropriati, e lo stesso O (1) accesso per indice, al costo di uno spazio sprecato sugli elementi di tipi più piccoli. Posso entrare in questo con più dettagli se vuoi.

Se l'elenco dei tipi è ora noto in anticipo o se non si desidera tale tipo di overhead, è necessario mantenere un indice separato di puntatori (o offset dall'inizio del backing store) a elementi, in modo da poter eseguire l'accesso O (1). Inoltre, dati i problemi di allineamento, non sono sicuro di poterlo fare anche in C++ 03 completamente portatile, sebbene sia possibile farlo in C++ 0x.