这种“，”运算符的使用是否被认为是错误的形式？

Question

我创建了一个列表类，作为替换程序中可变参数函数的一种方法，用于初始化需要包含不断变化的元素列表的对象。 list 类有一个我非常喜欢的用法语法。但是我以前没有见过它使用过，所以我想知道我是否应该仅仅因为这个事实而使用它？列表类的基本实现如下所示...

#include <list>
#include <iostream>
template<typename T>
struct list
{
    std::list<T> items;
    list(const list&ref):items(ref.items){}
    list(){}
    list(T var){items.push_back(var);}
    list& operator,(list add_){
        items.insert(items.end(),add_.items.begin(), add_.items.end());
        return *this;
    }
    list& operator=(list add_){
        items.clear();
        items.insert(items.end(),add_.items.begin(), add_.items.end());
        return *this;
    }
    list& operator+=(list add_){
        items.insert(items.end(),add_.items.begin(), add_.items.end());
        return *this;
    }
};

这让我可以像这样在代码中使用它...

struct music{
//...
};
struct music_playlist{
    list<music> queue;
//...
};
int main (int argc, const char * argv[])
{
    music_playlist playlist;
    music song1;
    music song2;
    music song3;
    music song4;
    playlist.queue = song1,song2; // The queue now contains song1 and song2
    playlist.queue+= song1,song3,song4; //The queue now contains two song1s and song2-4
    playlist.queue = song2; //the queue now only contains song2
    return 0;
}

我真的认为语法比我刚刚公开一个常规的 stl 容器要好得多，甚至比可变参数函数更好（和类型安全）。但是，由于我没有看到使用这种语法，我很好奇是否应该避免它，因为首先代码应该很容易被其他程序员理解？

编辑：

结合这个问题，我发布了这个question，更针对实际问题的解决方案。

Answer 1

在很多层面上都很糟糕......

您正在覆盖list 和shadowingstd::list。一个很大的禁忌。如果您想要自己的列表类 - 使用不同的名称，不要隐藏标准库。

以这种方式使用, 是不可读的。运算符的返回值是右操作数。即使您的代码有效，对于外部读者来说，原因也不是很明显，这是一件坏事。代码应该是可读的，不是很好。

Answer 2

使用逗号operator , 并没有什么不好的地方。如果被利用，任何操作员都会留下不好的味道。在您的代码中，我没有看到任何合理的问题。我只想提出一个建议：

list& operator,(list &add_){  // <--- pass by reference to avoid copies
  *this += add_;  // <--- reuse operator +=
  return *this;
}

这样，如果您想对逻辑进行任何更改，您必须始终只编辑 operator +=。请注意，我的回答是一般而言的可读性和代码维护的角度。我不会对您使用的业务逻辑提出担忧。

Answer 3

为什么不像 QList 那样重载 << 运算符呢？然后像这样使用它：

playlist.queue << song1 << song2; // The queue now contains song1 and song2
playlist.queue << song1 << song3 << song4; //The queue now contains two song1s and song2-4

Answer 4

这可能属于程序员的事情，但这是我的两分钱。

如果您谈论的代码上下文相当狭窄，用户会在几个地方使用它，仅此而已，那么重载, 运算符可能就可以了。如果您正在构建一种特定领域的语言，该语言用于特定领域而不是其他任何地方，那可能没问题。

当您为希望用户以某种频率使用的东西重载它时，问题就出现了。

重载, 意味着读者需要完全重新解释他们是如何阅读您的代码的。他们不能只看一个表情就能立即知道它的作用。您搞乱了 C++ 程序员在扫描代码时所做的一些最基本的假设。

这样做后果自负。

Answer 5

最近优先级有变化吗？

playlist.queue = song1,song2;

这应该解析为：

(playlist.queue = song1) , song2;

你的 ',' 和 '+=' 是一样的！ 如果您的逗号运算符要创建一个临时列表，插入左右项目并返回临时列表，那将是更好的语义匹配。那你就可以这样写了；

playlist.queue = (song1,song2);

带有明确的括号。这将使 C 程序员有机会阅读代码。

Answer 6

我同意您编写的语法看起来不错。
我对代码的主要困难是我希望以下内容是相同的

playlist.queue = song1,song2;
playlist.queue = (song1,song2);  //more of c-style, as @Iuser notes.

而事实上它们完全不同。

这很危险，因为它很容易在代码中引入使用错误。 如果有人喜欢使用括号来增加对分组的额外强调（并不少见），那么逗号可能会成为一种真正的痛苦。例如，

//lets combine differnt playlists
new_playlist.queue =    song1        //the first playlist
                      ,(song3,song4) //the second playlist //opps, I didn't add song 3!
                      , song5;        //the third 

或

new_playlist.queue = (old_playlist.queue, song6); //opps, I edited my old playlist too!

顺便说一句，你有没有遇到 boost.assign:http://www.boost.org/doc/libs/1_47_0/libs/assign/doc/index.html

Answer 7

一个问题是，如果编译器无法选择重载的运算符逗号，它可以使用内置运算符。

相比之下，Boost.Assign 混合类型会产生编译错误。

#include <boost/assign.hpp>

int main()
{
    int one = 1;
    const char* two = "2";
    list<int> li;
    li = one, two;

    using namespace boost::assign;
    std::list<int> li2;
    li2 += one, two;
}

Answer 8

我很好奇我是否应该避免它，因为最重要的是 代码应该很容易被其他程序员理解

如果目标是让其他 C++ 程序员更容易理解您的代码，那么重写运算符以赋予它们与标准 C++ 非常不同的含义并不是一个好的开始。读者不必 a) 了解您是如何实现容器的；b) 重新调整他们对标准运算符的理解，以便能够理解您的代码。

对于这种事情，我很感激Boost precedent。如果您非常确定大多数阅读您的代码的人也会熟悉 Boost Assign，您自己的运算符覆盖可能是相当合理的。尽管如此，我还是建议按照@badzeppelin 的建议使用 operator

cout << "Hello world!"`

您的追加操作与写入流非常相似。