Il peut y avoir plusieurs raisons. Pour en citer quelques-uns:
- Les pointeurs intelligents sont devenus une partie de la norme tout récemment. Jusque-là, ils faisaient partie d'autres bibliothèques
- Leur utilisation principale est d'éviter les fuites de mémoire; de nombreuses bibliothèques n'ont pas leur propre gestion de la mémoire; Généralement, ils fournissent des utilitaires et des API
- Ils sont implémentés comme wrapper, car ce sont en fait des objets et non des pointeurs. Ce qui a un coût supplémentaire en temps / espace, par rapport aux pointeurs bruts; Les utilisateurs des bibliothèques peuvent ne pas vouloir avoir de tels frais généraux
Edit : L'utilisation de pointeurs intelligents est entièrement le choix du développeur. Cela dépend de divers facteurs.
Dans les systèmes à performances critiques, vous ne souhaiterez peut-être pas utiliser de pointeurs intelligents qui génèrent une surcharge
Le projet qui a besoin de la compatibilité descendante, vous ne voudrez peut-être pas utiliser les pointeurs intelligents qui ont des fonctionnalités spécifiques à C ++ 11
Edit2 Il y a une série de plusieurs votes négatifs en l'espace de 24 heures en raison du passage ci-dessous. Je ne comprends pas pourquoi la réponse est rejetée même si ci-dessous n'est qu'une suggestion complémentaire et non une réponse.
Cependant, C ++ vous facilite toujours l'ouverture des options. :) par exemple
template<typename T>
struct Pointer {
#ifdef <Cpp11>
typedef std::unique_ptr<T> type;
#else
typedef T* type;
#endif
};
Et dans votre code, utilisez-le comme:
Pointer<int>::type p;
Pour ceux qui disent qu'un pointeur intelligent et un pointeur brut sont différents, je suis d'accord avec cela. Le code ci-dessus était juste une idée où l'on peut écrire un code qui est interchangeable juste avec un #define, ce n'est pas une contrainte ;
Par exemple, T*doit être supprimé explicitement, mais pas un pointeur intelligent. Nous pouvons avoir un modèle Destroy()pour gérer cela.
template<typename T>
void Destroy (T* p)
{
delete p;
}
template<typename T>
void Destroy (std::unique_ptr<T> p)
{
// do nothing
}
et utilisez-le comme:
Destroy(p);
De la même manière, pour un pointeur brut, nous pouvons le copier directement et pour un pointeur intelligent, nous pouvons utiliser une opération spéciale.
Pointer<X>::type p = new X;
Pointer<X>::type p2(Assign(p));
Où Assign()est comme:
template<typename T>
T* Assign (T *p)
{
return p;
}
template<typename T>
... Assign (SmartPointer<T> &p)
{
// use move sematics or whateve appropriate
}