Home > Articles > Programming > C/C++

How the Boost Bind Library Can Improve Your C++ Programs

📄 Contents

  1. How Does the Bind Library Improve Your Programs?
  2. How Does Bind Fit with the Standard Library?
  3. Bind
  4. Usage
  5. Bind Summary
  • Print
  • + Share This
  • 💬 Discuss
This chapter is from the book
The existence of a generalized C++ binder is a tremendously useful tool when it comes to writing terse, coherent code. It reduces the number of small function objects created for adapting functions/function objects, and combinations of functions. Although the Standard Library already offers a small part of the functionality found in Boost.Bind, significant improvements can make Boost.Bind the better choice. In this sample chapter from Beyond the C++ Standard Library, you'll learn about Boost.Bind's powerful functional composition features, which provide programmers with great power without negative effects on maintenance.

How Does the Bind Library Improve Your Programs?

  • Adapts functions and function objects for use with Standard Library algorithms
  • Consistent syntax for creating binders
  • Powerful functional composition

When using the algorithms from the Standard Library, you often need to supply them with a function or a function object. This is an excellent way of customizing the behavior of algorithms, but you often end up writing new function objects because you don't have the tools necessary for functional composition and adaptation of argument order or arity. Although the Standard Library does offer some productive tools, such as bind1st and bind2nd, this is rarely enough. Even when the functionality suffices, that often implies suffering from awkward syntax that obfuscates the code for programmers who are not familiar with those tools. What you need, then, is a solution that both adds functionality and normalizes the syntax for creating function objects on-the-fly, and this is what Boost.Bind does.

In effect, a generalized binder is a sort of lambda expression, because through functional composition we can more or less construct local, unnamed functions at the call site. There are many cases where this is desirable, because it serves three purposes—reducing the amount of code, making the code easier to understand, and localizing behavior, which in turn implies more effective maintenance. Note that there is another Boost library, Boost.Lambda, which takes these properties even further. Boost.Lambda is covered in the next chapter. Why shouldn't you just skip ahead to that library? Because most of the time, Boost.Bind does everything you need when it comes to binding, and the learning curve isn't as steep.

One of the keys to the success of Bind is the uniform syntax for creating function objects and the few requirements on types that are to be used with the library. The design takes focus away from how to write the code that works with your types, and sets it to where we are all most interested—how the code works and what it actually does. When using adaptors from the Standard Library, such as ptr_fun and mem_fun_ref, code quickly becomes unnecessarily verbose because we have to provide these adaptors in order for the arguments to adhere to the requirements of the algorithms. This is not the case with Boost.Bind, which uses a much more sophisticated deduction system, and a straightforward syntax when the automatic deduction cannot be applied. The net effect of using Bind is that you'll write less code that is easier to understand.

  • + Share This
  • 🔖 Save To Your Account


comments powered by Disqus