Tuple and Tie

最新推荐文章于 2025-10-13 09:15:47 发布

转载最新推荐文章于 2025-10-13 09:15:47 发布 · 650 阅读

boost 同时被 2 个专栏收录

10 篇文章

订阅专栏

c++ 11 or more

9 篇文章

订阅专栏

本文深入探讨了C++11中tuple类型和std::tie函数的使用，通过对比C/C++传统方式返回多个参数的方法，展示了tuple和std::tie在提高代码可读性方面的优势。结合实例，详细解释了如何在函数中返回tuple，并通过std::tie接受返回值，从而使得参数和返回值之间的区分更加清晰。

recently came across an interesting feature to C++11: std::tie. One of the features I love about python is that you are able to return multiple values from a function. These get returned in a structure called a “Tuple”. Here is a basic example of what I mean:

class rectangle:
      def __init__(self, width, height):
          self.width = width
          self.height = height

      def get_dimensions(self):
          return self.width, self.height

  r = rectangle(3,4)
  w, h = r.get_dimensions()
  print w,h

When run this will print “3 4”. The classic way to return multiple parameters in C/C++ is to pass extra parameters by reference or as pointers. The return values then got written to these parameters. While this worked it wasn’t the clearest thing to read since there was no clear division between parameters and return values. Infact, sometimes they served the same purpose of providing data and returning with a value. Here is an example of the same function in the old C++ way:

#include <iostream>
  using std::cout;

  class rectangle
  {
    public:
      rectangle(int _width, int _height) : width(_width), height(_height) {}
      int width, height;

      void get_dimensions(int & _width, int & _height)
      {
          _width = width;
          _height = height;
      }
  };

  int main(int argc, char** argv)
  {
      rectangle r(3,4);
      int w,h;
      r.get_dimensions(w,h);
      cout << w << ' ' << h << '\n';
      return 0;
  }

As you can see w and h are passed in like normal parameters with no indication to the user their real purpose.

Luckily C++11 has introduced tuple types and a way to return multiple values from a function. To use this all you need to do is return a tuple from a function, and then use std::tie to accept the return value. std::tie create its own tuple storing references to the variables it needs to throw the data into. Heres the same example:

#include <tuple>
  #include <iostream>

  using std::tuple;
  using std::tie;
  using std::make_tuple;
  using std::cout;

  class rectangle
  {
    public:
      rectangle(int _width, int _height) : width(_width), height(_height) {}
      int width, height;

      tuple<int, int> get_dimensions() {return make_tuple(width, height);}
  };

  int main(int argc, char** argv)
  {
      rectangle r(3,4);
      int w,h;
      tie(w,h) = r.get_dimensions();
      cout << w << ' ' << h << '\n';
      return 0;
  }

As you can see, it is quite clear that w and h are return values and not parameters. They even get returned with a call to return . In today’s age with our large code bases I think it is important that we make a move towards readability or we’ll never be able to maintain anything.