Kontener kowariancji w C++

Question

Wiem, że C++ nie obsługuje kowariancji dla elementów kontenerów, tak jak w Javie lub C#. Więc następujący kod prawdopodobnie jest niezdefiniowane zachowanie:

#include <vector> 
struct A {}; 
struct B : A {}; 
std::vector<B*> test; 
std::vector<A*>* foo = reinterpret_cast<std::vector<A*>*>(&test); 

Nic więc dziwnego, że otrzymała downvotes gdy sugeruje to rozwiązanie another question.

Ale jaka część standardu C++ dokładnie mówi mi, że spowoduje to niezdefiniowane zachowanie? Gwarantuje to, że zarówno wskaźniki std::vector<A*> jak i std::vector<B*> przechowują swoje wskaźniki w ciągłym bloku pamięci. Gwarantuje to również, że sizeof(A*) == sizeof(B*). Wreszcie, A* a = new B jest całkowicie legalny.

Więc jakie złe duchy w standardzie wyczarowałem (poza stylem)?

Answer 1

Reguła naruszone tutaj jest udokumentowana w C++ 03 3,10/15 [basic.lval], która określa, co jest określane jako „nieformalnie ścisłe reguły aliasing”

Jeśli program próbuje uzyskać dostęp do zapisana wartość przedmiotu poprzez lwartością z innych niż jeden z następujących typów zachowanie jest niezdefiniowane:

• dynamiczny rodzaj obiektu,

• wersja cv wykwalifikowany dynamicznego typu obiektu,

• typ, który jest podpisany lub typ unsigned odpowiadający dynamicznego typu obiektu,

• typ, który jest podpisany lub niepodpisane typ odpowiadający CV- wykwalifikowany wersja dynamicznego typu obiektu,

• agregatem lub unia typ, który zawiera jeden z wyżej wymienionych typów wśród swoich członków (w tym rekurencyjnie, członek subaggregate lub zawartej unii),

• typ, który jest (możliwe bly cv-qualified) typ klasy podstawowej dynamicznego typu obiektu,

• char lub unsigned char type.

Krótko mówiąc, biorąc pod uwagę przedmiot, są dozwolone tylko w celu uzyskania dostępu do tego obiektu za pomocą wyrażenia, które ma jeden z typów na liście. W przypadku obiektu typu klasowego, który nie ma klas podstawowych, takich jak std::vector<T>, w zasadzie ogranicza się do typów wymienionych w punktach pierwszym, drugim i ostatnim.

std::vector<Base*> i std::vector<Derived*> są zupełnie niepowiązanych typy i nie można korzystać z obiektu typu std::vector<Base*> jakby to była std::vector<Derived*>.Kompilator może zrobić różne rzeczy, jeśli narusza tę zasadę, w tym:

• wykonywać różne optymalizacje na jednym niż z drugiej, albo

• rozplanować wewnętrzne członków jednej inaczej lub

• wykonywać optymalizacje zakładając, że std::vector<Base*>* nie może odnosić się do tego samego obiektu jako std::vector<Derived*>*

• kontroli użycie wykonawczych zapewniających t Kapelusz nie łamią ścisłego aliasingu regułę

[Może to również zrobić żadnej z tych rzeczy, a to może „pracować”, ale nie ma gwarancji, że będzie to „praca” i jeśli zmienisz kompilatory lub kompilator wersje lub ustawienia kompilacji, może przestać działać. Używam tutaj przerażających cytatów z jakiegoś powodu. :-)]

Nawet jeśli po prostu miałeś Base*[N], nie możesz użyć tej tablicy tak, jakby była to Derived*[N] (chociaż w tym przypadku użycie byłoby bezpieczniejsze, gdzie "bezpieczniejsze" oznacza "wciąż niezdefiniowane, ale mniej prawdopodobne, aby dostać się w kłopoty).

Answer 2

jesteś powołując się na zły duch reinterpret_cast <>.

chyba że naprawdę wiesz co robisz (to znaczy nie dumnie i nie pedantycznie) reinterpret_cast jest jedną z bram zło:

Jedyne bezpieczne użycie, jakie znam, to zarządzanie klasą es i struktury między wywołaniami funkcji C++ i C. Może jednak są inne.

Answer 3

Myślę, że łatwiej będzie pokazać, niż powiedzieć:

struct A { int a; }; 

struct Stranger { int a; }; 

struct B: Stranger, A {}; 

int main(int argc, char* argv[]) 
{ 
    B someObject; 
    B* b = &someObject; 

    A* correct = b; 
    A* incorrect = reinterpret_cast<A*>(b); 

    assert(correct != incorrect); // troubling, isn't it ? 

    return 0; 
} 

The (specyficzne) Emisja pokazał tutaj jest to, że kiedy robi „właściwą” konwersja, kompilator dodaje jakiś wskaźnik ajdustement w zależności od pamięci układ obiektów. Na reinterpret_cast nie jest przeprowadzana regulacja.

Przypuszczam, zrozumiesz dlaczego stosowanie reinterpet_cast powinny normalnie zostać wyrzucony z kodem ...

Answer 4

Ogólny problem z kowariancji w pojemnikach jest następujący:

Powiedzmy swoją obsadę będzie działać i być legalne (nie jest ale załóżmy, że jest na poniższym przykładzie):

#include <vector> 
struct A {}; 
struct B : A { public: int Method(int x, int z); }; 
struct C : A { public: bool Method(char y); }; 
std::vector<B*> test; 
std::vector<A*>* foo = reinterpret_cast<std::vector<A*>*>(&test); 
foo->push_back(new C); 
test[0]->Method(7, 99); // What should happen here??? 

więc trzeba także reinterpretacji-lanego C * do B * ...

Właściwie nie wiem jak to zrobić .NET i Java (myślę, że rzucają wyjątek podczas próby wstawienia C).