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...

We are continuing with the previous example, and now we want to pass a pointer to a function in our process_integers() method. Shall we add an overload for just function pointers, or is there a more elegant way?

This recipe is continuing the previous one. You must read the previous recipe first.

Nothing needs to be done as boost::function<> is also constructible from the function pointers:

void my_ints_function(int i); 
 
int main() { 
    process_integers(&my_ints_function); 
}

We are continuing with the previous example, and now we want to use a lambda function with our process_integers() method.

This recipe is continuing the series of the previous two. You must read them first. You will also need a C++11 compatible compiler or at least a compiler with C++11 lambda support.

Nothing needs to be done as boost::function<> is also usable with lambda functions of any difficulty:

#include <deque>
//#include "your_project/process_integers.h"

void sample(...

There are such cases when we need to store pointers in the container. The examples are: storing polymorphic data in containers, forcing fast copy of data in containers, and strict exception requirements for operations with data in containers. In such cases, C++ programmer has the following choices:

• Store pointers in containers and take care of their destructions using delete:

#include <set>
#include <algorithm>
#include <cassert>

template <class T>
struct ptr_cmp {
    template <class T1>
    bool operator()(const T1& v1, const T1& v2) const {
        return operator ()(*v1, *v2);
    }

    bool operator()(const T& v1, const T& v2) const {
        return std::less<T>()(v1, v2);
    }
};

void example1() {
    std::set<int*, ptr_cmp<int> > s;
    s.insert(new int(1));
    s.insert(new int(0));

    // ...
   ...

If you were dealing with languages, such as Java, C#, or Delphi, you obviously were using the try {} finally{} construction. Let me briefly describe to you what do these language constructions do.

When a program leaves the current scope via return or exception, code in the finally block is executed. This mechanism is used as a replacement for the RAII pattern:

// Some pseudo code (suspiciously similar to Java code) 
try { 
    FileWriter f = new FileWriter("example_file.txt"); 
    // Some code that may throw or return 
    // ... 
} finally { 
    // Whatever happened in scope, this code will be executed 
    // and file will be correctly closed 
    if (f != null) { 
        f.close() 
    } 
}

Is there a way to do such a thing in C++?

Let's take a look at the following example. We have some base class that has virtual functions and must be initialized with reference to the std::ostream object:

#include <boost/noncopyable.hpp> 
#include <sstream> 
 
class tasks_processor: boost::noncopyable { 
    std::ostream& log_; 
 
protected: 
    virtual void do_process() = 0; 
 
public: 
    explicit tasks_processor(std::ostream& log) 
        : log_(log) 
    {} 
 
    void process() { 
        log_ << "Starting data processing"; 
        do_process(); 
    } 
};

We also have a derived class that has a std::ostream object and implements the do_process() function:

class fake_tasks_processor: public tasks_processor { 
    std::ostringstream logger_; 
 
    virtual void do_process() { 
        logger_ << "Fake processor processed...