Discussion :

[bertry]

Salut à tous,

Je réapprends à programmer en C++ en lisant Penser en C++ et je bloque sur l’exercice 9 du chapitre 14 :

Héritez une classe StringVectorde vector<void*>et redéfinissez les fonctions membres push_back( )et operator[]pour accepter et produire des string*. Qu'est-ce qui arrive si vous essayez de push_back( )un void*?

Ce qui me pose problème c'est la redéfinition de operator[] ( Rien ne vous empêche de donner aussi vôtre avis sur le redéfinition de push_back, si nécessaire ): Je n'arrives pas à comprendre comment renvoyer une référence sur un std::string*

Voici mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include <vector>
#include <iostream>
 
class StringVector : public std::vector<void*> {
public:
	void push_back ( std::string* s );
	std::string*& operator [] ( size_type n );
};
 
void StringVector::push_back ( std::string* spt ) {
	std::vector<void*>::push_back ( static_cast<void*>(spt) );
}
 
std::string*& StringVector::operator [] ( size_type n ) {
	return (static_cast<std::string*>(this->vector<void*>::operator [] ( n )));
}
 
void main () {
	StringVector sv;
 
	//Test de push_back
	std::string* spt = new std::string ( "abc" );
	sv.push_back ( spt );
	spt = new std::string ( "def" );
	sv.push_back ( spt );
	spt = new std::string ( "ghi" );
	sv.push_back ( spt );
 
	std::cout << "iterator :" << std::endl;
	for ( StringVector::iterator it = sv.begin(); it != sv.end(); ++it )
		std::cout << (static_cast<std::string*>(*it))->data() << std::endl;
 
	//Test de operator []
	std::cout << "operator [] :" << std::endl;
	for ( unsigned int i = 0; i < sv.size(); ++i ) {
		std::cout << i << " = " << sv[i] << std::endl;
	}
 
	system ("pause");
}

et l'erreur de compilation ligne 15 :

error C2440: 'return'*: impossible de convertir de 'std::string *' en 'std::string *&'

[Steph_ng8]

Salut.

Personnellement, j'ai un message d'erreur un peu plus explicite :

erreur: invalid initialization of non-const reference of type ‘std::string*& {aka std::basic_string<char>*&}’ from an rvalue of type ‘std::string* {aka std::basic_string<char>*}’

En gros, ça dit que tu essaies de créer une référence sur une std::string temporaire, qui de plus a une durée de vie inférieure à la référence que tu veux créer.

Tu dois te dire que std::vector<void*>::operator[] retourne un void*&, et non pas un void*.
À partir de là, on peut être tenté de modifier le cast par : static_cast<std::string*&>.

Sauf que ça ne fonctionne pas non plus :

erreur: invalid static_cast from type ‘void*’ to type ‘std::string*& {aka std::basic_string<char>*&}’

Le problème vient du type de cast utilisé.
S'il est très simple de transtyper n'importe quel type de pointeur vers un void*, même implicitement, l'inverse est faux.
Il faut indiquer explicitement que l'on veut travailler sur des données de types différents, bien que liés, et pour cela le static_cast ne suffit pas.
Il faut utiliser à la place l'opérateur reinterpret_cast.

Je ne m'étends pas plus sur le sujet, tu le verras en temps voulu si ce n'est pas encore fait.
Au cas où, cette entrée de la FAQ peut t'être utile :
Comment effectuer une conversion de type explicite (cast) ?

Bon courage !

[bertry]

Merci steph ,

J'ai remplacé ça

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

return (static_cast<std::string*>(this->vector<void*>::operator [] ( n )));

par ça

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

return (reinterpret_cast<std::string*&>(this->vector<void*>::operator [] ( n )));

et ça semble fonctionner : je n'avais pas compris qu'il fallait utiliser un reinterpret_cast

[Steph_ng8]

Oui, les histoires de transtypage en C++, ce n'est pas évident au départ.
Mais une fois qu'on a fait quelques erreurs, on a compris le truc !

Bonne continuation !

[Emmanuel Deloget]

Pour te souvenir, T a = static_cast<T>(b) ne fonctionne que si T a(b) est une expression valide. reinterpre_cast<> fonctionne systématiquement, const_cast<> ne fonctionne que si on change (enlève ou ajoute) un qualifier cv (const, volatile ou les deux), et dynamic_cast<> ne fonctionne que pour faire un cast dans une hiérarchie de classe.