Discussion :

[guillaume07]

IL est dit un peu partout que les ptr les plus utilisés sont ceux du type shared_ptr, hors je ne vois pas trop l'intérêt d'avoir un mécanisme de partage de ptr, bien souvent on a un ptr et il y a un 'seul' propriétaire, je me trompe ?

[Nogane]

Bonjour,
C'est exact. Si un scoped_ptr suffit, il est préférable de l'utiliser a la place du shared_ptr. (Et fortement préférable a l'auto_ptr)

PS: Sauf si c'est pour faire une "implémentation privé", car la seul le shared_ptr le permettra. (l'auto_ptr aussi, mais la c'est le drame garantie)

[guillaume07]

en faite les cas d'utilisations des shared m'ont l'air très restreint

[Nogane]

Pas tant que ca. Une utilisation très courante, c'est pour faire un conteneur de shared_ptr. Style vector<shared_ptr<MaClass> >. En effet, le vector requiert un objet copyable. Le scoped_ptr ne l'est pas.
Autre exemple, on as un cache d'images(par exemple) en mémoire. Chaque images ne doit pas être supprimée tant qu'elle est utilisée au moins a un endroit dans le programme. C'est un cas typique de propriété partagé, et c'est très courant.

[guillaume07]

Pas tant que ca. Une utilisation très courante, c'est pour faire un conteneur de shared_ptr. Style vector<shared_ptr<MaClass> >. En effet, le vector requiert un objet copyable. Le scoped_ptr ne l'est pas.
Autre exemple, on as un cache d'images(par exemple) en mémoire. Chaque images ne doit pas être supprimée tant qu'elle est utilisée au moins a un endroit dans le programme. C'est un cas typique de propriété partagé, et c'est très courant.

oui mais le cas du vector il y a ptr_container

[Goten]

en faite les cas d'utilisations des shared m'ont l'air très restreint

Non les shared_ptr sont bien plus utilisé et ont un domaine plus large. Tout ce qui est passage par valeur (retour de fonction), le scoped_ptr ça le fait pas.

[guillaume07]

Non les shared_ptr sont bien plus utilisé et ont un domaine plus large. Tout ce qui est passage par valeur (retour de fonction), le scoped_ptr ça le fait pas.

Code :

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

1
2
3
4
5
6
7
8
9
10
boost::scoped_ptr<int> add( ) 
{ 
  return boost::scoped_ptr<int>(new int(1)); 
} 
 
int main() 
{ 
	boost::scoped_ptr<int> sp = add();
	getchar();
}

c'est là où c'est un peu space car dans un code comme celui ci où est la notion de partage, au retour de add seul sp est propriétaire du pointeur, hors là on est obliger d'utiliser du shared

EDIT: il faut peut être plutôt utiliser un auto_ptr alors

[Goten]

Ton code compilera pas. Parce que justement le scoped_ptr est pas fait pour ça. (c'est juste une enveloppe RAII-sante)
Pour ça que quand tu dis que c'est le plus utile, je te dis que non, car en général quand j'ai a utiliser un pointeur c'est justement que je veux pouvoir étendre ça durée de vie et le passer de "main en main"

[guillaume07]

Ton code compile pas hein. Parce que justement le scoped_ptr est pas fait pour ça. (c'est juste une enveloppe RAII-sante)
Pour ça que quand tu dis que c'est le plus utile, je te dis que non, car en général quand j'ai a utiliser un pointeur c'est justement que je veux pouvoir étendre ça durée de vie et le passer de "main en main"

je sais que ça compile pas,c'était pour l'exemple

Mais dans ce cas là un un auto_ptr est peut être le bon outil ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
std::auto_ptr<int> add( ) 
{ 
  return std::auto_ptr<int>(new int(1)); 
} 
 
int main() 
{ 
	std::auto_ptr<int> sp = add();
	std::cout << *sp;
	getchar();
}

[Nogane]

C'est en effet dans ce cas uniquement que l'auto_ptr est utile. Mais le shared_ptr est quand même plus safe.

[guillaume07]

C'est en effet dans ce cas uniquement que l'auto_ptr est utile. Mais le shared_ptr est quand même plus safe.

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
 
std::auto_ptr<int> add( ) 
{ 
  return std::auto_ptr<int>(new int(1)); 
} 
 
void  add(std::auto_ptr<int> f ) 
{ 
 
} 
int main() 
{ 
	std::auto_ptr<int> sp = add();
	add(sp);
	std::cout << *sp;
	getchar();
}

effectivement ça évite ce genre de situation, mais l'auto_ptr conserve donc une propriété intéressante suivant le cas que les autres smart ptr n'ont pas

[Nogane]

Oui. En attendant le C++1x et son unique_ptr.

[guillaume07]

D'ailleurs une petite question concernant l'implémetation d'auto ptr :

Code :

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

1
2
3
4
5
6
7
8
9
    template <class X>
    class auto_ptr {
    public:
        typedef X element_type;
 
        // 20.4.5.1 construct/copy/destroy:
        explicit           auto_ptr(X* p =0) throw();
                           auto_ptr(auto_ptr&) throw();
        template <class Y> auto_ptr(auto_ptr<Y>&) throw();

A quoi sert le dernier constructeur ?

[Goten]

Conversion. (si elle existe entre X et Y)

[guillaume07]

ça s'utilise comment , le code suivant ne passe pas :

Code :

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

1
2
3
 
	std::auto_ptr<short> p;
	std::auto_ptr<int> m(p);

[JolyLoic]

Conversion. (si elle existe entre X et Y)

J'aurais dit :
Conversion. (si elle existe entre X* et Y*)

[Goten]

ça s'utilise comment , le code suivant ne passe pas :

Code :

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

1
2
3
 
	std::auto_ptr<short> p;
	std::auto_ptr<int> m(p);

C'est parce que je fourché sur le clavier, cf la correction de Loic.

@ Loic : c'est ce que je voulais dire... si j'avais pas eu la tête en l'air quand j'ai posté.

[guillaume07]

C'est parce que je fourché sur le clavier, cf la correction de Loic.

@ Loic : c'est ce que je voulais dire... si j'avais pas eu la tête en l'air quand j'ai posté.

je dois changer quoi dans les deux lignes pour que ça marche , je suis à l'ouest pour le coup

[JolyLoic]

je dois changer quoi dans les deux lignes pour que ça marche , je suis à l'ouest pour le coup

Changer quoi ? Ton objectif... short* et int* ne sont pas compatible, il n'y a pas de raison qu'un xxx_ptr<short> ou un xxx_ptr<int> le soient...

Un exemple qui marche (aux erreurs de frappe près) :

Code :

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

1
2
3
4
5
class A{};
class B : public A {};
 
auto_ptr<B> ptrB(new B);
auto_ptr<A> ptrA(ptrB);

[yan]

Salut.
Y as t'il une réelle différence entre scoped_ptr et auto_ptr?
Si j'ai bien compris scoped_ptr n'est pas copiable alors que auto_ptr oui(mais c'est un transfert de pointeur et non une copie)