Discussion :

[deubelte]

Bonjour

Dans le livre de Scott Meyers, Effective C++, il y a un truc bizarre. Dans cette classe (cf Item 16)

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
template<class T> // template for classes associating
class NamedPtr { 
public:
NamedPtr(const string& initName, T *initPtr);
NamedPtr& operator=(const NamedPtr& rhs);
int get(int );
private:
string name;
T *ptr;
};
template<class T>int NamedPtr<T>::get(int o){
	return this->ptr[o];
}
template<class T>
NamedPtr<T>::NamedPtr(const string& initName, T *initPtr )
: name(initName), ptr(initPtr)
{}
 
template<class T>
NamedPtr<T>& NamedPtr<T>::operator=(const NamedPtr<T>& rhs)
{
if (this == &rhs)
return *this;
// assign to all data members
name = rhs.name; // assign to name
*ptr = *rhs.ptr;//for ptr, assign what's pointed to, not te pointer itself.
return *this; 
}

Il dit bien qu'il faut assigner l'objet pointé par ptr, pas le pointeur lui-même, dans la définition de l'opérateur =.

Alors j'ai essayé moi-même sa classe:

Code :

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

1
2
3
4
5
6
7
8
9
int main(){
	int *o=new int[2];	int *p=new(int[2]);
	o[0]=1;o[1]=3; p[0]=10;p[1]=33;
NamedPtr<int> A("ee",o);
NamedPtr<int> B("ede",p);
B=A;
cout<<B.get(0);
cout<<B.get(1);
}

et on voit bien dans ce cas là, que le renvoie du premier cout est 1, mais le second n'est pas 3, mais 33.
Ensuite, j'ai supprimé les deux déférences, et j'ai obtenu comme renvoie 0 et 3.

Je suis perplexe là, car je pense que son intention, c'est bien de faire en sorte que A et B soient égaux. Donc les données membres aussi.

[bruno_pages]

Bonjour,

attention il ne faut pas confondre un pointeur vers un int et un vecteur d'int

NamedPtr manipule des pointeurs, pas des vecteurs, il est donc logique que seul le premier élément du vecteur soit modifié

[deubelte]

NamedPtr manipule des pointeurs, pas des vecteurs, il est donc logique que seul le premier élément du vecteur soit modifié

Je crois savoir d'ou vient mon erreur, c'est que j'ai supposé que cela pointait nécessairement vers un tableau, ce qui n'est pas forcément le cas.

Je suis d'accord, mais je ne voit pas ce que cela change.
Dans le cas ou cela pointe uniquement vers un entier, pourquoi est il quand même nécessaire de déférencer l'objet?

Si on avait voulu modifié un tableau entier, comment aurait-on fait?
merci

[Arzar]

Je crois savoir d'ou vient mon erreur, c'est que j'ai supposé que cela pointait nécessairement vers un tableau, ce qui n'est pas forcément le cas.

Ça ne doit pas être le cas ! NamedPtr<T> est conçu pour manipuler un pointeur sur un objet de type T, pas un pointeur sur un tableau d'objet de type T. (ou tableau dynamique)

Si tu veux manipuler des tableaux dynamiques, il y a std::vector. Grossièrement un std::vector<T> possède en interne un pointeur pointant vers un tableau d'objet de type T + un int pour connaitre la taille du tableau. Son opérateur d'affectation parcours le tableau et copie élément par élément.

Dans le cas ou cela pointe uniquement vers un entier, pourquoi est il quand même nécessaire de déférencer l'objet?

Quel objet ? On déférence des pointeurs, pas des objets.
Et si tu copies directement le pointeur, alors les deux pointeurs sous-jacents aux NamedPtr pointeront vers le même objet (ici le même int). Comme le destructeur de NamedPtr fait un delete, lorsque les deux NamedPtr seront détruits il y aura un double delete sur le même pointeur -> segfault ou corruption mémoire.

[bruno_pages]

Dans le cas ou cela pointe uniquement vers un entier, pourquoi est il quand même nécessaire de déférencer l'objet?

je ne comprends pas, il n'est pas necessaire de déréférencé puisque comme vous l'aviez dit le premier entier valait bien 1 (et non 10)

Si on avait voulu modifié un tableau entier, comment aurait-on fait?

ce qu'il faut c'est que le type sur lequel vous pointez ai un opérateur d'affectation qui fasse ce que vous attendez, vous pouvez donc pas exemple utiliser std::vector

[deubelte]

Et si tu copies directement le pointeur, alors les deux pointeurs sous-jacents aux NamedPtr pointeront vers le même objet (ici le même int). Comme le destructeur de NamedPtr fait un delete, lorsque les deux NamedPtr seront détruits il y aura un double delete sur le même pointeur -> segfault ou corruption mémoire.

Ok, j'ai compris. C'est exactement le même problème qui arrive lorsque l'on ne met pas les constructeurs par copie.