Coulée de pointeurs vers des objets

Question

Si B est la sous-classe A.

Et je en main():

B** b = new B*[10]; 
... // some algorithm that does b[i] = new B(..); 

J'ai un tableau de pointeurs vers des objets B.

, j'ai une fonction:

void f(A** foo); 

Si dans le principal, je fais: f(b); je reçois un avertissement, mais il est évident que je fais: f((A**)b);, je ne. Le (A**) est un peu méchant. Je me demandais s'il y avait une manière plus élégante en C++ qu'au moins faire la vérification de type comme dynamic_cast. Je veux foo pour trier (seulement en utilisant des swaps) des tableaux d'objets de type A ou sous-classe .. donc faites un algorithme de tri générique. J'espère que vous comprenez mieux mon problème.

Answer 1

A** et B** sont deux types totalement différents. Tout simplement parce qu'il y a une conversion implicite de B* à A* ne signifie pas que la même conversion existe de B** à A** Voir cette FAQ Converting Derived* → Base* works OK; why doesn't Derived** → Base** work? pour plus de détails.

Answer 2

Le cas est incorrect. Supposons que la fonction est (parfaitement légitime):

void f(A** foo) 
{ 
    foo[0] = new A(); 
} 

maintenant si vous avez passé un B** instead, le premier pointeur (que le compilateur est certain est un B*) est devenu tout à coup un A* - type terrible violation, Hard- accident probable bientôt.

A** - pas de const en vue, veuillez noter! - désigne un pointeur mutable pointant vers pointeurs modifiables, ce qui explique pourquoi la définition de l'un de ces pointeurs sur un nouveau pointeur sur A est parfaitement OK. Mais vous ne pouvez pas le faire si vous avez réellement un B** - ces pointeurs doit toujours à B (ou sous-classe de celui-ci), pas-A, un superclasse de B. Oui, c'est la covariance contre la contre-variance encore une fois - sous la mutabilité (pas de const en vue), c'est vraiment un champ de mines. Pourquoi ne pas coller dans tous les const vous pouvez éventuellement vous permettre? Cela indiquera également quels cas ont du sens dans quelles circonstances!

Answer 3

Il y a une raison pour laquelle vous recevez un avertissement ou une erreur si vous essayez de lancer implicitement un B** vers un A**: ce n'est pas prudent de le faire. En vous référant au tableau A**, vous pouvez placer des pointeurs sur les objets A à l'intérieur. Pour un tableau de B*, cela est faux et, par conséquent, la distribution est dangereuse.

Peut-être f serait mieux une fonction de modèle:

template<typename T> 
void f(T **array) { 
    ... 
} 

Answer 4

Si B est une sous-classe de A alors vous pouvez toujours trier une liste de pointeurs vers des objets de type B même si le type du tableau est " tableau de pointeurs à A ".

E.g.

A** ptrToBs = new A*[10]; 

ptrToBs[0] = &b01; // ... or new B 
ptrToBs[1] = &b02; 

// ... 

ptrToBs[9] = &b10; 

f(ptrToBs); 

Cependant, ce que vous dites que vous voulez est un algorithme générique pour échanger des objets, pas des pointeurs en fonction de la valeur des objets pointés. Dans ce cas, il vaut mieux avoir un modèle de fonction.

template< class T > 
void f(T* t) 
{ 
    // ... 
} 

De cette façon, vous pouvez trier un tableau de A ou et tableau de B sans avoir à un tableau de pointeur exactement le bon type; vous pouvez simplement trier un tableau d'objets A ou B ou toute autre chose à condition que le type d'objets que vous triez supporte les opérations que vous utilisez dans votre algorithme de tri.

Typiquement, vous voudriez passer la taille du tableau ou un pointeur à la fin du tableau pour que l'algorithme n'ait pas à assumer la taille du tableau.

template< class T > void f(T* arr, std::size_t size); 

ou

template< class T > void f(T* first, T* last);