make_unique et de transfert parfait

Pourquoi n'est-il pas std::make_unique modèle de fonction dans la norme C++11 de la bibliothèque? Je trouve

std::unique_ptr<SomeUserDefinedType> p(new SomeUserDefinedType(1, 2, 3));

un peu verbeux. Ne serait pas la suite être beaucoup plus agréable?

auto p = std::make_unique<SomeUserDefinedType>(1, 2, 3);

Ce masque la new bien et ne mentionne que le type une fois.

De toute façon, voici ma tentative de mise en œuvre de make_unique:

template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args)
{
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

Il m'a fallu un certain temps pour obtenir le std::forward choses à compiler, mais je ne suis pas sûr si elle est correcte. S'agit-il? Qu'est-ce exactement ne std::forward<Args>(args)... veux dire? Que fait le compilateur de cette?

  • Assez sûr que nous avons eu cette discussion avant... notez également que unique_ptr prend un deuxième paramètre de modèle qui vous devez en quelque sorte permettre - c'est différent de shared_ptr.
  • Peut-être que c'est parce qu'il est plutôt facile d'écrire vous-même? Alors qu'un make_unique() simplement roulés un new déclaration, ce n'est pas comme make_shared() qui n'est pas trivial à mettre en œuvre correctement (il alloue de l'espace pour le compte de référence et l'objet en même temps). Mais bon question de bien.
  • Je ne pense pas qu'il serait judicieux de paramétrer make_unique avec une coutume deleter, parce qu'évidemment il alloue via un bon vieux new et doit donc utiliser un bon vieux delete 🙂
  • C'est vrai. Donc, le projet de make_unique serait limitée à new allocation... eh bien, c'est très bien si vous voulez écrire, mais je peux voir pourquoi quelque chose comme ça ne fait pas partie de la norme.
  • En fait, j'aime utiliser un make_unique modèle depuis le constructeur de std::unique_ptr est explicite, et donc il est détaillé au retour unique_ptr à partir d'une fonction. Aussi, je préfère utiliser auto p = make_unique<foo>(bar, baz) que std::unique_ptr<foo> p(new foo(bar, baz)).
  • Comme alternative, vous pouvez écrire p.reset( nouveau SomeUserDefinedType(1, 2, 3) );
  • make_unique est à venir dans C++14, voir isocpp.org/blog/2013/04/trip-report-iso-c-spring-2013-meeting

InformationsquelleAutor fredoverflow | 2011-08-12
  1. 157

    Herb Sutter, président du C++ comité de normalisation, écrit sur son blog:

    Que C++11 ne comprend pas make_unique est en partie une supervision, et il sera presque certainement être ajouté dans le futur.

    Il donne également une mise en œuvre qui est identique à celle donnée par l'OP.

    Edit: std::make_unique est maintenant partie intégrante de C++14.

    • Un make_unique modèle de fonction ne prend pas en soi une garantie d'exception sûr des appels. Il s'appuie sur la convention, que l'appelant utilise. En revanche, la stricte statique type de contrôle (qui est la principale diff entre C++ et C) est construit sur l'idée de application sécurité, via des types. Et pour cela, make_unique peut être simplement une classe à la place de la fonction. Voir, par exemple, mon blog à partir de Mai 2010. C'est aussi liée à la discussion sur l'Herbe du blog.
    • Je n'ai pas tout suivi de votre commentaire. Comment est make_unique pas exception sûr? Comment en faire une classe de le rendre plus exception sûr? Héritant d'une classe qui n'est pas conçue pour être dérivée ne semble pas être une bonne idée pour moi en tout cas...
    • lire la plante blog pour comprendre l'exception d'un problème de sécurité. oublier "pas conçue pour être dérivée", c'est juste de la foutaise. au lieu de ma suggestion de faire make_unique une classe, maintenant, je pense qu'il est préférable de faire une fonction qui produit un make_unique_t, la raison, c'est un problème avec le plus pervers analyser :-).
    • Nous avons peut-être lire un autre article, parce que je viens de lire indique clairement que make_unique offre la forte exception de garantie. Ou peut-être vous sont un mélange de l'outil à son usage, dans ce cas n la fonction est exception coffre-fort. Envisager void f( int *, int* ){}, offre clairement le no throw garantie, mais par votre raisonnement, il n'est pas une exception sûr, car il peut être utilisé à mauvais escient. Pire, void f( int, int ) {} n'est pas une exception en sécurité!: typedef unique_ptr<int> up; f( *up(new int(5)), *up(new int(10)))...
    • il semble que votre point est que rien n'est exception en sécurité parce que tout peut être abusé de sorte qu'il est impliqué dans certains exception de code non sécurisé, et d'autre part, aussi que rien n'est exception dangereux car il peut théoriquement être utilisé à l'exception des moyens sûrs, et la troisième, que par l'autorité de l'article que vous consultez, make_unique comme par magie confère une exception de sécurité sur le code où il peut être appliqué. désolé, vous ne parviennent pas à me convaincre. comme je le vois aucun des trois points sont valables logique, et ils sont également un peu contradictoires.
    • de toute façon, je ne vois pas l'utilité de ne pas avoir un plus sûr à utiliser make_unique fonction. pourquoi êtes-vous en faisant valoir qu'il devrait être plus risqué?
    • J'ai demandé à l'exception des questions dans make_unique mis en œuvre comme ci-dessus et vous m'indiquer un article de Sutter, l'article que mon google-fu m'a indiqué que les états make_unique offre le fort exception de garantie, ce qui contredit votre affirmation ci-dessus. Si vous avez un autre article que j'ai suis intéressé à le lire. Donc ma question d'origine des peuplements Comment est make_unique (tel que défini ci-dessus) ne font pas exception sûr? (Note: oui, je pense que make_unique améliore exception de sécurité dans les lieux où il peut être appliqué)
    • ... aussi, je ne suis pas la poursuite de moins sûr à utiliser make_unique fonction. D'abord je ne vois pas en quoi c'est dangereux, et je ne vois pas comment l'ajout d'un type supplémentaire serait de le faire sûr. Ce que je sais, c'est que je m'intéresse à comprendre les questions que cette mise en œuvre peut avoir --je ne vois pas tout--, et comment une alternative serait de les résoudre. Quelles sont les conventions que make_unique dépend? Comment voulez-vous utiliser la vérification de type à faire respecter la sécurité? Ce sont les deux questions auxquelles j'aimerais une réponse.
    • eh bien, ok. tout d'abord, à l'exception d'un problème de sécurité est pas à propos de make_unique. c'est à propos de l'utilisation d'une fonction déclarée avec deux ou plus de deux unique_ptr args. make_unique est juste un outil que l'utilisateur d'un tel dangereuse la fonction peut utiliser pour faire un appel coffre-fort. l'utilisateur peut aussi le faire dans d'autres façons, mais toujours la fonction est dangereux d'une façon originale: il nécessite une certaine compréhension profonde d'écrire plus de faire des appels en sécurité. au lieu de cela les arguments formels peuvent être de type il faut utilisation de make_unique, ou explicites, en passant de la propriété des objets existants. ce qui est bien plus robuste.
    • Ok, donc ce que vous proposez est en train de changer l'interface de prendre un make_unique_t que les forces de l'utilisation de make_unique et en interne détient le unique_ptr pour s'assurer que les appelants est utiliser make_unique qui est fort. Au départ, j'ai compris que vous avez demandé make_unique de ne pas être/faire l'appel exception coffre-fort. Concernant ce type supplémentaire, le problème, c'est que vous serez alors restreindre les utilisations de votre fonction de mémoire qui a été allouée, qui permettrait de limiter l'utilisabilité (vous pouvez également fournir un make_unique variante qui est capable de se déplacer à partir d'un déjà construit unique_ptr)
    • oui, à peu près. comme je l'ai écrit, certains "explicite le passage de la propriété" doit être pris en charge. comme je n'ai pas écrit, il n'y a pas beaucoup d'espace dans ces commentaires, make_unique_ptr_t<T> est le plus naturellement une classe dérivée de unique_ptr<T>, et puis il a juste unique_ptr<T> de la classe de base sous-objet et n'ajoute pas possible frais généraux -- c'est à dire, c'est gratuit.
    • Le lien a été à la la solution pour le Gourou de la Semaine le Problème n ° 102, herbsutter.com/2011/12/02/.... La solution semble avoir été retirée du site.

    InformationsquelleAutor Johan Råde
  2. 77

    Nice, mais Stephan T. Lavavej (mieux connu sous le nom STL) a une meilleure solution pour make_unique, qui fonctionne correctement pour le choix de la version.

    #include <memory>
