Коли перевантажувати оператор кома?

Я так часто бачу запитання щодо SO щодо перевантаження оператора коми в C ++ (головним чином, не пов'язаного з самим перевантаженням, але такими речами, як поняття точок послідовності), і це змушує мене задуматися:

Коли слід перевантажувати кому? Які приклади практичного використання?

Я просто не можу придумати жодних прикладів, які б я бачив чи потребував чогось подібного

foo, bar;

в реальному коді, тому мені цікаво, коли (якщо взагалі) це насправді використовується.

Давайте трохи змінимо акцент на:

Коли повинні ви перевантажувати кому?

Відповідь: Ніколи.

Виняток: якщо ви робите метапрограмування шаблону, у operator,нього є спеціальне місце в самому низу списку пріоритетів операторів, що може стати в нагоді для побудови SFINAE-охоронців тощо.

Єдине практичне використання перевантажень, яке я бачив, - operator,це Boost :

• Посилення. Призначення
• Boost.Phoenix - тут принципово важливо, що він дозволяє лямбдам Phoenix підтримувати кілька висловлювань

Я використовував оператор кома для індексації карт з кількома індексами.

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;

Boost.Assign використовує його, щоб дозволити вам робити такі речі:

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

І я бачив, як це використовується для химерних мовних хакерів, я подивлюсь, чи зможу я їх знайти.

Ага, я пам’ятаю одне з тих химерних застосувань: збирання кількох виразів . (Попередження, темна магія.)

Кома має цікаву властивість, оскільки вона може приймати параметр типу void. Якщо це так, то використовується вбудований оператор-кома.

Це зручно, коли потрібно визначити, чи має вираз тип 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)

Я даю читачеві зрозуміти як вправу, що відбувається. Пам'ятайте, що operator,товариші праворуч.

Подібно до прикладу @ GMan Boost.Assign , Blitz ++ перевантажує оператор коми, щоб забезпечити зручний синтаксис для роботи з багатовимірними масивами. Наприклад:

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;

У SOCI - Бібліотека доступу до бази даних C ++ використовується для реалізації вхідної частини інтерфейсу:

sql << "select name, salary from persons where id = " << id,
       into(name), into(salary);

З обґрунтування поширених запитань :

З: Перевантажений оператор-кома просто затуманює, мені це не подобається.

Ну, розглянемо наступне:

"Надішліть запит X на сервер Y і помістіть результат у змінну Z."

Вище "і" відіграє роль коми. Навіть якщо перевантаження оператора коми не є дуже популярною практикою в C ++, деякі бібліотеки роблять це, досягаючи стислого та простого для вивчення синтаксису. Ми майже впевнені, що в SOCI оператор коми був перевантажений з хорошим ефектом.

Я використовую оператор коми для друку журналу. Це насправді дуже схоже на, ostream::operator<<але я вважаю, що оператор-кома насправді кращий для цього завдання.

Отже я маю:

template <typename T>
MyLogType::operator,(const T& data) { /* do the same thing as with ostream::operator<<*/ }

Він має ці приємні властивості

• Оператор-кома має найменший пріоритет. Отже, якщо ви хочете транслювати вираз, все не запсується, якщо ви забудете дужки. Порівняйте:

  myLog << "The mask result is: " << x&y; //operator precedence would mess this one up
  myLog, "The result is: ", x&y;
  

  Ви навіть можете змішувати оператори порівняння всередині без проблем, наприклад

  myLog, "a==b: ", a==b;
  

• Оператор-кома візуально маленький. Це не псує читання, коли склеюєш багато речей

  myLog, "Coords=", g, ':', s, ':', p;
  

• Він узгоджується зі значенням оператора коми, тобто "друкувати це", а потім "друкувати те".

Однією з можливостей є бібліотека Boost Assign (хоча я майже впевнений, що деякі люди вважають це зловживанням, а не корисним використанням).

Boost Spirit, ймовірно, також перевантажує оператор коми (він перевантажує майже все інше ...)

У тому ж напрямку мені надіслали запит на витягування github із перевантаженням оператора коми. Це виглядало приблизно як наступне

class Mylogger {
    public:
            template <typename T>
            Mylogger & operator,(const T & val) {
                    std::cout << val;
                    return * this;
            }
 };

 #define  Log(level,args...)  \
    do { Mylogger logv; logv,level, ":", ##args; } while (0)

тоді в моєму коді я можу зробити:

 Log(2, "INFO: setting variable \", 1, "\"\n");

Хтось може пояснити, чому це хороший чи поганий випадок використання?

Одне з практичних завдань - це ефективне використання із змінними аргументами в макросі. До речі, аргументи змінних раніше були розширенням у GCC, а тепер є частиною стандарту C ++ 11.

Припустимо, у нас є a class X, який додає до нього об’єкт типу A. тобто

class X {
  public: X& operator+= (const A&);
};

Що робити, якщо ми хочемо додати 1 або більше об’єктів Aв X buffer;?
Наприклад,

#define ADD(buffer, ...) buffer += __VA_ARGS__

Вгорі макрос, якщо він використовується як:

ADD(buffer, objA1, objA2, objA3);

то він розшириться до:

buffer += objA1, objeA2, objA3;

Отже, це буде прекрасним прикладом використання оператора кома, оскільки аргументи змінної розширюються з однаковими.

Тому, щоб вирішити цю проблему, ми перевантажуємо commaоператор і обертаємо його, +=як показано нижче

  X& X::operator, (const A& a) {  // declared inside `class X`
    *this += a;  // calls `operator+=`
  }

Ось приклад з документації OpenCV ( http://docs.opencv.org/modules/core/doc/basic_structures.html#mat ). Оператор кома використовується для ініціалізації cv :: Mat:

// create a 3x3 double-precision identity matrix
Mat M = (Mat_<double>(3,3) << 1, 0, 0, 0, 1, 0, 0, 0, 1);