Il peut y avoir de nombreuses raisons. Pour la liste de quelques-uns d'entre eux:
- Les pointeurs intelligents sont devenus partie intégrante de la norme, tout récemment. Jusqu'alors ils
faisaient partie des autres bibliothèques
- Leur utilisation principale est pour éviter les fuites de mémoire; de nombreuses bibliothèques
ne disposent pas de leur propre gestion de la mémoire; en Général, ils fournissent
utilitaires et les Api
- Ils sont mis en œuvre comme wrapper, car ils sont en fait des objets et non des pointeurs. Qui a plus de temps/coût de l'espace, par rapport à raw pointeurs; Les utilisateurs des bibliothèques peut ne pas vouloir avoir de ces frais généraux
Edit: l'Utilisation des pointeurs intelligents est un tout développeur de choix. Elle dépend de plusieurs facteurs.
Dans la performance des systèmes critiques, vous ne voulez pas utiliser puce
les pointeurs qui génère des frais généraux
Le projet qui a besoin de la compatibilité descendante, vous ne voulez pas
pour utiliser les pointeurs intelligents qui a le C++11 caractéristiques spécifiques
Edit2 Il est une chaîne de plusieurs downvotes en l'espace de 24 heures en raison de dessous de passage. Je n'arrive pas à comprendre pourquoi la réponse est downvoted même si, ci-dessous est juste un add-on de la suggestion et non une réponse.
Cependant, C++ facilite toujours vous d'avoir les options ouvertes. :) par exemple
template<typename T>
struct Pointer {
#ifdef <Cpp11>
typedef std::unique_ptr<T> type;
#else
typedef T* type;
#endif
};
Et dans votre code à utiliser:
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ù on peut écrire un code qui est interchangeable avec juste un #define, ce n'est pas une contrainte;
Par exemple, T* doit être supprimé explicitement, mais un pointeur intelligent ne. On peut avoir un type "modèle" Destroy() pour le gérer.
template<typename T>
void Destroy (T* p)
{
delete p;
}
template<typename T>
void Destroy (std::unique_ptr<T> p)
{
// do nothing
}
et l'utiliser comme:
Destroy(p);
De la même manière, pour un pointeur brut, nous pouvons copier directement et de pointeur intelligent, nous pouvons utiliser l'opération spéciale.
Pointer<X>::type p = new X;
Pointer<X>::type p2(Assign(p));
Où Assign() est que:
template<typename T>
T* Assign (T *p)
{
return p;
}
template<typename T>
... Assign (SmartPointer<T> &p)
{
// use move sematics or whateve appropriate
}
