fonction de membre d'échange d'ami public

Dans la belle réponse à l' idiome copier-et-échanger, il y a un morceau de code dont j'ai besoin d'un peu d'aide:

class dumb_array
{
public:
    // ...
    friend void swap(dumb_array& first, dumb_array& second) // nothrow
    {
        using std::swap; 
        swap(first.mSize, second.mSize); 
        swap(first.mArray, second.mArray);
    }
    // ...
};

et il ajoute une note

Il y a d'autres prétentions que nous devrions spécialiser std :: swap pour notre type, fournir un swap en classe avec un swap de fonction libre, etc. Mais tout cela est inutile: toute utilisation correcte de swap se fera par un appel non qualifié , et notre fonction sera trouvée via ADL. Une fonction fera l'affaire.

Avec friendje suis un peu "hostile", je dois l'admettre. Donc, mes principales questions sont:

• ressemble à une fonction libre , mais c'est à l'intérieur du corps de la classe?
• pourquoi n'est-ce pas swapstatique ? Il n'utilise évidemment aucune variable membre.
• "Toute utilisation appropriée du swap permettra de découvrir le swap via ADL" ? ADL recherchera les espaces de noms, non? Mais regarde-t-il aussi à l'intérieur des classes? Ou est-ce ici où friendintervient?

Questions secondaires:

• Avec C ++ 11, dois-je marquer mon swaps avec noexcept?
• Avec C ++ 11 et son range-for , dois-je placer friend iter begin()et de friend iter end()la même manière à l'intérieur de la classe? Je pense que ce friendn'est pas nécessaire ici, non?

Il existe plusieurs façons d'écrire swap, certaines meilleures que d'autres. Au fil du temps, cependant, il a été constaté qu'une seule définition fonctionnait le mieux. Voyons comment nous pourrions penser l'écriture d'une swapfonction.

Nous voyons d'abord que les conteneurs comme std::vector<>ont une fonction membre à argument unique swap, telle que:

struct vector
{
    void swap(vector&) { /* swap members */ }
};

Naturellement, alors, notre classe devrait aussi, non? Eh bien pas vraiment. La bibliothèque standard contient toutes sortes de choses inutiles , et un membre en swapfait partie. Pourquoi? Continuons.

Ce que nous devons faire, c'est identifier ce qui est canonique et ce que notre classe doit faire pour travailler avec. Et la méthode canonique d'échange est avec std::swap. C'est pourquoi les fonctions membres ne sont pas utiles: elles ne sont pas la façon dont nous devrions échanger les choses, en général, et n'ont aucune incidence sur le comportement de std::swap.

Eh bien, pour faire du std::swaptravail, nous devrions fournir (et std::vector<>aurions dû fournir) une spécialisation std::swap, non?

namespace std
{
    template <> // important! specialization in std is OK, overloading is UB
    void swap(myclass&, myclass&)
    {
        // swap
    }
}

Eh bien, cela fonctionnerait certainement dans ce cas, mais cela pose un problème flagrant: les spécialisations de fonctions ne peuvent pas être partielles. Autrement dit, nous ne pouvons pas spécialiser les classes de modèles avec ceci, seulement des instanciations particulières:

namespace std
{
    template <typename T>
    void swap<T>(myclass<T>&, myclass<T>&) // error! no partial specialization
    {
        // swap
    }
}

Cette méthode fonctionne parfois, mais pas tout le temps. Il doit y avoir un meilleur moyen.

Il y a! Nous pouvons utiliser une friendfonction et la trouver via ADL :

namespace xyz
{
    struct myclass
    {
        friend void swap(myclass&, myclass&);
    };
}

Quand nous voulons échanger quelque chose, nous associons ^† std::swap puis faisons un appel non qualifié:

using std::swap; // allow use of std::swap...
swap(x, y); // ...but select overloads, first

// that is, if swap(x, y) finds a better match, via ADL, it
// will use that instead; otherwise it falls back to std::swap