#include <type_traits>
#include <utility>

template <typename T, typename... Args>
std::unique_ptr<T> make_unique_helper(std::false_type, Args&&... args) {
  return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

template <typename T, typename... Args>
std::unique_ptr<T> make_unique_helper(std::true_type, Args&&... args) {
   static_assert(std::extent<T>::value == 0,
       "make_unique<T[N]>() is forbidden, please use make_unique<T[]>().");

   typedef typename std::remove_extent<T>::type U;
   return std::unique_ptr<T>(new U[sizeof...(Args)]{std::forward<Args>(args)...});
}

template <typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args) {
   return make_unique_helper<T>(std::is_array<T>(), std::forward<Args>(args)...);
}

    Ceci peut être vu sur son Noyau en C++ 6 vidéo.

    Une version mise à jour de la STL version de make_unique est maintenant disponible en N3656. Cette version ai adopté dans le projet de C++14.

    • make_unique est proposée par Stephen T Lavalej dans la prochaine std mise à jour.
    • Voici une comme pour lui parler de l'ajouter. channel9.msdn.com/Series/C9-Lectures-Stephan-T-Lavavej-Core-C-/...
    • pourquoi faire toutes les modifications inutiles xeo, il était bien comme il était. Ce code a été aussi exactement que Stephen T. Lavalej le mettre, et il travaille pour dinkumware qui maintient la bibliothèque std. Vous avez déjà commenté sur le mur, de sorte que vous devriez connaître.
    • La mise en œuvre de make_unique devrait aller dans un en-tête. Les en-têtes ne devrait pas importer un espace de noms (voir Point n ° 59 de Sutter/Alexandrescu de "C++ Normes de Codification" du livre). Xeo les changements d'aider à éviter d'encourager les mauvaises pratiques.
    • malheureusement, pas pris en charge par VC2010, même VC2012 je pense, deux pas en charge varidic tempalte paramètre
    • Cette mise en œuvre est maintenant dans VC2013, qui a de nouveau été libéré. Il sera également inclus dans la dernière version de l'autre C++ IDE qui permettent de C++13.

    InformationsquelleAutor tominator
  3. 19

    std::make_shared n'est pas seulement un raccourci pour std::shared_ptr<Type> ptr(new Type(...));. Il fait quelque chose qui vous ne peut pas faire sans elle.

    Afin de faire son travail, std::shared_ptr doit allouer un suivi bloc en plus de détenir le stockage pour le pointeur. Cependant, parce que std::make_shared alloue de l'objet réel, il est possible que std::make_shared alloue à la fois l'objet et le suivi de bloc dans le même bloc de mémoire.

    Ainsi, alors que std::shared_ptr<Type> ptr = new Type(...); serait de deux allocations de mémoire (un pour le new, l'un dans le std::shared_ptr suivi bloc), std::make_shared<Type>(...) serait d'allouer un bloc de mémoire.

    Qui est important pour de nombreux utilisateurs potentiels de std::shared_ptr. La seule chose un std::make_unique serait faire est d'être un peu plus pratique. Rien de plus que cela.

    • Il n'est pas nécessaire. Allusion, mais pas obligatoire.
    • Ce n'est pas que pour plus de commodité, il serait également améliorer l'exception de sécurité dans certains cas. Voir Kerrek SB réponse pour cela.
    InformationsquelleAutor Nicol Bolas
  4. 19

    Alors que rien ne vous empêche de rédiger votre propre helper, je crois que la principale raison de make_shared<T> dans la bibliothèque, c'est qu'il crée un autre type interne de pointeur partagé que shared_ptr<T>(new T), qui est différemment affectés, et il n'y a aucun moyen d'y parvenir sans l'dédié helper.

    Votre make_unique wrapper sur l'autre main est simple sucre syntaxique autour d'un new expression, si bien qu'elle puisse être agréable à l'œil, il n'apporte rien new à la table. Correction: ce n'est pas vrai, en fait: Avoir un appel de fonction pour envelopper le new expression fournit exception de sécurité, par exemple dans le cas où vous appelez une fonction void f(std::unique_ptr<A> &&, std::unique_ptr<B> &&). Ayant deux premières news qui sont non séquencés à l'égard l'un de l'autre signifie que si une nouvelle expression échoue avec une exception, les autres peuvent avoir des fuites de ressources. Quant à savoir pourquoi il n'y a pas make_unique dans la norme: Il a été tout simplement oublié. (Ce qui arrive de temps en temps. Il n'y a également aucun std::cbegin dans la norme, même si il devrait être une).

    Également noter que unique_ptr prend un deuxième paramètre de modèle qui vous devez en quelque sorte permettre; ce qui est différent de shared_ptr, qui utilise le type d'effacement de magasin personnalisé deleters sans faire partie de la type.

    • Que voulez-vous dire exactement par "différent interne tapez"?
    • Le pointeur partagé est relativement compliqué de classe; en interne, il garde un polymorphe de référence du bloc de contrôle, mais il ya plusieurs différents types de blocs de contrôle. shared_ptr<T>(new T) utilise l'un d'eux, make_shared<T>() utilise un autre. Permettant que c'est une Bonne Chose, et la version partagée est dans un certain sens le plus léger de poids pointeur partagé que vous pouvez obtenir.
    • alloue un bloc de mémoire dynamique pour suivre le nombre et le "broyeur" action lorsque vous créez un shared_ptr. Si vous passez le pointeur de façon explicite, il a besoin de la création d'un "nouveau" bloc, si vous utilisez make_shared il peut bundle votre de l'objet et le satellite de données dans un seul bloc de mémoire (un new) ce qui accélère l'allocation/désallocation, moins de fragmentation, et (normalement) un meilleur comportement du cache.
    • Je pense que j'ai besoin de re-regarder les shared_ptr et les amis...
    • est la seule drôle de bête, à cause de cette information étrangère, il doit suivre (comte et de la deleter). Les autres sont, heureusement, beaucoup plus simple à analyser.
    • En effet, unique_ptr est beaucoup plus léger de classe -- je dirais que make_shared est aussi proche de la notion de unique_ptr que vous pouvez obtenir, mais seulement qu'il utilise un allocateur plutôt que de laisser l'utilisateur choisir la fonction d'allocation.
    • -1 "Votre make_unique wrapper sur l'autre main est simple sucre syntaxique autour d'une nouvelle expression, si bien qu'elle puisse être agréable à l'œil, il n'apporte rien de nouveau à la table." est faux. Il apporte la possibilité d'exception sûr l'invocation de la fonction. Il n'apporte pas une garantie; pour cela, il faudrait classe de sorte que les arguments formels pourrait être déclarée de cette classe (Herbe décrit que comme la différence entre l'opt-in et opt-out).
    • Ouais, c'est vrai. Depuis, j'ai compris. Je vais modifier la réponse.

    InformationsquelleAutor Kerrek SB
  5. 13

    En C++11 ... est utilisé (dans le modèle de code) pour le "pack d'extension" trop.

    La condition est que vous l'utiliser comme un suffixe d'une expression contenant un non développés pack de paramètres, et il sera tout simplement appliquer l'expression de chacun des éléments du pack.

    Par exemple, la construction de votre exemple:

    std::forward<Args>(args)... -> std::forward<int>(1), std::forward<int>(2),
                                                     std::forward<int>(3)

std::forward<Args...>(args...) -> std::forward<int, int, int>(1,2,3)

    Le dernier étant incorrect, je pense.

    Également, pack d'arguments peut pas être transmis à une fonction non développés. Je ne suis pas sûr au sujet d'un paquet de paramètres du modèle.

    • Agréable de voir ce précisée. Pourquoi ne pas inclure les variadic paramètre du modèle, trop?
    • parce que je ne suis pas sûr au sujet de son étrange syntaxe, et je ne sais pas si beaucoup de gens ont joué avec. Donc je vais garder ce que je sais. Il peut justifier le c++ entrée de la FAQ, si quelqu'un était motivé et compétent, assez, pour les variadic syntaxe est tout à fait complète.
    • La syntaxe est std::forward<Args>(args)..., qui s'étend à forward<T1>(x1), forward<T2>(x2), ....
    • Oh, je pensais que vous parliez de la pure type de manipulations. Je ne vois pas la nécessité de mettre le type de la T1... serait venu de nulle part.
    • :Je pense que forward fait toujours besoin d'un paramètre du modèle, n'est-ce pas?
    • Je ne le pense pas, ideone semble d'accord ideone.com/9cxH6 (mais alors, je ne voudrais pas prendre à la valeur nominale).
    • Hmmm, je ne suis pas 100% sur, mais si vous ne spécifiez pas le paramètre, il se pourrait que vous êtes de ne pas obtenir ce que vous voulez -- c'est à dire le paramètre peut être dérivée à tort. Il avait encore de la compilation, mais par exemple, vous pouvez forcer une rvalue pour devenir une lvalue. Je n'en suis pas sûr.
    • Si vous ne spécifiez pas le paramètre de modèle dans std::forward, il ne compile pas. Il a été conçu à l'erreur dans cette voie.
    • merci! Semble être un gcc glitch sur ideone alors, je vais patcher mon exemple alors 🙂
    • ideone peut ne pas avoir ramassé parce que vous n'avez pas instancier make_unique dans votre exemple.
    • la droite! Forcer l'instanciation déclenche l'avertissement (ideone.com/GDNHb)

    InformationsquelleAutor Matthieu M.
  6. 5

    Inspiré par la mise en œuvre par Stephan T. Lavavej, j'ai pensé qu'il pourrait être sympa d'avoir un make_unique que pris en charge tableau des extensions, c'est sur github et j'aimerais obtenir des commentaires sur elle. Il vous permet de le faire:

    //create unique_ptr to an array of 100 integers
auto a = make_unique<int[100]>();

//create a unique_ptr to an array of 100 integers and
//set the first three elements to 1,2,3
auto b = make_unique<int[100]>(1,2,3);
    InformationsquelleAutor Nathan Binkert