何时重载逗号运算符？

Question

我经常看到关于 SO 的问题是关于在 C++ 中重载逗号运算符（主要与重载本身无关，但类似于序列点的概念），这让我想知道：

什么时候应该你超载逗号？有哪些实际用途的例子？

我只是想不出任何我见过或需要类似的例子

foo, bar;

在实际代码中，所以我很好奇何时（如果有的话）实际使用它。

Answer 1

Boost.Assign 使用它，让您执行以下操作：

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

我已经看到它用于古怪的语言黑客，我会看看我能不能找到一些。

---

啊哈，我确实记得其中一个古怪的用法：collecting multiple expressions。 （警告，黑魔法。）

Answer 2

让我们把重点改一下：

你什么时候应该重载逗号？

答案：从不。

例外：如果您在进行模板元编程，operator, 在运算符优先级列表的最底部有一个特殊的位置，它可以在构造 SFINAE-guard 等时派上用场。

我见过的重载operator, 的唯一两个实际用途都在Boost 中：

• Boost.Assign
• Boost.Phoenix - 这里的基础在于它允许 Phoenix lambdas 支持多个语句

Answer 3

一种可能性是Boost Assign 库（尽管我很确定有些人会认为这种滥用而不是一种好的用途）。

Boost Spirit 也可能重载了逗号运算符（它几乎重载了其他所有内容......）

Answer 4

类似于@GMan'sBoost.Assign 示例，Blitz++ 重载逗号运算符以提供convenient syntax 用于处理多维数组。例如：

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;

Answer 5

逗号有一个有趣的属性，它可以接受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, 关联到右侧。

Answer 6

同样，我收到了一个带有逗号运算符重载的 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");

有人可以解释为什么这是一个好的或坏的用例吗？

Answer 7

在SOCI - The C++ Database Access Library中用于实现接口的入站部分：

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

来自rationale FAQ：

问：重载的逗号运算符只是混淆，我不喜欢它。

好吧，考虑以下几点：

“将查询 X 发送到服务器 Y 并将结果放入变量 Z。”

上面，“and”起到了逗号的作用。即使重载逗号运算符在 C++ 中不是一种非常流行的做法，一些库也会这样做，从而实现简洁且易于学习的语法。我们很确定，在 SOCI 中，逗号操作符的重载效果很好。

Answer 8

我使用逗号运算符来索引具有多个索引的地图。

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 9

这是来自 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);

Answer 10

其中一个实际用途是在宏中有效地使用可变参数。顺便说一句，变量参数是早期 GCC 的一个扩展，现在是 C++11 标准的一部分。

假设我们有一个class X，它将A 类型的对象添加到其中。即

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

如果我们想将A 的1 个或多个对象添加到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+=`
  }

Answer 11

我使用逗号操作符来打印日志输出。它实际上与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;
  

• 它与逗号运算符的含义对齐，即“打印这个”然后“打印那个”。