Comment fonctionne la bibliothèque standard de mettre en œuvre des std::swap?

Quelle est la fonction d'échange de la mise en œuvre de la STL? Est-il aussi simple que cela:

template<typename T> void swap(T& t1, T& t2) {
    T tmp(t1);
    t1=t2;
    t2=tmp;
}

Dans d'autres postes, ils parlent spécialisé cette fonction pour votre propre classe. Pourquoi aurais-je besoin de faire cela? Pourquoi ne puis-je pas utiliser le std::swap fonction?

  • C'est exactement comment std::swap a été implémenté en C++03, en C++11, il est T tmp(std::move(t1)); t1 = std::move(t2); t2 = std::move(tmp); que ce sera plus efficace que de copier pour certains types.
  • Il n'existe pas de "la bibliothèque standard". Il y a un tas d'implémentations, choisissez-en un ou quelques-uns et le regarder.
  • Chacune de ces implémentations met en œuvre "Le C++ standard Library" (voir §17.1/1
  • Il est, cependant, pas "le TSL". La Bibliothèque Standard n'est pas la STL.
  • Il est totalement "le TSL". C'est une bibliothèque C++ écrit par SGI, qui a ressemblance frappante avec la norme C++ de la bibliothèque. sgi.com/tech/stl/table_of_contents.html
InformationsquelleAutor Maximilian Mordig | 2014-08-13
  1. 53

    Comment est std::swap mis en œuvre?

    Oui, la mise en œuvre présentées dans la question, la classique C++03 un.

    Plus moderne du C++(C ++ 11) la mise en œuvre de std::swap ressemble à ceci:

    template<typename T> void swap(T& t1, T& t2) {
    T temp = std::move(t1); //or T temp(std::move(t1));
    t1 = std::move(t2);
    t2 = std::move(temp);
}

    C'est une amélioration par rapport à la classique C++03 mise en œuvre en termes de gestion des ressources, car il empêche les copies inutiles, etc. C', le C++11 std::swap, requiert le type T être MoveConstructible et MoveAssignable, permettant ainsi la mise en œuvre et les améliorations.

    Pourquoi aurais-je besoin de fournir une implémentation personnalisée?

    Une implémentation personnalisée de swap, pour un type spécifique, est généralement conseillé lors de la mise en œuvre est plus efficace ou plus spécifique que la version standard.

    Un exemple classique de cela est lorsque votre classe gère une grande quantité de ressources qui pourraient être coûteuses à copier, puis supprimer. Au lieu de cela, votre custom mise en œuvre pourrait tout simplement échanger les poignées ou des pointeurs est nécessaire pour effectuer l'échange.

    Avec l'avènement de std::move et de meubles des types (et de la mise en œuvre de votre type en tant que tel), circa C++11 et au-delà, beaucoup de l'original de raisonnement commence à tomber; mais néanmoins, si une coutume swap serait mieux que le standard, la mettre en œuvre.

    Générique code sera généralement en mesure d'utiliser votre personnalisé swap si il utilise le ADL mécanisme de manière appropriée.

    • Pouvez-vous donner un exemple où il aurait encore un sens pour se spécialiser swap si la classe implémente l'déplacez-constructeur?
    • si les constructeurs de déplacement sont mises en œuvre, alors je ne peux pas penser à une raisonnable exemple de la main gauche. Fondamentalement, la mise à jour swap est conçu pour faire exactement cela, a minimisé les exigences sur vous pour prolonger ou de personnaliser la mise en œuvre standard (ce qui est une bonne chose à mon avis).
    • Une raison possible serait que, si l'état d'un déplacé-de l'objet n'est pas complètement trivial, et n'est pas optimisé loin dans la norme swap mise en œuvre, alors vous pourriez écrire un plus efficace de swap de trois coups par ne pas s'embêter avec que le programme d'installation. Cela fait beaucoup de "si" bien sûr, mais supposons qu'un déplacé-de l'objet est défini comme "le vide" et un objet "vide" contient tout un tas de zéros et peut-être un mannequin nœud de la structure. C'est un peu écrit, trois fois. Donc, normalement négligeable, mais vous pourriez le faire pour l'exécution si elle se pose.
    • ... également envisager quelque chose comme une chaîne de caractères avec une courte optimisation de la chaîne. Vous auriez du mettre en œuvre le constructeur de déplacement de cours (pour le transfert de la dynamique des tampons de longues chaînes de caractères), mais vous pouvez aussi mise en œuvre de swap afin de (tenter de) échanger le contenu de court-tampons de chaîne de manière plus efficace que les trois copies du contenu de la mémoire tampon à trois différentes régions de la mémoire.
    • cela signifie que vous devez repenser votre déplacé-de l'etat (qui est censé être le plus simple et le moins de ressource cher possible)
    • Je parle du cas où "moins de ressource cher possible" est néanmoins plus cher que le "coût zéro". Si vous voulez dire qu'un déplacé-de l'etat doit être à coût zéro pour établir ensuite OK, mais même si la compensation d'un pointeur de champ est effectivement zéro coût dans presque toutes les circonstances, il n'est pas exactement le cas.
    • Un swap fonction membre peut temporairement en rupture invariants si cela est plus rapide que de faire trois mouvements qui ont à maintenir les invariants après chaque mouvement. Si il y a une efficace X::swap(X&) membre puis se spécialise swap(X&, X&) appeler cela a du sens. Certaines opérations de déplacement pourrait même être mis en œuvre en termes de swap membre, de sorte que le générique std::swap fonction serait d'appeler le swap membre trois fois, quand il ne doit être effectuée qu'une fois.
    • Où puis-je trouver le code source pour le standard pour valider il en est ainsi?
    • votre standard des bibliothèques de code, plus facile peut utiliser votre éditeur de code pour le parcourir. Souvenir de chacun peuvent être différentes, la bibliothèque est libre de mettre en œuvre en tant que de besoin, aussi longtemps que le pré-et post-conditions sont remplies.

    InformationsquelleAutor Niall
  2. 17

    Quelle est la fonction d'échange de la mise en œuvre de la STL?

    Dont la mise en œuvre? C'est un cahier des charges, pas un seul de béton de la bibliothèque. Si vous voulez dire comment mon compilateur standard de la bibliothèque de il, soit nous dire quel compilateur, ou de lire le code vous-même.

    Est-il aussi simple que cela:

    C'est essentiellement la version naïve de pré-C++11.

    Cet spécialisée des nations unies mise en œuvre des forces d'une copie: pour T = std::vector<SomethingExpensive> dans votre exemple, le code se traduit comme:

    template<typename T> void swap(T& t1, T& t2) {
  T tmp(t1); //duplicate t1, making an expensive copy of each element
  t1=t2;     //discard the original contents of t1,
             //and replace them with an expensive duplicate of t2
  t2=tmp;    //discard the original contents of t2,
             //and replace them with an expensive duplicate of tmp
}            //implicitly destroy the expensive temporary copy of t1

    donc à l'échange de deux vecteurs nous avons essentiellement créé trois. Il y avait trois allocations dynamiques et beaucoup de chers objets copiés, et l'un quelconque de ces opérations pourrait jeter, en laissant éventuellement les arguments dans un état indéterminé.

    Depuis toute évidence, c'était horrible, les surcharges ont été fournis pour cher conteneurs, et vous avez été invités à écrire des surcharges pour votre propre cher types: par exemple. le std::vector spécialisation eu accès au vecteur-même, et pourrait permuter deux vecteurs sans la copie:

    template <typename T> void swap(vector<T> &v1, vector<T> &v2) { v1.swap(v2); }
template <typename T> void vector<T>::swap(vector<T>& other) {
  swap(this->size_, other.size_); //cheap integer swap of allocated count
  swap(this->used_, other.used_); //cheap integer swap of used count
  swap(this->data__, other.data_); //cheap pointer swap of data ptr
}

    Note que cela implique d'aucune copie de quoi que ce soit cher, pas de dynamique (de)l'allocation, et il est garanti de ne pas jeter.

    Maintenant, la raison de cette spécialisation est que le vecteur::swap a accès à du vecteur internes, et peuvent en toute sécurité et efficacement les déplacer sans les copier.

    Pourquoi aurais-je besoin pour ce faire [spécialisés ... pour votre propre classe] ?

    Pré-C++11, pour la même raison que std::vector - pour faire la permutation efficace et d'exception-safe.

    Depuis C++11, vous n'avez pas vraiment - si vous devez fournir déplacer de la construction et de l'affectation ou le compilateur peut générer des valeurs par défaut saines pour vous.

    Le nouveau générique de swap:

    template <typename T> void swap(T& t1, T& t2) {
    T temp = std::move(t1);
    t1 = std::move(t2);
    t2 = std::move(temp);
}

    pouvez utiliser move de la construction/la cession d'obtenir essentiellement le même comportement que la coutume vecteur de mise en œuvre ci-dessus, sans avoir à écrire une implémentation personnalisée à tous.

    • J'utilise Visual Studio c++ 2005 (n'a pas de support de c++11, mais les ignorer). Comment puis-je accéder au code source? Je ne pouvais pas trouver quoi que ce soit; il pourrait en être propriétaire.
    • Les fichiers d'en-tête doivent être quelque part, le compilateur peut les utiliser, mais je ne sais pas le chemin.
    • Dans Visual Studio, vous pouvez probablement clic droit sur swap et choisissez "Aller À la Définition".
    • il existe un raccourci pour aller à la définition, sinon, regardez dans le répertoire d'installation (dans program files) et de regarder dans le dossier "include"
    • Je pense que le répertoire par défaut pour 2005 est "C:\Program Files (x86)\Microsoft Visual Studio 8.0\VC\include\"
    InformationsquelleAutor Useless