On Programming

A discussion of programming strategies and results

Tuple and Tie

| Comments

I 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:

1
2
3
4
5
6
7
8
9
10
11
  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:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
  #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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
  #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.

Comments