Boost :: Tuples vs Structs返回值

我试图让我的头绕着元组(谢谢@litb),而他们使用的常见build议是函数返回> 1值。

这是我通常使用一个结构的东西,我不明白在这种情况下元组的优点 – 这似乎是一个容易出错的方法为最后懒惰。

借用一个例子 ,我会用这个

struct divide_result { int quotient; int remainder; }; 

使用元组,你会有

 typedef boost::tuple<int, int> divide_result; 

但是如果没有阅读你所调用函数的代码(或者注释,如果你足够愚蠢的信任它们),你不知道哪个int是商,反之亦然。 这似乎相当…

 struct divide_result { int results[2]; // 0 is quotient, 1 is remainder, I think }; 

…这不会使我充满信心。

那么,元组对结构的优点是什么,弥补了模糊性?

元组

我想我同意你说,什么位置的问题对应什么variables会引起混淆。 但我认为有两面。 一个是呼叫方 ,另一个是 呼叫

 int remainder; int quotient; tie(quotient, remainder) = div(10, 3); 

我认为我们得到的东西非常清晰,但是如果你必须一次返回更多的价值,那么它会变得令人困惑。 一旦调用者的程序员查阅了div的文档,他就会知道什么位置是什么,并能写出有效的代码。 作为一个经验法则,我会说不要一次返回超过4个值。 对于任何超越,喜欢一个结构。

输出参数

当然也可以使用输出参数:

 int remainder; int quotient; div(10, 3, &quotient, &remainder); 

现在我认为这说明了元组如何比输出参数更好。 我们混合了div的input和输出,而没有获得任何好处。 更糟糕的是,我们让那些代码的读者怀疑div实际返回值是什么。 输出参数很有用的时候有很好的例子。 在我看来,只有当你没有别的办法的时候,你才应该使用它们,因为返回值已经被使用了,不能改变成元组或结构。 operator>>就是一个很好的例子,你可以在这里使用输出参数,因为返回值已经为stream保留了,所以你可以链接operator>> calls。 如果你不需要操作符,上下文也不清楚,我build议你使用指针,在调用方发出信号,告诉对象实际上是用作输出参数的,除了适当的注释。

返回一个结构

第三个选项是使用一个结构体:

 div_result d = div(10, 3); 

我认为,这绝对是赢得了奖项。 但是请注意,您仍然可以访问该结构中的结果,并且结果不会在表格中“裸露”,因为输出参数和tie使用的元组就是这种情况。

我认为现在的一个重点是尽可能使一切尽可能通用。 所以,说你有一个可以打印出元组的函数。 你可以做

 cout << div(10, 3); 

并显示您的结果。 我认为另一方面,元组明显地赢得了他们的多面 。 这样做与div_result,你需要重载operator <<,或需要分别输出每个成员。

另一种select是使用Boost Fusion映射(代码未经testing):

 struct quotient; struct remainder; using boost::fusion::map; using boost::fusion::pair; typedef map< pair< quotient, int >, pair< remainder, int > > div_result; 

您可以直观地访问结果:

 using boost::fusion::at_key; res = div(x, y); int q = at_key<quotient>(res); int r = at_key<remainder>(res); 

还有其他的一些优点,比如遍历地图的字段等。查看doco了解更多信息。

使用元组,可以使用tie ,这有时是相当有用的: std::tr1::tie (quotient, remainder) = do_division (); 。 结构不是那么容易。 其次,在使用模板代码的时候,有时候更容易依赖对,而不是为结构types添加另一个typedef。

如果types不同,那么pair / tuple实际上并不比结构更差。 想一下例如pair<int, bool> readFromFile() ,其中int是读取的字节数,bool是eof是否被命中。 在这种情况下添加一个结构对我来说似乎是矫枉过正的,特别是在这里没有任何含糊之处。

元组在ML或Haskell等语言中非常有用。

在C ++中,它们的语法使得它们不那么优雅,但在以下情况下可能会有用:

  • 你有一个函数,必须返回多个参数,但结果是“本地”的来电和被调用者; 你不想为此定义一个结构

  • 你可以使用tiefunction来做一个非常有限的模式匹配forms“a la ML”,比起为了同样的目的而使用结构更优雅。

  • 他们来预定义<运营商,这可以节省时间。

我倾向于使用元组和typedefs至less部分地减轻“无名元组”的问题。 例如,如果我有一个网格结构,那么:

 //row is element 0 column is element 1 typedef boost::tuple<int,int> grid_index; 

然后我使用命名的types为:

 grid_index find(const grid& g, int value); 

这是一个有点人为的例子,但我想大多数时候它在可读性,清晰性和易用性之间达到了一个愉快的媒介。

或者在你的例子中:

 //quotient is element 0 remainder is element 1 typedef boost:tuple<int,int> div_result; div_result div(int dividend,int divisor); 

你没有的结构元组的一个特征是初始化。 考虑下面的内容:

 struct A { int a; int b; }; 

除非你写了一个make_tuple等价物或构造函数,然后使用这个结构作为input参数,你首先必须创build一个临时对象:

 void foo (A const & a) { // ... } void bar () { A dummy = { 1, 2 }; foo (dummy); } 

但是,不要太糟糕,维护会为我们的结构添加一个新成员,无论出于何种原因:

 struct A { int a; int b; int c; }; 

聚合初始化的规则实际上意味着我们的代码将继续编译而不会改变。 因此,我们不得不search这个结构的所有用法并更新它们,而不需要编译器的帮助。

与元组对比一下:

 typedef boost::tuple<int, int, int> Tuple; enum { A , B , C }; void foo (Tuple const & p) { } void bar () { foo (boost::make_tuple (1, 2)); // Compile error } 

编译器不能通过make_tuple初始化“元组”,因此会生成错误,使您可以为第三个参数指定正确的值。

最后,元组的另一个优点是它允许你编写迭代每个值的代码。 这是不可能的使用结构。

 void incrementValues (boost::tuples::null_type) {} template <typename Tuple_> void incrementValues (Tuple_ & tuple) { // ... ++tuple.get_head (); incrementValues (tuple.get_tail ()); } 

防止你的代码散布许多结构体定义。 对于编写代码的人来说,更容易,而当你仅仅logging元组中的每个元素时,就更容易使用它,而不是写自己的结构/让人们查找结构定义。

元组将更容易编写 – 不需要为每个返回值的函数创build一个新的结构体。 关于什么地方将会去哪些function文档的文档,无论如何将是需要的。 要使用这个函数,在任何情况下都需要读取函数文档,这里将解释元组。

我同意你100%罗迪。

要从一个方法中返回多个值,除了元组之外,还有几个选项取决于你的情况:

  1. 创build一个新的结构。 当你要返回的多个值相关时 ,这是很好的,并且创build一个新的抽象是合适的。 例如,我认为“divide_result”是一个很好的通用抽象,通过传递这个实体使得你的代码比传递一个无名的元组更清晰。 然后,您可以创build对这个新types进行操作的方法,将其转换为其他数字types等。

  2. 使用“输出”参数。 通过引用传递几个参数,并通过分配给每个out参数返回多个值。 当您的方法返回多个不相关的信息时,这是适当的。 在这种情况下创build一个新的结构将是矫枉过正的,而用Out参数强调这一点,再加上每个项目都会得到它应有的名称。

元组是邪恶的。