Quand surcharger l'opérateur de virgule?

Question

Je vois des questions sur de SORTE que chaque si souvent à propos de la surcharge de l'opérateur virgule en C++ (surtout sans rapport avec la surcharge de lui-même, mais des choses comme la notion de séquence de points), et il me fait me demander:

Quand devriez - vous la surcharge de la virgule? Quels sont quelques exemples de ses utilisations pratiques?

Je ne peux pas penser à des exemples sur le dessus de ma tête où j'ai vu ou besoin de quelque chose comme

foo, bar;

dans le monde réel de code, donc je suis curieux de savoir quand (si jamais) c'est en fait utilisé.

Answer 1

J'ai utilisé l'opérateur de virgule afin d'indexer des cartes avec plusieurs index.

 enum Place {new_york, washington, ...};

pair<Place, Place> operator , (Place p1, Place p2)
{
    return make_pair(p1, p2);
}


map< pair<Place, Place>, double> distance;

distance[new_york, washington] = 100;
 

Answer 2

Nous allons changer l'accent un peu de:

Quand devriez - vous la surcharge de la virgule?

La réponse: Jamais.

L'exception: Si vous êtes en train de faire du modèle de la métaprogrammation, operator, a une place particulière dans le bas de la priorité de l'opérateur de la liste, qui peut venir dans maniable pour la construction de SFINAE-gardes, etc.

Les deux seules utilisations pratiques que j'ai vu de la surcharge operator, sont à la fois dans Boost:

• Coup de pouce.Attribuer
• Coup de pouce.Phoenix – c'est ici fondamental en ce qu'il permet de Phoenix lambdas à l'appui de plusieurs états

Answer 3

Boost.Assign l' utilise pour vous permettre de faire des choses comme:

 vector<int> v; 
v += 1,2,3,4,5,6,7,8,9;
 

Et je l'ai vu utilisé pour des hacks de langue bizarres, je verrai si je peux en trouver.

---

Aha, je me souviens d'une de ces utilisations originales: collecter plusieurs expressions . (Attention, magie noire.)

Answer 4

La virgule a une propriété intéressante en ce sens qu’elle peut prendre un paramètre de type void . Si c'est le cas, l'opérateur de virgule intégré est utilisé.

C'est pratique lorsque vous voulez déterminer si une expression a le type void:

 namespace detail_
{
    template <typename T>
    struct tag
    {
        static T get();
    };

    template <typename T, typename U>
    tag<char(&)[2]> operator,(T, tag<U>);

    template <typename T, typename U>
    tag<U> operator,(tag<T>, tag<U>);
}

#define HAS_VOID_TYPE(expr) \
    (sizeof((::detail_::tag<int>(), \
             (expr), \
             ::detail_::tag<char>).get()) == 1)
 

Je laisse le lecteur comprendre comme un exercice ce qui se passe. Rappelez-vous que operator, s'associe à droite.

Answer 5

Semblable à @GMan de Boost.Attribuer exemple, Blitz++ surcharges de l'opérateur virgule pour fournir une pratique de la syntaxe pour travailler avec des tableaux multidimensionnels. Par exemple:

Array<double,2> y(4,4);   // A 4x4 array of double
y = 1, 0, 0, 0,
    0, 1, 0, 0,
    0, 0, 1, 0,
    0, 0, 0, 1;