Qu'est-ce qu'une friendfonction? Il y a confusion dans ce domaine.

Avant que C ++ ne soit normalisé, les friendfonctions faisaient quelque chose appelé «injection de nom d'ami», où le code se comportait comme si la fonction avait été écrite dans l'espace de noms environnant. Par exemple, il s'agissait de pré-normes équivalentes:

struct foo
{
    friend void bar()
    {
        // baz
    }
};

// turned into, pre-standard:    

struct foo
{
    friend void bar();
};

void bar()
{
    // baz
}

Cependant, lorsque ADL a été inventé, cela a été supprimé. La friendfonction pourrait alors ne se trouve par ADL; si vous le vouliez en tant que fonction libre, il fallait le déclarer comme tel ( voir ceci , par exemple). Mais voilà! Il y avait un problème.

Si vous utilisez simplement std::swap(x, y), votre surcharge ne sera jamais trouvée, car vous avez explicitement dit "regarder dedans std, et nulle part ailleurs"! C'est pourquoi certains ont suggéré d'écrire deux fonctions: l'une comme fonction à trouver via ADL , et l'autre pour gérer des std::qualifications explicites .

Mais comme nous l'avons vu, cela ne peut pas fonctionner dans tous les cas et nous nous retrouvons avec un désordre horrible. Au lieu de cela, l'échange idiomatique est allé dans l'autre voie: au lieu d'en faire le travail des classes à fournir std::swap, c'est le travail des échangeurs de s'assurer qu'ils n'utilisent pas qualifié swap, comme ci-dessus. Et cela a tendance à bien fonctionner, tant que les gens le savent. Mais c'est là que réside le problème: il n'est pas intuitif de devoir utiliser un appel non qualifié!

Pour rendre cela plus facile, certaines bibliothèques comme Boost ont fourni la fonction boost::swap, qui ne fait qu'un appel non qualifié à swap, avec std::swapcomme espace de noms associé. Cela aide à rendre les choses succinctes à nouveau, mais c'est toujours une déception.

Notez qu'il n'y a pas de changement dans le comportement de C ++ 11 std::swap, ce que moi et d'autres pensions à tort que ce serait le cas. Si cela vous a mordu, lisez ici .

En bref: la fonction membre n'est que du bruit, la spécialisation est moche et incomplète, mais la friendfonction est complète et fonctionne. Et quand vous échangez, utilisez boost::swapou non qualifié swapavec std::swapassocié.

† De manière informelle, un nom est associé s'il sera pris en compte lors d'un appel de fonction. Pour plus de détails, lisez le §3.4.2. Dans ce cas, std::swapn'est normalement pas pris en compte; mais on peut l' associer (l'ajouter à l'ensemble des surcharges considérées par les non qualifiés swap), permettant de la retrouver.

Ce code est équivalent (dans presque tous les sens) à:

class dumb_array
{
public:
    // ...
    friend void swap(dumb_array& first, dumb_array& second);
    // ...
};

inline void swap(dumb_array& first, dumb_array& second) // nothrow
{
    using std::swap; 
    swap(first.mSize, second.mSize); 
    swap(first.mArray, second.mArray);
}

Une fonction ami définie à l'intérieur d'une classe est:

• placé dans l'espace de noms englobant
• automatiquement inline
• capable de faire référence à des membres statiques de la classe sans autre qualification

Les règles exactes sont dans la section [class.friend](je cite les paragraphes 6 et 7 du projet C ++ 0x):

Une fonction peut être définie dans une déclaration d'ami d'une classe si et seulement si la classe est une classe non locale (9.8), le nom de la fonction n'est pas qualifié et la fonction a une portée d'espace de noms.

Une telle fonction est implicitement en ligne. Une fonction friend définie dans une classe est dans la portée (lexicale) de la classe dans laquelle elle est définie. Une fonction ami définie en dehors de la classe ne l'est pas.