Chapter 70. Boost.Assign

The library Boost.Assign provides helper functions to initialize containers or add elements to containers. These functions are especially helpful if many elements need to be stored in a container. Thanks to the functions offered by Boost.Assign, you don’t need to call a member function like push_back() repeatedly to insert elements one by one into a container.

If you work with a development environment that supports C++11, you can benefit from initializer lists. Usually you can pass any number of values to the constructor to initialize containers. Thanks to initializer lists, you don’t have to depend on Boost.Assign with C++11. However, Boost.Assign provides helper functions to add multiple values to an existing container. These helper functions can be useful in C++11 development environments.

Example 70.1 introduces a few functions that containers can be initialized with. To use the functions defined by Boost.Assign, include the header file boost/assign.hpp.

Example 70.1. Initializing containers

  1. #include <boost/assign.hpp>
  2. #include <boost/tuple/tuple.hpp>
  3. #include <vector>
  4. #include <stack>
  5. #include <map>
  6. #include <string>
  7. #include <utility>
  9. using namespace boost::assign;
  11. int main()
  12. {
  13.   std::vector<int> v = list_of(1)(2)(3);
  15.   std::stack<int> s = list_of(1)(2)(3).to_adapter();
  17.   std::vector<std::pair<std::string, int>> v2 =
  18.     list_of<std::pair<std::string, int>>("a", 1)("b", 2)("c", 3);
  20.   std::map<std::string, int> m =
  21.     map_list_of("a", 1)("b", 2)("c", 3);
  23.   std::vector<boost::tuple<std::string, int, double>> v3 =
  24.     tuple_list_of("a", 1, 9.9)("b", 2, 8.8)("c", 3, 7.7);
  25. }

Boost.Assign provides three functions to initialize containers. The most important, and the one you usually work with, is boost::assign::list_of(). You use boost::assign::map_list_of() with std::map and boost::assign::tuple_list_of() to initialize tuples in a container.

You don’t have to use boost::assign::map_list_of() or boost::assign::tuple_list_of(). You can initialize any container with boost::assign::list_of(). However, if you use std::map or a container with tuples, you must pass a template parameter to boost::assign::list_of() that tells the function how elements are stored in the container. This template parameter is not required for boost::assign::map_list_of() and boost::assign::tuple_list_of().

All three functions return a proxy object. This object overloads the operator operator(). You can call this operator multiple times to save values in the container. Even though you access another object, and not the container, the container is changed through this proxy object.

If you want to initialize adapters like std::stack, call the member function to_adapter() on the proxy. The proxy then calls the member function push(), which is provided by all adapters.

boost::assign::tuple_list_of() supports tuples of type boost::tuple only. You cannot use this function to initialize containers with tuples from the standard library.

Example 70.2 illustrates how values can be added to existing containers.

Example 70.2. Adding values to containers

  1. #include <boost/assign.hpp>
  2. #include <vector>
  3. #include <deque>
  4. #include <set>
  5. #include <queue>
  7. int main()
  8. {
  9.   std::vector<int> v;
  10.   boost::assign::push_back(v)(1)(2)(3);
  12.   std::deque<int> d;
  13.   boost::assign::push_front(d)(1)(2)(3);
  15.   std::set<int> s;
  16.   boost::assign::insert(s)(1)(2)(3);
  18.   std::queue<int> q;
  19.   boost::assign::push(q)(1)(2)(3);
  20. }

The boost::assign::push_back(), boost::assign::push_front(), boost::assign::insert(), and boost::assign::push() functions of Boost.Assign return a proxy. You pass these functions the container you want to add new elements to. Then, you call the operator operator() on the proxy and pass the values you want to store in the container.

The four functions boost::assign::pushback(), boost::assign::push_front(), boost::assign::insert(), and boost::assign::push() are called in this manner because the proxies returned call the identically named member functions on the container. Example 70.2 adds the three numbers 1, 2, and 3 to the vector _v with three calls to push_back().

Boost.Assign provides additional helper functions you can use to add values to a container, including boost::assign::add_edge(), which you can use to get a proxy for a graph from Boost.Graph.

Exercise

Improve this program with Boost.Assign:

  1. #include <vector>
  2. #include <algorithm>
  3. #include <iterator>
  4. #include <iostream>
  6. int main()
  7. {
  8.     std::vector<int> v;
  9.     v.push_back(1);
  10.     v.push_back(2);
  11.     v.push_back(3);
  12.     std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout));
  13.     v.push_back(4);
  14.     v.push_back(5);
  15.     v.push_back(6);
  16.     std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout));
  17. }