In this chapter, we'll continue to deal with datatypes, introduced by the Boost libraries, mostly focusing on working with the pointers. We'll see how to easily manage resources, how to use a datatype capable of storing any functional objects, functions, and lambda expressions. After reading this chapter, your code will become more reliable and memory leaks will become history.

Sometimes, we are required to dynamically allocate memory and construct a class in that memory. That's where the troubles start. Take a look at the following code:

bool foo1() { 
    foo_class* p = new foo_class("Some data"); 

    const bool something_else_happened = some_function1(*p);  
    if (something_else_happened) { 
        delete p; 
        return false; 
    } 
 
    some_function2(p); 
 
    delete p; 
    return true; 
}

This code looks correct at first glance. But, what if some_function1() or some_function2() throws an exception? In that case, p won't be deleted. Let's fix it in the following way:

bool foo2() { 
    foo_class* p = new foo_class("Some data"); 
    try { 
        const bool something_else_happened = some_function1(*p); 
        if (something_else_happened) { 
            delete...

Imagine that you have some dynamically allocated structure containing data, and you want to process it in different threads of execution. The code to do this is as follows:

#include <boost/thread.hpp> 
#include <boost/bind.hpp> 
 
void process1(const foo_class* p); 
void process2(const foo_class* p); 
void process3(const foo_class* p); 
 
void foo1() { 
    while (foo_class* p = get_data()) // C way 
    { 
        // There will be too many threads soon, see 
        // recipe 'Parallel execution of different tasks' 
        // for a good way to avoid uncontrolled growth of threads 
        boost::thread(boost::bind(&process1, p)) 
            .detach(); 
        boost::thread(boost::bind(&process2, p)) 
            .detach(); 
        boost::thread(boost::bind(&process3, p)) 
            .detach(...

We already saw how to manage pointers to a resource in the Managing pointers to classes that do not leave scope recipe. But, when we deal with arrays, we need to call delete[] instead of a simple delete. Otherwise, there will be a memory leak. Take a look at the following code:

void may_throw1(char ch); 
void may_throw2(const char* buffer); 
 
void foo() { 
    // we cannot allocate 10MB of memory on stack, 
    // so we allocate it on heap 
    char* buffer = new char[1024 * 1024 * 10]; 

    // Oops. Here comes some code, that may throw.
    // It was a bad idea to use raw pointer as the memory may leak!!
    may_throw1(buffer[0]); 
    may_throw2(buffer); 

    delete[] buffer; 
}

We continue coping with pointers, and our next task is to reference count an array. Let's take a look at the program that gets some data from the stream and processes it in different threads. The code to do this is as follows:

#include <cstring> 
#include <boost/thread.hpp> 
#include <boost/bind.hpp> 
 
void do_process(const char* data, std::size_t size); 
 
void do_process_in_background(const char* data, std::size_t size) { 
    // We need to copy data, because we do not know, 
    // when it will be deallocated by the caller.
    char* data_cpy = new char[size]; 
    std::memcpy(data_cpy, data, size); 
 
    // Starting thread of execution to process data.
    boost::thread(boost::bind(&do_process, data_cpy, size)) 
            .detach(); 
    boost::thread(boost::bind(&do_process, data_cpy, size...

Consider the situation when you are developing a library that has its API declared in the header files and implementation in the source files. This library shall have a function that accepts any functional objects. Take a look at the following code:

// making a typedef for function pointer accepting int 
// and returning nothing 
typedef void (*func_t)(int); 
 
// Function that accepts pointer to function and 
// calls accepted function for each integer that it has.
// It cannot work with functional objects :( 
void process_integers(func_t f); 
 
// Functional object 
class int_processor { 
   const int min_; 
   const int max_; 
   bool& triggered_; 
 
public: 
    int_processor(int min, int max, bool& triggered) 
        : min_(min) 
        , max_(max) 
        , triggered_(triggered) 
    {} 
 
    void operator()(int i) const { 
        if (i...