Rakafon's blog

JScript: How to get AllUsers AppData directory

2010-06-06T15:50:00.001+03:00

var osXP = 0;
var osVista = 1;
var osWin7 = 2;

function getOsVersionString()
{
    var wbemFlagReturnImmediately = 0x10;
    var wbemFlagForwardOnly = 0x20;
    var objWMIService = GetObject("winmgmts:\\\\.\\root\\CIMV2");
    var colItems = objWMIService.ExecQuery("SELECT * FROM Win32_OperatingSystem", "WQL", wbemFlagReturnImmediately | wbemFlagForwardOnly);
    
    var enumItems = new Enumerator(colItems);
    var objItem = enumItems.item();
    
    return objItem.Caption;
}

function getOsVersion()
{
    var osVersionString = getOsVersionString();

    if (osVersionString.indexOf("Windows Vista") != -1)
    {
        return osVista;
    }

    if (osVersionString.indexOf("Windows 7") != -1)
    {
        return osWin7;
    }

    return osXP;
}

function getAllUsersAppData()
{
    var result;
    
    var wsShell = new ActiveXObject("WScript.Shell");
    result = wsShell.ExpandEnvironmentStrings("%ALLUSERSPROFILE%");
    
    try
    {
        var osVersion = getOsVersion();
        
        if (osVersion == osXP)
            result += "\\Application Data";
    }
    catch(err)
    {
    }

    return result;
}

Организация доступа к 32-bit DLL из 64-bit приложения.

2009-04-02T01:01:00.010+03:00

Перенос 32-битных Windows приложений на 64-битную машину может быть весьма проблематичным, если у вас есть 32-разрядные библиотеки DLL, которые вы не можете переписать и портировать для 64-bit. Майк Беккер покажет вам, как можно получить доступ к 32-bit DLL из 64-битного кода с помощью встроенных механизмов IPC.

64-разрядные технологии Microsoft впервые появились в Windows Server 2003 для процессоров Itanium 2 (архитектура ихвестна как "IA64") а также для eXtended CPUs (архитектура известна как "x64"). 64-bit технология имеет много преимуществ, но также поднимает новые вопросы для разработчиков программного обеспечения. Например, вам может понадобиться необходимость доступа к существующим 32-разрядным библиотекам DLL из 64-битного процесса.

Главное преимущество технологии 64-бит состоит в способности адресовать до 8 ТБ памяти, против максимальных 2 Гб для 32-битных процессов. Как результат, 64-разрядная технология позволяет проводить операции с большим объёмом данных в оперативной памяти без необходимости временного сброса памяти на жётский диск. Это может значительно повысить производительность и открыть новые алгоритмы обработки данных базирующихся на очень больших доступных объёмов оперативной памяти. Как бы то ни было аргументы для миграции существующего программного обеспечения на 64-битную платформу имеют место быть.

Многие приложения, написанные с помощью C/C++ могут быть легко портированы под 64-битную платформу, особенно если они написаны в виде монолитного модуля. Иногда достаточно просто пересобрать исходные коды с использованием x64/IA64 компилятора. Однако уже опубликованное или базирующееся на модулях ПО может вызвать проблемы.

Конфликт: 64-bit против 32-bit

Основная проблема миграции возникает при необходимости портирования 32-разрядных программных компонентов, которые не могут быть пересобраны, возможно, потому что исходный код потерян, к нему нет доступа или одна из зависимостей этого модуля не можeт быть перенесена на 64-bit платформу.

32-битное ПО по-прежнему поддерживается на 64-битной платформе. Так 32-битные процессы могут выполняться внутри Windows WOW64-подсистемы, которая является частью всех 64-битных систем Windows. Однако 64-разрядный процесс не может загружать 32-разрядные модули в своё адресное пространство, также и 32-разрядные процессы не могут загружать 64-разрядные модули в своё адресное пространство. Единственный способ общения между 32-битными и 64-битными модулями возможен путём межпроцессного взаимодействия (IPC). Другими словами, 32-разрядные и 64-разрядные процессы могут обмениваться данными с использованием IPC-механизмов, например такие как out-of-proc COM, сокеты, сообщения Windows или MMF (Memory mapped files).

Например, 32-битный программный продукт содержит основной модуль WeatherReport (см. рисунок выше), который внутри обращается к DLL WeatherStationControl. Пока основной модуль и DLL являются 32-разрядными, продукт может работать как на 32-битных, так и 64-битных платформах (внутри WOW64). Если основной модуль и DLL переносятся на 64-битную платформу, то они могут работать в рамках 64-битных процессов. Однако, если только основной модуль переносится на 64-bit, он не сможет загружать 32-разрядные DLL.

Лучшим способом переноса такого продукта на 64-битную платформу является миграция как основного модуля, так и всех его зависимостей, но если хоть одна зависимая DLL не может быть перенесена, то продукт не может быть загружен в 64-битном процессе, следовательно приложение работать не будет.

Решение: суррогатный процесс

Эта проблема может быть решена путем загрузки зависимой 32-битной DLL в отдельном пространстве 32-разрядного процесса. Основной модуль, работая в качестве 64-битного процесса, может получить доступ к зависимым DLL'ям через границы процессов, используя IPC (Смотри MSDN reference).

64-битный процесс может получить доступ к 32-разрядной DLL используя механизмы межпроцессного взаимодействия. То бишь 32-разрядные DLL загружаются в отдельный 32-битный суррогатный процесс, и тогда 64-битное приложение использует встроенные механизмы IPC для того, чтобы обмениваться данными 32-битным процессом.

Это решение требует дополнительной работы, например необходимо создать 32-разрядный суррогатный процесс, который загрузит 32-разрядные DLL и предоставит API для работы с ними. Кроме того, некоторые изменения будет необходимо стелать со стороны 64-битного клиента, т.к. клиент будет вынужден использовать методы IPC вместо непосредственного доступа к 32-разрядной DLL. Стоит отметить, что, в крайнем случае, эта дополнительная работа может быть сравнима с работой, которую необходимо выполнить при разработке 64-разрядной версию 32-битной DLL с нуля.

Одним из возможных путей сокращения этих расходов является реализация 64-разрядной DLL обертки, которая предоставит те же функции, что и оригинальная 32-битная DLL. Эта обёртка уже внутри себя скроет детали IPC вызовов оригинальной 32-битной DLL, загруженной в 32-битный суррогатный процесс.

64-битная обёртка (WeatherStationControl64.DLL) экспортирует тот же интерфейс, что и оригинальная 32-битная DLL (WeatherStationControl.DLL), то бишь предоставляет главному модулю WeatherReport те же сервисы без необходимости внесения изменений в код модуля WeatherReport.

Основные затраты этого решения связаны с реализацией суррогатного процесса, загружающего 32-битную DLL и реализаццей 64-битной DLL оболочки. Фактически затраты будут зависеть от того, какая из IPC технологий будет использоваться для обмена данными между 64-битным и 32-битным процессами.

Использование COM для межпроцессного взаимодействия

Один из самых популярных методов IPC - это DCOM (Distributed COM). Первоначально разработанная для распределенных систем, DCOM по-прежнему поддерживается как на 64-битных платформах Windows. Модули COM могут быть собраны как 32-разрядные так и 64-разрядные. Единственным ограничением является то, что 64-битные и 32-битные модули не могут находиться в одном и том же процессе, следовательно они должны взаимодействовать через границы процессов. Это делается с помощью out-of-process (OOP) COM компонентов, следующим образом:

Создаём 32-битный COM-Сервер, который загрузит 32-битную DLL и опубликует 32-bit DLL интерфейс как COM-интерфейс, реализованный внутри через делегирование к API исходной 32-битной DLL.
Конфигурируем этот COM-Сервер для out-of-proc загрузки любым способом создания COM+ приложений (используя dllhost.exe в качестве суррогата).
Также можно реализовать этот COM-компонент как специальный COM-Сервер EXE, используя ATL COM Server в качестве хостящего процесса.
Можно также помеcтить этот COM-компонент внутрь Win32-сервиса.
Создаём 64-разрядную DLL оболочку, реализующую тот же интерфейс, как оригинальная 32-битная DLL. Обёртка будет импортировать COM-интерфейс из COM-объекта, созданного выше, и транслировать каждый API вызов в обращение к COM-интерфейсу, передавая параметры вызова и получая возвращаемые значения.

32-разрядная DLL (WeatherStationControl.DLL) используется СОМ-объектом (WeatherStationWrapper), который предоставляет интерфейс 32-битной DLL в качестве COM-интерфейса. 64-битная DLL обёртка (WeatherStationControl64.DLL) делает вызовы COM-интерфейса, которые уже делегируют всю работу оригинальным API вызовам исходной 32-битой DLL. Основной процесс (WeatherReport) использует интерфейс, предоставляемый 64-разрядной DLL обёрткой, но на самом деле работа выполняется в оригинальной 32-битной DLL.

Это решение должно быть значительно дешевле, чем создание 64-разрядную версию 32-битных DLL с нуля. Библиотека ATL, поддерживающаяся Visual Studio, вкупе со всеми своими визардами и готовыми фрагментами кода, также должны помочь снизить затраты миграции за счет экономии времени и снижения вероятности ошибок.

Последствия

Однако существует ряд вещей, которые вам все еще нужно иметь в виду:

Выравнивание
Выравнивание данных в памяти отличается в 32-bit и 64-bit процессах. Это означает, что более сложные пользовательские структуры данных могут быть сериализованы 32-разрядным процессом иначе, чем ожидается в 64-битном проыцессе, и наоборот. Microsoft Windows Platform SDK включает документацию о различиях в соответствие памяти данными между 32-битной и 64-битных процессов.
Типы данных
В большинстве случаев, 64-разрядная Windows использует те же типы данных, как 32-битной версии. Различия в основном в указателях, которые 32-битные в 32-битной версий Windows и 64-битные в 64-битных Windows.
Указатель полученных данных типов, таких как HANDLE и HWND также различны между 32-битной и 64-разрядных версиях. Windows позволяет вести единый базовый код для 32-разрядных версиях и 64-битного программного обеспечения, предлагая полиморфные типы данных, которые имеют различную длину в зависимости от целевой платформы, например INT_PTR представляет целое с таким же размером, как и указатель. Любая переменная этого типа будет целым числом, которое составляет 32 бита на 32-битной платформе и 64 бита на 64-битной платформе.
COM инициализации
Вы можете получить доступ к СОМ-объекту, если он был успешно инициализирован. Функция COM API CoInitialize() должна вызываться для каждого потока, который собирается работать с COM-объектом, т.е. делать вызовы COM-интерфейсов, также должна вызываться CoUninitialize() перед завершением потока.(см. MSDN). Это правило должно строго соблюдаться, если основной процесс вызывает оригинальные 32-битные DLL из разных потоков выполнения.
Безопасность
При использовании out-of-proc, экземпляры COM-объектов находятся в отдельном процессе, независимо от того используете вы стандартный суррогатной процесс, EXE COM-Сервер или Win32 сервис. Это может означать, что вызовы 32-битной DLL могут произойти в другом контексте безопасности, чем у основного процесса, особенно если основной процесс интенсивно использует имперсонирование. Если это так, вы можете настроить собственные параметры доступа для out-of-proc компонента, или осуществлять внутреннее имперсонирование внутри COM-объекта.
Производительность
IPC-решение почти наверняка будет медленнее, чем прямые вызовы DLL. Маршалинг данных за границы процессов, автоматическое преобразование данных между 32 и 64 бит, WOW64 особенности, задержки инстанцирования экземпляров COM-объектов - всё это будет влиять на производительность. Однако есть много методов оптимизации, которые можно использовать, таких как COM pooling, кэширование данных внутри DLL-оболочки, реализация критичных к производительности интерфейсов в 64-битной DLL, и так далее.
Перенаправление
Подсистема WOW64 отвечает за поддержку 32-битных модулей на 64-битных Windows. Чтобы избежать нежелательных коллизий между 32-битным и 64-битным ПО, особенно при доступе к файловой системы и реестру, WOW64 изолирует 32-разрядные модули, используя механизм, называемый перенаправление (см. MSDN).
Например, для 64-битного процесса при получении пути системной папки возвращается %WINDOWS%\System32, а для 32-разрядного процесса возвращается %WINDOWS%\SysWOW64.
Путь к папке исполняемого файла будет "Program Files" для 64-битного процесса, но для 32-разрядного процесса это будет "Program Files (x86)".
Раздел реестра HKEY_LOCAL_MACHINE\Software содержит настройки и данные для 64-разрядных процессов, а ключ HKEY_LOCAL_MACHINE\Software\WOW6432Node содержит настройки и данные для 32-разрядных процессов.
Это перенаправление активируется автоматически, когда программные модули пытаются получить предопределённые системные пути или ключи реестра.
Модули ядра
Предложенное здесь решение работает для 32-разрядных DLL, использующихся в user mode, но не работает с 32-битными драйверами. Это происходит, потому что 32-битные модули ядра не могут быть использованы на 64-битной платформе, без исключений или обходных путей. Если ваш продукт включает в себя любой модуль уровня ядра, таких как драйвер устройства, то единственно возможный путь миграции - это портировать модуль ядра на 64-битную платформу.
Установка.
Использование out-of-proc COM-компонента требует изменений в процедуре установки вашего ПО, т.к. COM-компонент должен быть установлен и зарегистрирован в системе. Как уже говорилось выше в пункте Безопасность, для этого может потребоваться настройка специальных параметров доступа для COM-компонента.

Тыкните сюда дабы скачать пример кода

Оригинал статьи здесь: Mike Becker: "Accessing 32-bit DLLs from 64-bit code", Jun 2007

Литература:

Base64 Encoder

2009-04-01T23:15:00.001+03:00

Велосипед отечественного производства для кодирования бинарных данных в текст с кодировкой Base64 и обратно.

Файл check_helpers.hpp

//------------------------------------------------------------------------
#ifndef __CHERCKHELPERS_HEADER_INCLUDED__
#define __CHERCKHELPERS_HEADER_INCLUDED__
//------------------------------------------------------------------------
#include <boost/type_traits.hpp>
//------------------------------------------------------------------------
template<class IterTypeT>
struct IsRandomAccesIterator
{
    static const bool value = false;
};
template<>
struct IsRandomAccesIterator<std::random_access_iterator_tag>
{
    static const bool value = true;
};
//------------------------------------------------------------------------
#define CHARTYPE_SOURCE_SEQUENCE_CHECK(stl_container_t) \
    BOOST_STATIC_ASSERT ( \
    boost::is_fundamental<typename stl_container_t::value_type>::value ); \
    BOOST_STATIC_ASSERT ( \
    sizeof(typename stl_container_t::value_type) == static_cast<std::size_t>(1) );
//------------------------------------------------------------------------
#define CHARTYPE_SOURCE_ITERATOR_CHECK(iterator_t) \
    BOOST_STATIC_ASSERT ( \
        boost::is_fundamental<typename std::iterator_traits<iterator_t>::value_type>::value ); \
    BOOST_STATIC_ASSERT ( \
        sizeof(typename std::iterator_traits<iterator_t>::value_type) == static_cast<std::size_t>(1) );
//------------------------------------------------------------------------
#define RANDOM_ACCESS_ITERATOR_CHECK(iterator_t) \
    BOOST_STATIC_ASSERT ( \
    IsRandomAccesIterator< \
        typename std::iterator_traits<iterator_t>::iterator_category>::value );
//------------------------------------------------------------------------
//------------------------------------------------------------------------
#endif // __CHERCKHELPERS_HEADER_INCLUDED__
//------------------------------------------------------------------------

Файл base64_conv.h

//------------------------------------------------------------------------
#ifndef __BASE64_CONVERTER_HEADER_INCLUDED__
#define __BASE64_CONVERTER_HEADER_INCLUDED__
//------------------------------------------------------------------------
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/type_traits.hpp>
#include <vector>
#include <string>
#include <iterator>
#include <algorithm>
#include "check_helpers.hpp"
//------------------------------------------------------------------------
class base64_conv : private boost::noncopyable
{
public:
    typedef std::vector<char>           buffer_t;
    typedef boost::shared_ptr<buffer_t> p_buffer_t;

public:
    base64_conv();
    ~base64_conv();

    template<typename stl_container_t>
    void to_base64 ( const stl_container_t & sourse_data )
    {
        // This code can not be compiled, because a sequence is contained
        // by a wrong type; need sequence which contained by predefined char type
        CHARTYPE_SOURCE_SEQUENCE_CHECK(stl_container_t);

        std::vector<typename stl_container_t::value_type> tmp_buffer (
            sourse_data.begin(), sourse_data.end() );
        to_base64(tmp_buffer);
    }
    
    template<typename char_t, typename allocator_t>
    void to_base64 (
        const std::vector<char_t, allocator_t> & sourse_data )
    {
        if ( sourse_data.empty() )
        {
            p_buffer->clear();
            return;
        }

        to_base64_for_vector_or_string ( sourse_data.begin(), sourse_data.end() );
    }

    template<typename char_t, typename char_traits_t, typename allocator_t>
    void to_base64(
        const std::basic_string<char_t, char_traits_t, allocator_t> & sourse_data )
    {
        if ( sourse_data.empty() )
        {
            p_buffer->clear();
            return;
        }

        to_base64_for_vector_or_string ( sourse_data.begin(), sourse_data.end() );
    }

    template<typename stl_container_t>
    void from_base64( const stl_container_t & sourse_data )
    {
        // This code can not be compiled, because a sequence is contained
        // by a wrong type; need sequence which contained by predefined char type
        CHARTYPE_SOURCE_SEQUENCE_CHECK(stl_container_t);

        std::vector<typename stl_container_t::value_type> tmp_buffer (
            sourse_data.begin(), sourse_data.end() );
        from_base64(tmp_buffer);
    }

    template<typename char_t, typename allocator_t>
    void from_base64 (
        const std::vector<char_t, allocator_t> & sourse_data )
    {
        if ( sourse_data.empty() )
        {
            p_buffer->clear();
            return;
        }

        from_base64_for_vector_or_string (
            sourse_data.begin(), sourse_data.end() );
    }

    template<typename char_t, typename char_traits_t, typename allocator_t>
    void from_base64 (
        const std::basic_string<char_t, char_traits_t, allocator_t> & sourse_data )
    {
        if ( sourse_data.empty() )
        {
            p_buffer->clear();
            return;
        }

        from_base64_for_vector_or_string (
            sourse_data.begin(), sourse_data.end() );
    }

    p_buffer_t get_result();
    void get_result ( std::string & out_str );
    void get_result ( std::vector<char> & out_buffer );

private:
    template<typename in_rait_t>
    void to_base64_for_vector_or_string (
        const in_rait_t it_begin, const in_rait_t it_end )
    {
        // This code can not be compiled, because a sequence is contained
        // by a wrong type; need sequence which contained by predefined char type
        CHARTYPE_SOURCE_ITERATOR_CHECK(in_rait_t);

        // This code can not be compiled, because iterator_category of in_rait_t
        // is not equal std::random_access_iterator_tag
        RANDOM_ACCESS_ITERATOR_CHECK(in_rait_t);

        std::size_t data_length = std::distance(it_begin, it_end);
        if ( data_length <= 0 )
        {
            p_buffer->clear();
            return;
        }

        const char * p_data_begin = reinterpret_cast<const char*>( & * it_begin );
        do_encode_to_base64 ( p_data_begin, data_length );
    }

    template<typename in_rait_t>
    void from_base64_for_vector_or_string (
        const in_rait_t it_begin, const in_rait_t it_end )
    {
        // This code can not be compiled, because a sequence is contained
        // by a wrong type; need sequence which contained by predefined char type
        CHARTYPE_SOURCE_ITERATOR_CHECK(in_rait_t);

        // This code can not be compiled, because iterator_category of in_rait_t
        // is not equal std::random_access_iterator_tag
        RANDOM_ACCESS_ITERATOR_CHECK(in_rait_t);

        std::size_t data_length = std::distance(it_begin, it_end);
        if ( data_length <= 0 )
        {
            p_buffer->clear();
            return;
        }

        const char * p_data_begin = reinterpret_cast<const char*>( & * it_begin );
        do_decode_from_base64 ( p_data_begin, data_length );
    }

    void do_encode_to_base64 (
        const char * sourse_data,
        std::size_t sourse_data_size );

    void do_decode_from_base64 (
        const char * sourse_data,
        std::size_t sourse_data_size );

private:
    enum { MAX_LINE_LENGTH = 72 };
    p_buffer_t p_buffer;
};
//------------------------------------------------------------------------
#endif // __BASE64_CONVERTER_HEADER_INCLUDED__
//------------------------------------------------------------------------

Файл base64_conv.cpp

//------------------------------------------------------------------------
#include "stdafx.h"
#include "base64_conv.h"
//------------------------------------------------------------------------
namespace {

// Translation Table as described in RFC1113
//------------------------------------------------------------------------
const char cb64[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

// Translation Table to decode (created by author)
//------------------------------------------------------------------------
const char cd64[]="|$$$}rstuvwxyz{$$$$$$$>?@ABCDEFGHIJKLMNOPQRSTUVW$$$$$$XYZ[\\]^_`abcdefghijklmnopq";

// encode 3 8-bit binary bytes as 4 '6-bit' characters
//------------------------------------------------------------------------
void encodeblock ( unsigned char in[3], unsigned char out[4], int len )
{
    out[0] = cb64[ in[0] >> 2 ];
    out[1] = cb64[ ((in[0] & 0x03) << 4) | ((in[1] & 0xf0) >> 4) ];
    out[2] = (unsigned char) (len > 1 ? cb64[ ((in[1] & 0x0f) << 2) | ((in[2] & 0xc0) >> 6) ] : '=');
    out[3] = (unsigned char) (len > 2 ? cb64[ in[2] & 0x3f ] : '=');
}

// decode 4 '6-bit' characters into 3 8-bit binary bytes
//------------------------------------------------------------------------
void decodeblock( unsigned char in[4], unsigned char out[3] )
{   
    out[ 0 ] = (unsigned char ) (in[0] << 2 | in[1] >> 4);
    out[ 1 ] = (unsigned char ) (in[1] << 4 | in[2] >> 2);
    out[ 2 ] = (unsigned char ) (((in[2] << 6) & 0xc0) | in[3]);
}

// base64 encode a sequence adding padding and line breaks as per spec.
//------------------------------------------------------------------------
void encode (
    const char * in_sequence,
    std::size_t in_length,
    std::vector<char> & out_sequence,
    int line_size )
{
    unsigned char in[3], out[4];
    int i, len, blocks_out = 0;

    out_sequence.clear();
    out_sequence.reserve(in_length * 4/3);

    const char * it_begin   = in_sequence;
    const char * it_end     = in_sequence + in_length;

    while ( it_begin < it_end )
    {
        len = 0;
        for ( i = 0; i < 3; i++ )
        {
            if ( it_begin < it_end )
            {
                in[i] = static_cast<unsigned char>(*it_begin++);
                len++;
            }
            else
            {
                in[i] = 0;
            }
        }
        if ( len )
        {
            encodeblock( in, out, len );
            for( i = 0; i < 4; i++ )
            {
                out_sequence.push_back(out[i]);
            }
            blocks_out++;
        }
        if ( blocks_out >= (line_size/4) || ( it_begin == it_end ) )
        {
            if ( blocks_out )
            {
                out_sequence.push_back('\r');
                out_sequence.push_back('\n');
            }
            blocks_out = 0;
        }
    }
}

// decode a base64 encoded sequence discarding padding, line breaks and noise
//------------------------------------------------------------------------
void decode (
    const char * in_sequence,
    std::size_t in_length,
    std::vector<char> & out_sequence )
{
    unsigned char in[4], out[3], v;
    int i, len;

    out_sequence.clear();
    out_sequence.reserve(in_length * 3/4);

    const char * it_begin   = in_sequence;
    const char * it_end     = in_sequence + in_length;

    while( it_begin < it_end )
    {
        for( len = 0, i = 0; i < 4 && (it_begin < it_end); i++ )
        {
            v = 0;
            for ( ; (it_begin < it_end) && v == 0 ; ++it_begin )
            {
                v = static_cast<unsigned char>(*it_begin);
                v = static_cast<unsigned char>((v < 43 || v > 122) ? 0 : cd64[ v - 43 ]);
                if( v )
                {
                    v = static_cast<unsigned char>((v == '$') ? 0 : v - 61);
                }
            }
            if ( v )
            {
                len++;
                in[i] = static_cast<unsigned char>(v - 1);
            }
            else
            {
                in[i] = 0;
            }
        }
        if( len )
        {
            decodeblock( in, out );
            for( i = 0; i < len - 1; i++ )
            {
                out_sequence.push_back(out[i]);
            }
        }
    }
}

}
//------------------------------------------------------------------------
base64_conv::base64_conv()
    : p_buffer ( new std::vector<char> )
{
};
//------------------------------------------------------------------------
base64_conv::~base64_conv()
{
};
//------------------------------------------------------------------------
void base64_conv::do_encode_to_base64 (
    const char * sourse_data, std::size_t sourse_data_size )
{
    encode ( sourse_data, sourse_data_size, *p_buffer, MAX_LINE_LENGTH );
}
//------------------------------------------------------------------------
void base64_conv::do_decode_from_base64 (
    const char * sourse_data, std::size_t sourse_data_size )
{
    decode ( sourse_data, sourse_data_size, *p_buffer );
}
//------------------------------------------------------------------------
base64_conv::p_buffer_t base64_conv::get_result()
{
    return p_buffer;
}
//------------------------------------------------------------------------
void base64_conv::get_result (
    std::string & out_str )
{
    std::string ret_val;
    ret_val.reserve(p_buffer->size());
    std::copy (
        p_buffer->begin(),
        p_buffer->end(),
        std::back_inserter(ret_val) );
    std::swap(out_str, ret_val);
}
//------------------------------------------------------------------------
void base64_conv::get_result (
    std::vector<char> & out_buffer )
{
    std::swap(out_buffer, *p_buffer);
    p_buffer->clear();
}
//------------------------------------------------------------------------

Использование boost::spirit

2009-04-01T22:20:00.001+03:00

В данной статье я расскажу как написать свой парсер ini-файлов на C++. За основу возьмём контекстно-свободную грамматику, построенную в предыдущей статье "Создаём парсер для ini-файлов. Теория". Для построения парсера будет использоваться библиотека Boost Spirit, которая позволяет строить свои собственные парсеры комбинируя готовые примитивные парсеры при помощи парсерных комбинаторов.

Важно: в данной статье предполагается, что читатель знаком с основами C++ (в том числе будет активно использоваться STL). Если вы не очень в себе уверены, то я советую сначала прочитать пару статей для новичков по С++ и по STL.

Грамматика

Для начала вспомним какую грамматику для ini-фалов мы построили в предыдущей статье:

inidata = spaces, {section} .

section = "[", ident, "]", stringSpaces, "\n", {entry} .

entry = ident, stringSpaces, "=", stringSpaces, value, "\n", spaces .

ident = identChar, {identChar} .

identChar = letter | digit | "_" | "." | "," | ":" | "(" | ")" | "{" | "}" | "-" | "#" | "@" | "&" | "*" | "|" .

value = {not "\n"} .

stringSpaces = {" " | "\t"} .

spaces = {" " | "\t" | "\n" | "\r"} .

Её описание нам скоро понадобится.

C++ и Boost Spirit

Начните с установки boost (можно взять на официальном сайте или поискать готовые пакеты для вашей OS). Собирать boost не требуется, так как весь Spirit живёт в хедерах. Процесс установки для разных систем может быть различным, поэтому я не буду его здесь описывать.

Я постараюсь подробно описать процесс создания парсера на С++. При этом я не буду особенно думать о производительности, так как это не является целью данной статьи.

Начнём с подключения необходимых хедеров.

   1 #include <fstream>

2 #include <functional>

3 #include <numeric>

4 #include <list>

5 #include <vector>

6 #include <string>

7 

8 #include <boost/spirit.hpp>

9 #include <boost/algorithm/string.hpp>

10 

11 using namespace std;

12 using namespace boost::spirit;

Кроме хедера самого Spirit я включил библиотеку строчных алгоритмов из boost-а (буду использовать функцию trim). Конструкция using namespace не всегда является хорошей практикой, но здесь для краткости я себе это позволю.

Определим типы данных: запись — это пара «ключ — значение», секция — это пара «ключ — список записей», все данные ini-файла — это список секций.

  14 typedef  pair<string, string>    Entry;

15 typedef  list<Entry >            Entries;

16 typedef  pair<string, Entries>   Section;

17 typedef  list<Section>           IniData;

Кроме типов данных нам потребуются обработчики событий, которые будут вызываться в тот момент, когда парсер разберёт очередной нетерминал.

  19 struct add_section

20 {

21    add_section( IniData & data ) : data_(data) {}

22 

23    void operator()(char const* p, char const* q) const

24    {

25       string s(p,q);

26       boost::algorithm::trim(s);

27       data_.push_back( Section( s, Entries() ) );

28    }

29 

30    IniData & data_;

31 };

32 

33 struct add_key

34 {

35    add_key( IniData & data ) : data_(data) {}

36 

37    void operator()(char const* p, char const* q) const

38    {

39       string s(p,q);

40       boost::algorithm::trim(s);

41       data_.back().second.push_back( Entry( s, string() ) );

42    }

43 

44    IniData & data_;

45 };

46 

47 struct add_value

48 {

49    add_value( IniData & data ) : data_(data) {}

50 

51    void operator()(char const* p, char const* q) const

52    {

53       data_.back().second.back().second.assign(p, q);

54    }

55 

56    IniData & data_;

57 };

Обработчики событий представляют собой функторы, которые принимают на вход кусок строки (через два указателя).
Функтор add_section будет вызываться в тот момент, когда парсер распознает очередную секцию. В качестве параметра add_section получит имя этой секции. Функтор add_key будет вызван в тот момент, когда парсер распознает имя нового параметра. Функтор add_value будет вызван в тот момент, когда парсер распознает значение параметра. При помощи этих функторов организуется последовательное заполнение IniData: сначала добавляется пустая секция (add_section), потом в эту секцию кладется Entry с незаполненным значением (add_key), а потом это значение заполняется (add_value).

Теперь будем переносить грамматику из нотации Бэкуса-Наура в C++. Для этого создаётся специальный класс inidata_parser.

  59 struct inidata_parser : public grammar<inidata_parser>

60 {

61    inidata_parser(IniData & data) : data_(data) {}

62 

63    template <typename ScannerT>

64    struct definition

65    {

66       rule<ScannerT> inidata, section, entry, ident, value, stringSpaces, spaces;

67 

68       rule<ScannerT> const& start() const { return inidata; }

69 

70       definition(inidata_parser const& self)

71       {

72          inidata = *section;

73 

74          section = ch_p('[')

75                >> ident[add_section(self.data_)]

76                >> ch_p(']')

77                >> stringSpaces

78                >> ch_p('\n')

79                >> spaces

80                >> *(entry);

81 

82          entry =  ident[add_key(self.data_)]

83                >> stringSpaces

84                >> ch_p('=')

85                >> stringSpaces

86                >> value[add_value(self.data_)]

87                >> spaces;

88 

89 

90          ident  = +(alnum_p | chset<>("-_.,:(){}#@&*|") );

91 

92          value = *(~ch_p('\n'));

93 

94          stringSpaces = *blank_p;

95 

96          spaces = *space_p;

97       }

98 

99    };

100 

101    IniData & data_;

102 };

Этот класс инкапсулирует в себе всю грамматику. Разберёмся поподробнее. В строке 59 мы видим, что парсер наследуется от шаблонного класса grammar, используя crtp, — это необходимo для правильной работы Spirit-а. Парсер принимает в конструкторе ссылку на незаполненную IniData и сохраняет её (61). Внутри парсера нужно определить шаблонную структуру definition (63-64). У структуры definitionесть члены данных типа rule — это парсеры для каждого из нетерминалов нашей грамматики в форме Бэкуса-Наура (66). Необходимо определить функцию-член start, которая будет возвращать ссылку на главный нетерминал — inidata (68).

В конструкторе definition мы описываем грамматику. Грамматика переписывается на C++ почти дословно. inidata состоит из нескольких секций (72) — это выражается звёздочкой (как замыкание Клини, но звёздочка слева). Секция начинается с квадратной скобки — для этого используется встроенный парсер ch_p, который парсит один символ. Вместо запятой из нотации Бэкуса-Наура используется оператор >>. В квадратных скобках после выражения пишется функтор-обработчик события (75, 82, 86). Символ "+" слева означает «хотя бы один», а "~" означает отрицание. alnum_p — встроенный парсер для букв и цифр. chset<> соответствует любому символу из строки (важно, что минус идёт первым, иначе он воспринимается как знак интервала, вроде «a-z»). blank_p соответствует пробельному символу в строке (пробел или табуляция), space_p соответствует любому пробельному символу (в т.ч. и переводу строки и возврату каретки).

Отметим, что нетерминалы ident и identChar удалось слить в один благодаря оператору "+" — в нотации Бэкуса-Наура это было невозможно, т.к. там отсутствует подобное обозначение.

С грамматикой всё. Осталось научиться удалять комментарии и искать значение в IniData.
Для удаления комментариев нам потребуется специальный функтор.

 104 struct is_comment{ bool operator()( string const& s ) const { return s[] == '\n' || s[] == ';'; } };

Теперь напишем функцию поиска в IniData.

 106 struct first_is

107 {

108     first_is(std::string const& s) : s_(s) {}

109 

110     template< class Pair >

111     bool operator()(Pair const& p) const { return p.first == s_; }

112 

113     string const& s_;

114 };

115 

116 bool find_value( IniData const& ini, string const& s, string const& p, string & res )

117 {

118     IniData::const_iterator sit = find_if(ini.begin(), ini.end(), first_is(s));

119     if (sit == ini.end())

120        return false;

121 

122     Entries::const_iterator it = find_if(sit->second.begin(), sit->second.end(), first_is(p));

123     if (it == sit->second.end())

124         return false;

125 

126     res = it->second;

127     return true;

128 }

Вместо функтора first_is можно применить boost::bind, но я решил не мешать всё в одну кучу. С поиском всё просто: сначала в списке ищем секцию по имени, потом в списке записей секции ищем параметр по имени, и, если всё нашлось, то возвращаем значение параметра через параметр-ссылку.

Осталось написать main.

 130 int main( int argc, char** argv)

131 {

132    if ( argc != 4 )

133    {

134       cout << "Usage: " << argv[] << " <file.ini> <section> <parameter>" << endl;

135       return ;

136    }

137 

138    ifstream in(argv[1]);

139    if( !in )

140    {

141       cout << "Can't open file \"" << argv[1] << '\"' << endl;

142       return 1;

143    }

144 

145    vector< string > lns;

146 

147    std::string s;

148    while( !in.eof() )

149    {

150       std::getline( in, s );

151       boost::algorithm::trim(s);

152       lns.push_back( s+='\n' );

153    }

154    lns.erase( remove_if(lns.begin(), lns.end(), is_comment()), lns.end());

155    string text = accumulate( lns.begin(), lns.end(), string() );

156 

157    IniData data;

158    inidata_parser parser(data); //  Our parser

159    BOOST_SPIRIT_DEBUG_NODE(parser);

160 

161    parse_info<> info = parse(text.c_str(), parser, nothing_p);

162    if (!info.hit)

163    {

164        cout << "Parse error\n";

165        return 1;

166    }

167 

168    string res;

169    if (find_value(data, argv[2], argv[3], res))

170        cout << res;

171    else

172        cout << "Can't find requested parameter";

173    cout << endl;

174 }

Строки 132-136 — проверяем параметры программы: если их не 4, то выводим usage. Если с параметрами всё ок, то открываем файл (138-143). Если и с файлом всё нормально, то создаём массив строк lns (145) и считываем в него весь файл (147-153). После этого удаляем оттуда комментарии, используя припасённый функтор is_comment (154). В заключение склеиваем все строчки в одну (155).

В строчках 157-159 создаётся и инициализируется парсер. Теперь запускаем парсер — для этого используется функция parse, которая принимает на вход сам текст, парсер и специальный парсер для пропускаемых символов (скажем, мы хотели бы пропускать все пробелы). В нашем случае парсер для пропускаемых символов будет пустым — nothing_p (т.е. ничего не парсящий). Результатом функции parse является структура parse_info<>. Нас интересует булево поле hit этой структуры, которое истинное, если не произошло ошибок. В строчках 162-166 мы сообщаем, если произошла ошибка. Осталось только найти параметр, заданный в командной строке и вывести его значение (168-173).

Теперь код полностью написан. Компилируем его и запускаем на тестовом примере.

$ g++ ini.cpp -o ini_cpp



$ ./ini_cpp /usr/lib/firefox-3.0.5/application.ini App ID

{ec8030f7-c20a-464f-9b0e-13a3a9e97384}



$ ./ini_cpp /usr/lib/firefox-3.0.5/application.ini App IDD

Can't find requested parameter

Надеюсь, что данная статья поможет вам написать свой собственный парсер =)

P.S.: Наглым образом спёрто отсюда: Создаём парсер для ini-файлов на C++

Использование boost::datetime

2009-04-01T22:10:00.001+03:00

Gregorian
Posix Time
Local Time

Сейчас наверно сложно найти человека, который не столкнулся бы с необходимостью использования времени в своих целях, а точнее его цифрового представления. Цели могут быть совершенно разными, от простых замеров интервалов времени, в которые выполняется некий участок кода(совершенно не верный метод профайлинга, между прочим, но сейчас не об этом), до поддержки полноценных календарей в своих приложениях, которые должны быть актуальны для любого человека на земном шаре. Все эти манипуляции можно выполнить с помощью довольно аскетичной и простой в использовании, но в тоже время мощной библиотеки Boost.Date_Time. В библиотеке учитываются: високосный год, високосная секунда, летнее время и т.д
Разберемся с некоторой терминологией, используемой в библиотеке:
В библиотеке существую три глобальных типа разделения времени:

Time Point — некая точка во временном континууме, например дата Вашего рождения
Time Duration — интервал времени, не привязанный ни к какой точке временного континуума
Time Interval — интервал времени, привязанный к некой точке во временном континууме

Так же необходимо помнить о разрешающей способности каждого метода получения времени, разрешающая способность(Resolution) показывает — какая минимальная единица времени может быть использована при анализе имеющегося у вас объекта времени. Т.е это не что иное, как степень точности полученной временной точки. Наконец, перейдем к непосредственному знакомству с возможностями библиотеки.

boost::gregorian

Все примеры, используемые в данной статье подразумевает использование using namespace boost::<соответствующий_namespace> в начале каждого компилируемого юнита.
Данный компонент представляет нам Грегорианский календарь и все мыслимые возможности работы с ним. Он в свою очередь делится на следующие компоненты:

Разберем назначение каждой из них:

boost::gregorian::date — предназначен для простого хранения даты – точки во временном континууме. Поддерживает создание даты из строки определенного формата, а также посредством класса boost::date_time::day_clock, основанного на стандартном механизме С\С++ связанным с time_t
Помимо хранения даты(которая не может быть изменена у объекта, кроме как посредством operator=) у класса есть методы* для получения конкретных частей даты(year(), month(), day() etc.), преобразования внутреннего представления даты в строку, определенного формата(to_simple_string(),to_iso_string(),to_iso_extended_string()) и конвертации в(и обратно) стандартную С\С++ структуру tm(to_tm(),date_from_tm())

*- я не привожу описание каждой функции, более того я не буду, приводит полный список имеющихся функций, их список Вы можете посмотреть в ссылках, соответствующих конкретному классу. Функций довольно много и они довольно просты в использовании, так же я опускаю наличие параметров функции, если считаю это незначительным в данный момент.
Пример:

date xGPWStart(1941, Jun, 22); date xNowdays = day_clock::local_day(); std::cout << "The Great Patriotic War was started in " << xGPWStart << std::endl; std::cout << "And the current data is " << xNowdays; * This source code was highlighted with Source Code Highlighter.

Вывод:

The Great Patriotic War was started in 1941-Jun-22
And the current data is 2009-Jul-26

boost::gregorian::date_duration — служит для подсчета дней, используя boost::gregorian::date для вычислений.
Для удобства работы с date_duration существуют три класса: months_duration, years_duration и weeks_duration(так же есть typedef’ы на эти типы, представленные для удобства: months, years и weeks соответственно), которые могут быть прибавлены или вычтены из date_duration чтобы получить желаемый результат. Существует подводный камень, связанный с этими тремя классами. Если использовать их в своих вычислениях, то Вы можете получить результат, который Вы не ожидаете. Приведу пример:

date xSomeDay(1999, Jan, 28); date xDayInNextMonth; std::cout << "That's right: " << ( xDayInNextMonth = xSomeDay + months(1) ) << std::endl; std::cout << "And that's not: " << xDayInNextMonth + months(1); * This source code was highlighted with Source Code Highlighter.

That's right: 1999-Feb-28
And that's not: 1999-Mar-31

Такое поведение обусловлено особенностью класса months_duration, который будет всегда использовать конец месяца в арифметических операциях, если изначальный объект указывал на одно из возможных чисел, которыми оканчиваются месяцы(28, 29, 30, 31). Будьте внимательны при использовании данного типа, кстати month_iterator лишен этого недостатка(преимущества?), но о нем поговорим позже.

boost::gregorian::date_period — класс представлен для удобного представления интервала между двумя датами, может быть использован для определения вхождения определенной даты во временной интервал(contains()), пересечения интервалов(intersects(), intersection()), смежности дат(is_adjacent()) и определения отношения расположения одной даты относительно другой(is_after(), is_before()). Кроме того, существуют методы для комбинации интервалов(merge(), span()) и их изменения(shift(), expand()). Важно помнить, что последний дегь в периоде не входит в весь период, т.е в периоде 1-Jan-1999\10-Jan-1999 последним днем будет 9 января, а не 10.
Пример:

date_period xGPWDuration( date(1941, Jun, 22), date(1945, May, 9) ); date_period xStalinLifeYears( date(1878, Dec, 18), date(1953, Mar, 6) ); date_period xJukovsIncorrectLifeYears( date(1896, Dec, 6), date(1974, Jun, 14) ); std::cout << "The Great Patriotic War duration is " << xGPWDuration << std::endl; std::cout << "Was the GPW inside the Stalin's life years? " << std::boolalpha << xStalinLifeYears.contains(xGPWDuration) << std::endl; std::cout << "Jukov's incorrect life years is " << xJukovsIncorrectLifeYears << std::endl; xJukovsIncorrectLifeYears.expand( days(5) ); std::cout << "Jukov's correct life years is " << xJukovsIncorrectLifeYears << std::endl; //Last day isn't included in the interval date_period xFirstPeriod( date(1999, Jan, 1), date(1999, Jan, 10) ); date_period xSecondPeriod( date(1999, Jan, 10), date(1999, Jan, 12) ); std::cout << "Does these periods intersect? " << std::boolalpha << xFirstPeriod.intersects(xSecondPeriod) << std::endl; * This source code was highlighted with Source Code Highlighter.

Вывод:

The Great Patriotic War duration is [1941-Jun-22/1945-May-08]
Was the GPW inside the Stalin's life years? true
Jukov's incorrect life years is [1896-Dec-06/1974-Jun-13]
Jukov's correct life years is [1896-Dec-01/1974-Jun-18]
Does these periods intersect? false

boost::gregorian::date_iterator — как должно быть понятно из названия – это типичный итератор, предназначенный для “движения” по датам. date_iterator сам по себе не интересен, т.к является абстрактным классом, более интересны его классы-наследники: day_iterator, week_iterator, month_iterator, year_iterator.
В качестве примера используем пример из date_duration, в котором мы получали некорректную дату (из-за подводных камней с месяцами). Как я и упоминал раньше, в date_iterator подобных проблем нет:

month_iterator xSomeDay(date(1999, Jan, 28)); std::cout << "That's right: " << *++xSomeDay << std::endl; std::cout << "And that's too!: " << *++xSomeDay; * This source code was highlighted with Source Code Highlighter.

That's right: 1999-Feb-28
And that's too!: 1999-Mar-28

Алгоритмы по работе с датами — набор разнообразных классов и функций, для различных манипуляций над датами. Каждый класс имеет метод get_data() который позволяет получить дату, сгенерированную данным классом. Классы предоставляют нам следующий функционал:

Получить первый, последний или произвольный день для заданного месяца и недели(first_day_of_the_week_in_the_month(), last_day_of_the_week_in_the_month(), nth_day_of_the_week_in_the_month). День недели для поиска задается.
Задать частичную дату(без указания года)(partial_date()). А потом получать полную дату, с помощью get_data()
Вычислить первый день недели до или после заданной даты(first_day_of_the_week_before(), first_day_of_the_week_after()). День недели для вычисления задается

Функции предоставляют следующий функционал:

Вычислить кол-во дней начиная от текущей даты, до следующего или предыдущего, заданного, дня недели(days_until_weekday(), days_before_week_day()).
Сгенерировать дату, которая будет является датой следующего или предыдущего, заданного, дня недели. Новая дата будет сгенерирована, относительно предварительно заданной даты.

Примеры:

last_day_of_the_week_in_month xLastFriday(Friday, Jul); partial_date xJunTen(10, Jun); std::cout << "What is the date of the last friday in the July 2009? " << xLastFriday.get_date(2009) << std::endl; std::cout << "Just dusplay 10 Jun of 2009 " << xJunTen.get_date(2009) << std::endl; std::cout << "How much days from now till next friday? " << days_until_weekday( day_clock::local_day(), greg_weekday(Friday) )<< std::endl; * This source code was highlighted with Source Code Highlighter.

Вывод:

What is the date of the last friday in the July 2009? 2009-Jul-31
Just dusplay 10 Jun of 2009 2009-Jun-10
How much days from now till next friday? 5

boost::gregorian::gregorian_calendar — предоставляет полезный набор статических функций для работы с датами.
Вместо описания функций, приведу пример их использования(функции просты и их название говорит само за себя):

std::cout << "What the day of the GPW begining? " << DayToString( gregorian_calendar::day_of_week( gregorian_calendar::ymd_type(1941, Jun, 22) ) ) << std::endl; std::cout << "And what is the number of this day frome the epoch start? " << gregorian_calendar::day_number( gregorian_calendar::ymd_type(1941, Jun, 22) ) << std::endl; std::cout << "And what is the number of this day frome the epoch start? " << gregorian_calendar::day_number( gregorian_calendar::ymd_type(1400, Jan, 1) ) << std::endl; std::cout << "What is the last day in the February 1941? " << gregorian_calendar::end_of_month_day(1941, Feb) << std::endl; std::cout << "What is the date of the 3333333 day from the epoch start? " << date( gregorian_calendar::from_day_number(3333333) ) << std::endl; std::cout << "Is the 2004 year a leap year? " << std::boolalpha << gregorian_calendar::is_leap_year(2004) << std::endl; * This source code was highlighted with Source Code Highlighter.

Вывод:

What the day of the GPW begining? Sunday
And what is the number of this day frome the epoch start? 2430168
And what is the number of this day frome the epoch start? 2232400
What is the last day in the February 1941? 28
What is the date of the 3333333 day from the epoch start? 4414-Apr-03
Is the 2004 year a leap year? true

Эмпирическим путем было получено, что для функций day_number() и from_day_number() минимальными значениями являются 1400-Jan-1 и 2232400 соответственно. Если пытаться использовать дату ранее 1400-Jan-1, то получим исключение. То же справедливо и для количества дней.

boost::posix_time

Данный компонент предоставляет нам удобный метод работы с точками во времени, но в отличие от boost::gregorian boost::posix_time предоставляет возможность работы с временными точками более низкого разрешения (вплоть до наносекунд), высокая часть разрешения(дата) реализуется с помощью boost::gregorian. Компонент особенно удобен для задач, в которых необходима высокая точность получения времени(например строка записи в лог файле). Он делится на следующие части:

Разберем назначение каждой части:

boost::posix_time::ptime — представляет собой точку во временном континууме. Очень похожа на boost::gregorian:date но с разрешением до микросекунд. При создании экземпляра класса только по gregorian:date, “низкоразрешающая” часть устанавливается в полночь(все нули).
Пример использования:

ptime xTime(date(1961, Apr, 12), hours(9) + minutes(7)); std::cout << "Did you know that Gagrin said \"Poehali\" at " << xTime << "\n"; ptime xTimeStr( time_from_string("1961-04-12 09.07.00.0000") ); std::cout << "And the same time point constructed from a string: " << xTimeStr << "\n"; std::cout << "Current time with second resolution: " << second_clock::local_time() << "\nAnd with microsecond:" << microsec_clock::local_time(); * This source code was highlighted with Source Code Highlighter.

Вывод:

Did you know that Gagrin said «Poehali» at 1961-Apr-12 09:07:00
And the same time point constructed from a string: 1961-Apr-12 09:07:00
Current time with second resolution: 2009-Jul-29 16:41:51
And with microsecond:2009-Jul-29 16:41:51.087000

boost::posix_time::time_duration — представляет собой длительность во времени, которая не привязана к конкретной дате. Максимальное разрешение длительности ограничено наносекундами, если библиотека собрана с макросом BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG, и микросекундами, по умолчанию. Из объекта может быть получена информация о количестве секунд\микросекунд\миллисекунд\наносекунд(при соответствующей сборке) которые содержатся в текущей временной длительности.
Пример:

time_duration xTime(1,2,3); std::cout << "Print time: " << xTime << "\n"; std::cout << "Print increased time: " << xTime + hours(3) + seconds(2) + minutes(6) + milliseconds(15) + microseconds(25) << "\n"; std::cout << "Print total seconds: " << xTime.total_seconds() << " milliseconds: " << xTime.total_milliseconds() << " microseconds: " << xTime.total_microseconds() << "\n"; * This source code was highlighted with Source Code Highlighter.

Вывод:

Print time: 01:02:03
Print increased time: 04:08:05.015025
Print total seconds: 3723 milliseconds: 3723000 microseconds: 3723000000

boost::posix_time::time_period — представляет собой отрезок во времени, класс схож gregorian::date_period, но имеет более низкую разрешающую способность. Функционал класса позволяет определять вхождение(contains()), пересечение(intersects()) и длину(length()) интервалов. Так же существует возможность расширения(expand()), смещения(shift()) и объединения(merge()) интервалов.
Пример:

ptime xDoomsday( date(2012, Jan, 1) ); time_period xArmageddonLast(xDoomsday, hours(1)); time_period xChakNorrisSmoke(xDoomsday, minutes(1)); std::cout << "Doomsday was during: " << xArmageddonLast<< "\n"; std::cout << "Chak Norris was smoking at " << xChakNorrisSmoke << "\n"; std::cout << "Did Chak Norris smoke during Doomsday breathtaking?" << std::boolalpha <<xArmageddonLast.contains(xChakNorrisSmoke); * This source code was highlighted with Source Code Highlighter.

Вывод:

Doomsday was during: [2012-Jan-01 00:00:00/2012-Jan-01 00:59:59.999999]
Chak Norris was smoking at [2012-Jan-01 00:00:00/2012-Jan-01 00:00:59.999999]
Did Chak Norris smoke during Doomsday breathtaking?true

boost::posix_time::time_iterator — предназначен(как наверное все догадались :) ) для итерации по времени. Приятной особенностью данного итератора является возможность задания временного интервала, который будет использоваться при итерации, т.е. насколько и в каких единицах будет изменяться текущая точка во временном континууме при каждой итерации. В качестве временных единиц могут быть использованы все единицы от часа до наносекунд (если собрано с соответствующим флагом)
Приведу маленький пример:

ptime xTime(date(2012, Jan, 1)); time_iterator xIt(xTime, hours(6)); std::cout << "6 hours after Domsday has come!!!" << *++xIt; * This source code was highlighted with Source Code Highlighter.

Вывод:

6 hours after Domsday has come!!!2012-Jan-01 06:00:00

Local Time System

Данный компонент предоставляет нам возможность работы со временем, в разных часовых поясах и с разными правилами перехода на летнее время. Это достаточно мощный и нужный компонент, особенно необходимый для тех приложений где важно не просто текущее(локальное) время, а важен учет различных смещений во времени, согласно региональным соглашениям относительно времени(переход на летние время, часовой пояс и т.д). Итак, приведу список частей, которые входят в данный компонент:

boost::local_time:: posix_time_zone представляет собой набор данных и правил для представления часовых поясов(смещение относительно GMT, правила перехода на летнее время и обратно, название часового пояса и его аббревиатура). Объект данного типа создается на основании строки, формат строки является стандартизированным POSIX форматом(IEEE Std 1003.1) для часовых поясов.
В общем виде эта строка выглядит следующим образом:
std offset dst [offset],start[/time],end[/time]
std — Аббревиатура часового пояса.
offset — Смещение относительно GMT.
dst — Аббревиатура часового пояса, во время действия летнего времени.
[offset] — Показывает насколько изменяется время (в часах), при переходе на летнее время. Опциональный параметр.
start и end — Задают интервал действия летнего времени.
[/time] — Задает точное время в пределах дня, в которое начинается переход на летнее время или летнее время прекращает свое действие.
offset и time имеют следующий формат: [+|-]hh[:mm[:ss]] {h=0-23, m/s=0-59}
start и end могут быть представлены в одном из следующих форматов:

Mm.w.d {month=1-12, week=1-5 (5 всегда последняя), day=0-6}
Jn {n=1-365 29 февраля – не учитывается}
n {n=0-365 Учитывает 29 февраля в високосные годы}

Каждую часть этой строки вы может получить отдельно, с помощью методов данного класса. Не вижу смысла приводить здесь их имена, они достаточно прозрачны и отражают суть их назначения, так что обратитесь к документации, за их списком.
В качестве примера я использовал часовой пояс GMT+3(Московское время):

posix_time_zone xZone("MSK+3MSD+01,M3.5.0/02:00,M10.5.0/02:00"); std::cout << "Dailight period in 2009 started at " << xZone.dst_local_start_time(2009) << "\nAnd it will finish at " << xZone.dst_local_end_time(2009); * This source code was highlighted with Source Code Highlighter.

Вывод:

Dailight period in 2009 started at 2009-Mar-29 02:00:00
And it will finish at 2009-Oct-25 02:00:00

boost::local_time::tz_database — удобный класс для хранения множества различных часовых поясов. При создании объекта, создается пустая база данных (громко сказано конечно :) ), после чего она может быть вручную заполнена, с помощью метода add_record() или же прочитана из csv(comma separated values) файла, пример такого файла(с большим количеством записей) содержится в %boost%\libs\date_time\data\date_time_zonespec.csv
Формат записи внутри этого файла, должен удовлетворять следующему стандарту:

«ID»,«STD ABBR»,«STD NAME»,«DST ABBR»,«DST NAME»,«GMT offset»,«DST adjustment»,«DST Start Date rule»,«Start time»,«DST End date rule»,«End time»

Где:
ID – Содержит строку, однозначно идентифицирующую данный часовой пояс.
STD ABBR, STD NAME, DST ABBR, DST NAME — Эти поля заполняются строками с именами и аббревиатурами стандартного и летнего времен, зачастую имена и аббревиатуры идентичны.
GMT offset — Смещение во времени, относительно Гринвича. Его формат: {+|-}hh:mm[:ss]
DST adjustment — Смещение относительно GMT offset во время действия “летнего времени”. Формат тот же, что и у GMT offset.
DST Start Date rule — Строка описывающая день в году, который возвещает начало периода “летнего времени”. Так же имеет свой формат(сколько можно форматов разных?):

weekday;day-of-week;month
Где:
weekday — Порядковое числительное, индицирующее какой по счету день в месяце, нас интересует.
day-of-week — день недели.
month — месяц.
Пример:

-1;0;3 – Начало “летнего времени” в России(последнее воскресенье марта)

Start time — Время после полуночи, в которое вступает в силу “летнее время”. Формат тот же, что и у GMT offset.
DST End date rule — Строка описывающая день в году, который возвещает конец периода “летнего времени”. Формат идентичен DST Start Date rule.
End time — Аналог Start time, только для окончания “летнего времени”.
Пример:

tz_database xDb; xDb.load_from_file("G:\\Program files\\boost\\boost_1_39_0\\\libs\\date_time\\data\\date_time_zonespec.csv"); const std::vector<std::string>& xAllRegions = xDb.region_list(); std::cout << "Print first 10 zone IDs from the boost time zone file:" << std::endl; for(std::vector<std::string>::const_iterator it = xAllRegions.begin(); it != xAllRegions.begin() + 10; ++it) std::cout << *it << std::endl; std::cout << "And time when daylight saving was started at 2009: " << xDb.time_zone_from_region("Europe/Moscow")->dst_local_start_time(2009) << std::endl; * This source code was highlighted with Source Code Highlighter.

Вывод:

Print first 10 zone IDs from the boost time zone file:
Africa/Abidjan
Africa/Accra
Africa/Addis_Ababa
Africa/Algiers
Africa/Asmera
Africa/Bamako
Africa/Bangui
Africa/Banjul
Africa/Bissau
Africa/Blantyre
And time when daylight saving was started at 2009: 2009-Mar-29 02:00:00

boost::local_time::custom_time_zone — класс для создания описания часового пояса, но в отличие от прежде описанного boost::local_time::posix_time_zone , данный класс использует четыре других класса, при конструировании часового пояса. Это классы: time_duration , time_zone_names , dst_adjustment_offsets и dst_calc_rule. Так как класс не выделяется ничем выдающимся, то просто приведу пример его использования:

time_zone_names xNames("Moscow Standart Time", "MST", "Moscow Daylight Time", "MDT"); time_duration xGMTOffset(3, 0, 0); dst_adjustment_offsets xRulesOffsets( time_duration(1,0,0), time_duration(2,0,0), time_duration(3,0,0) ); //Mak daylight's rule last_day_of_the_week_in_month xStartRule(Sunday, Mar); last_day_of_the_week_in_month xEndRule(Sunday, Oct); boost::shared_ptr<dst_calc_rule> xRules( new last_last_dst_rule(xStartRule, xEndRule) ); custom_time_zone xCustomTimeZone(xNames, xGMTOffset, xRulesOffsets, xRules); std::cout << "The our time zone name is: " << xCustomTimeZone.std_zone_name() << "\n" << "It has an "<< xCustomTimeZone.base_utc_offset() << " offset from GMT.\n" << "And daylight period will end at "<< xCustomTimeZone.dst_local_end_time(2009) <<std::endl; std::cout << "Posix string which represents our custom_time_zone object is:\n" << xCustomTimeZone.to_posix_string(); * This source code was highlighted with Source Code Highlighter.

Вывод:

The our time zone name is: Moscow Standart Time
It has an 03:00:00 offset from GMT.
And daylight period will end at 2009-Oct-25 03:00:00
Posix string which represents our custom_time_zone object is:
MST+03MDT+01,M3.5.0/02:00,M10.5.0/03:00

Классы boost::local_time::local_date_time и boost::local_time::local_time_period повторяют схожие классы из boost::posix_time, с привязкой к часовому поясу, поэтому я не буду их рассматривать.

Полезные особенности и заключение

В Boost.Data_time, помимо классов для создания дат, есть полезные утилиты, такие как: форматируемая обработка ввода\вывода и сериализация. Оба механизма достаточно просты.

P.S.: Наглым образом спёрто отсюда: Boost это просто. Часть 2. Boost.Date_time.

Использование интеллектуальных указателей из boost

2009-04-01T22:00:00.001+03:00

Ни для кого не секрет, что работа с динамической памятью и системными ресурсами вообще является одним из самых сложных аспектов при программировании на С++. Сложность этой проблемы заключается в том, что память и ресурсы имеют обыкновение утекать… Безвозвратно и бесконтрольно. И если синтаксические и логические ошибки выловить в программе достаточно просто, то на поиск утечек памяти уходит не одна неделя. За все время существования этой проблемы разработчиками было придумано множество путей облегчения себе жизни. Кто-то, избрав путь наименьшего сопротивления, перешел на такие языки, как Java или C#, где за ресурсами следить вроде как не надо – на это существуют сборщики мусора, а динамическая память (в понимании С++) отсутствует как класс. Кто-то вооружившись BoundsChecker’ом анализирует результаты работы программы с целью выявить места, в которых происходит утечка. Кто-то, набравшись терпения, пишет собственные менеджеры памяти и сборщики мусора для С++. А кто-то, взяв на вооружения некоторые идеи языка С++, разрабатывает т. н. ведущие указатели, дабы, оставаясь в рамках языка, исключить саму возможность утечек.

Что есть ведущий указатель (или, иначе говоря Smart Pointer)? Это объект, поведение которого не отличается (ну, или почти не отличается) от поведения обычного указателя, но обладающий при этом рядом достоинств, отсутствующих у обычного указателя. Вообще говоря, по этому поводу написано столько, что писать еще раз тоже самое – большого смыла нет. Достаточно лишь упомянуть вот о чем. Ведущие (или умные) указатели обычно подразделяются на два основных типа – «слабые» и с «подсчетом ссылок». Слабые указатели позволяют без лишних затрат освободить хранящийся в них объект по выходу из блока, в котором такой указатель был объявлен. Тем самым решается проблема «потерянных ссылок», когда разработчик, по невнимательности, забывает освобождать динамическую память, указатель на которую сохраняется на стеке:

void SomeFunc()
{
char* buff = new char[16];
_itoa(125, buff, 10);

}

В этом примере буфер был выделен, но не был удален. Указатели же с подсчетом ссылок позволяют контролировать объект в течение гораздо более длительного срока. Достигается это тем, что такой указатель «считает ссылки» на указываемый объект и удаляет только тогда, когда контролируемый объект уже никому не нужен. Пример: Объявляется класс:

class SomeClass
{
public:
   SomeClass() {m_SomeObject = new int;}

   ~SomeClass() {delete m_SomeObject;}
private:
   int *m_SomeObject;
};
// потом где-то в коде имеет место такая конструкция:

SomeClass obj1;
{
   SomeClass obj2(obj1);
   // Что-то делаем с объектом obj1
}
// Что-то делаем с объектом obj2

Что произойдет? Правильно. После выхода из блока и вызова деструктора для obj2 указатель в obj1 станет недействительным. Избежать этого можно переписав конструктор копий и оператор присваивания. Но есть и более простой путь – воспользоваться указателем с подсчетом ссылок. Такой указатель можно реализовать самому. И наверняка многие так и делают. Но это не что иное, как изобретение велосипеда, название которому – boost::smart_ptr.

Как это использовать

scoped_ptr, shared_ptr, scoped_array, shared_array

Этот раздел библиотеки включает в себя группу классов, реализующих обе вышеописанные разновидности указателей: boost::scoped_ptr и boost::shared_ptr Первый используется для контроля времени жизни указателя в пределах операторного блока. Второй – для длительного контроля за указателем. Существуют разновидности этих классов для указателей на массивы: boost::scoped_array и boost::shared_array соответственно. Разница между этими группами классов очевидна. Первые для удаления контролируемого указателя используют оператор delete, а вторые – оператор delete[]. По этому путать их не рекомендуется во избежании возможных неприятностей с менеджером памяти. В общем случае использовать экземпляры этих классов можно почти также, как и указатели:

boost::shared_ptr<SomeClass> ptr(new SomeClass);
ptr->SomeFunc(); // вызываем метод класса по указателю

std::cout << *ptr; // выводим экземпляр класса в поток.
// а вот и то самое «почти»:
SomeClass* ptr1;
if (ptr == ptr1) // тут будет ошибка компиляции

   // что-то делаем

Дело в том, что ведущим указателям не рекомендуется иметь оператора преобразования к указываемому типу (подробней об этом можно прочитать у Александреску). Для получения явного указателя на ведущий объект используется метод get. Кроме метода get для этих классов определены следующие методы:

Метод	Назначение
Общие
reset	Уменьшает счетчик ссылок на единицу (если для shared_ptr) и, если необходимо, удаляет объект
swap	Обменивает значения двух объектов
scoped_array/shared_array
operator []	Предоставляет доступ по индексу
shared_ptr/shared_array
unique	Возвращает true, если счетчик ссылок == 1
use_count	Возвращает значения счетчика ссылок
operator bool	Возвращает true, если указатель проинициализирован

Подробно о сигнатурах этих методов можно прочитать в документации. Приведенные выше примеры кода с использованием этих классов будут выглядеть так:

void SomeFunc()

{
scoped_array<char> buff = new char[16];
_itoa(125, buff.get(), 10);

}

class SomeClass
{
public:
   SomeClass() {m_SomeObject.reset(new int);}

private:
   boost::shared_ptr<int> m_SomeObject;
};

Применение этих классов достаточно прозрачно, и не должно представлять каких-либо затруднений. Кроме этих четырех классов в джентельменский набор умных указателей входят еще два класса-помошника: boost::weak_ptr и boost::intrusive_ptr

weak_ptr

Первый (boost::weak_ptr) используется в паре с shared_ptr для хранения ссылок на объекты типа boost::shared_ptr. Так же, как и обычные ссылки/указатели на shared_ptr, weak_ptr не увеличивает счетчик ссылок. Но, в отличии от обычных ссылок/указателей, weak_ptr предоставляет дополнительный сервис, заключающийся в том, что если хранимый в нем объект в какой-то момент времени удаляется «извне», то попытка получения его из weak_ptr приводит к исключению. Используется weak_ptr в случае, когда постоянное владение объектом не нужно, но, тем не менее, необходим прозрачный контроль над ним. Например:

std::vector<boost::shared_ptr<SomeClass> > m_Vector;
std::map<std::string, boost::weak_ptr<SomeClass> > m_Map;

Предполагается, что m_Vector хранит и владеет экземплярами класса SomeClass, а m_Map – предоставляет быстрый доступ к этим объектам по некоторой строке. Инициализироваться они будут так:

m_Vector.push_back(boost::shared_ptr<SomeClass>(new SomeClass));
m_Map.insert(std::make_pair(m_Vector.back()->Key, m_Vector.back());

Теперь, если мы удалим какой-либо элемент из вектора, при попытке доступа к нему по ключу приведет к исключению. При этом дополнительных проверок на действительность ссылок делать не надо.

intrusive_ptr

Второй класс (boost::intrusive_ptr) используется при работе с объектами, использующими встроенный счетчик ссылок. Пример – COM-объекты. Этот класс предполагает, что определены функции intrusive_ptr_add_ref и intrusive_ptr_release (не являющиеся фунциями-членами хранимого класса), фактически увеличивающие или уменьшающие счетчик ссылок объекта. Для COM-объектов использование такого указателя могло бы выглядеть так:

int intrusive_ptr_add_ref(IUnknown* p) {return p->AddRef();}
int intrusive_ptr_release(IUnknown* p) {return p->Release();}

после чего можно смело писать: boost::intrusive_ptr<ISomeInterface> ptr(…);

Этот класс имеет интерфейс, аналогичный классу boost::shared_ptr, за исключением того, что его нельзя использовать в связке с boost::weak_ptr. Функциональность описанных классов покрывает большинство задач, которые могут возникнуть при решении проблем с контролем указателей. Если же потребуется что-то специфическое (что мало вероятно) всегда можно изобрести свой собственный велосипед и использовать его. Приведенное описание не претендует на полноту. Были опущены некоторые моменты, связанные с использованием классов, в частности класса weak_ptr. Для получения более полной информации можно заглянуть непосредственно в документацию: http://www.boost.org/libs/smart_ptr/smart_ptr.htm

P.S.: Наглым образом спёрто отсюда: [[doc:cpp:boost:shared_ptr]]

Использование boost::bind

2009-04-01T21:50:00.001+03:00

Одним из самых мощных средств стандартной библиотеки языка являются алгоритмы. Их в STL много. А там, где алгоритмы – появляются функторы и их разновидности – предикаты. И все было бы замечательно, если бы не одна большая ложка дегтя – средства стандартной библиотеки предоставляют слишком мало возможностей для описания функуторов. Все просто, если в алгоритм необходимо передать какую-либо глобальную функцию, или простой указатель на метод класса, хранящегося в контейнере.

Но когда речь заходит о чем-то более сложном, как-то:

передача заданного значения в предикат;
передача указателя на метод класса, не являющегося членом контейнера;
предварительная обработка элементов контейнера перед передачей их в функтор;
передача в функтор значений элементов данных объектов обрабатываемой последовательности;
(список можно продолжить…)

то STL уже не может предложить чего-либо более-менее пригодного к использованию. Сразу же оказывается, что std::binder1st и std::binder2nd накладывают существенные ограничения на принимаемые параметры (кто не сталкивался с «reverence to reference is not allowed» при использовании их в связке с mem_fun_ref?), в стандартные предикаты нельзя передать результат выполнения некоторой операции над элементом контейнера, std::mem_fun и std::mem_fun_ref позволяют работать только с объектами, являющимися членами обрабатываемой последовательности… Вообщем мрак. Проблемы некоторым образом решаются с помощью написания собственных функторов и адаптеров функторов. Но разработка минимально необходимого джентльменского набора – сама по себе нетривиальная задача. Тем более, что она уже имеет весьма элегантное решение, называемое boost::bind. Без преувеличения можно сказать, что по сравнению со связкой boost::bind/boost::mem_fn близкие по функциональности классы из STL кажутся жалкой поделкой. И не без основания. При использовании классов из STL приходится всякий раз задумываться – а какой из вариантов связывателя подойдет к данному конкретному случаю, и подойдет ли вообще. С boost::bind о подобных вещах заморачиваться не надо. К каждому варианту использования компилятор самостоятельно подберет необходимый связыватель. Или выдаст ошибку, если соответствующего варианта подобрать нельзя. В коде использовать этот класс не просто, а очень просто. Рассмотрим несколько типовых вариантов.

Использование с глобальной функцией

Предположим, что есть функция:

bool compare(int a, int b) {return a < b;}

для того, чтобы использовать эту функцию в, например, алгоритме sort нам необходимо написать:

std::vector<int> vec(…);
std::sort(vec.begin(), vec.end(), compare);

Теперь немного усложним задачу – в зависимости от флага нам необходимо сортировать либо по возрастанию, либо по убыванию. При использовании только STL пришлось бы писать две функции. Накладно. С помощью boost эту задачу решить значительно проще:

bool compare(int a, int b, bool reverseSort) {return reverseSort ? a > b : a < b;}

 
std::vector<int> vec(…);
std::sort(vec.begin(), vec.end(), boost::bind(compare, _1, _2, order));

где order – булевская переменная, задающая порядок сортировки. Последняя строчка выглядит несколько странновато, но именно в ней и заключается вся суть. В результате ее компиляции будет получен код, реализующий сортировку массива, использующий для сравнения функцию compare, и передающей ей на вход три аргумента – два числа, которые необходимо сравнить, и способ их сравнения. Почему именно так? Рассмотрим этот код подробнее, записав его так:

int a = 1, b = 2;
boost::bind(compare, _1, _2, false)(a, b);

(что-то подобное содержится в недрах функции std::sort). Последняя строчка в этом коде обозначает следующее:

boost::bind – функция, создающая необходимый нам связыватель. Возвращает экземпляр функционального объекта (функтора), для которого применим оператор вызова функции. (compare, - первый аргумент функции определяет имя/указатель на функцию, которая должна быть вызвана в связывателе. В данном случае это функция compare; _1, _2 – плейсхолдеры, определяющие логику передачи параметров из оператора вызова функции в функцию compare. , false) – значение последнего аргумента, передаваемого в compare. (a, b) – оператор вызова функции, производящий связывание аргументов и вызов функции compare. В итоге будет выполнена следующий код:

compare(a, b, false);

Из приведенного примера можно увидеть, что упомянутые выше плейсхолдеры определяют связь между аргументами у оператора вызова функции связывателя и аргументами вызываемой функцией. Причем, количество аргументов у оператора вызова функции связывателя определяется количеством плейсхолдеров:

boost::bind(compare, _1, 4, false)(a, b); // неправильно. 

boost::bind(compare, _1, 4, false)(a); // правильно
boost::bind(compare, _1, _2, false)(a); // неправильно

boost::bind(compare, _1, _2, false)(a, b); // правильно

Очевидно, что попытка задать в вызове boost::bind количество параметров, несоответствующее количеству обязательных параметров в вызываемой функции приведет к ошибке. Равно как и попытка указания количества параметров большего, чем количество параметров в вызываемой функции. Действуя по аналогии мы можем записать:

std::find_if(vec.begin(), vec.end(), boost::bind(compare, _1, 4, false)); // поиск первого числа, меньшего 4

std::remove_if(vec.begin(), vec.end(), boost::bind(compare, _1, 4, true)); // удаление из последовательности всех элементов, больших 4

// и т. д.

В случае использования чистого STL для каждого случая пришлось бы искать подходящий функтор… Или писать его. Здесь необходимо обратить внимание на то, что в качестве первого параметра функции bind может выступать не только указатель на функцию, но и другой функциональный объект. Например:

std::find_if(vec.begin(), vec.end(), boost::bind(std::equal_to<int>(), _1, 4));

этот строчка найдет в массиве первый элемент, равный 4.

Использование с указателями на функции члены

Помимо указателей на глобальные функции и функторов, в качестве первого параметра можно указывать указатель на функцию-член какого-то класса. Предположим один из простейших вариантов использования:

class GraphicsObject

{
public:
   void Draw(Canvas* canvas, DrawModes mode);
};
// Объявляем коллекцию объектов этого класса:
std::list<GraphicsObject*> GraphObjects;

// А теперь нам нужно отрисовать все объекты коллекции на заданном канвасе
std::for_each(GraphObjects.begin(), GraphObjects.end(); ……..);

при использовании чистого STL нам бы пришлось писать свой собственный функтор, вызывающий у переданного объекта метод Draw с заданными параметрами. Но можно воспользоваться boost::bind:

std::for_each(GraphObjects.begin(), GraphObjects.end(), 
    boost::bind(&GraphObject::Draw, _1, canvas, mode));

в результате чего мы получаем требуемый результат. У всех объектов коллекции вызывается метод Draw, которому передаются параметры canvas и mode. При использовании указателя на функцию-член класса необходимо помнить о том, что первым параметром ей должен передаваться указатель на объект, для которого эта функция должна вызываться. В приведенном примере мы указываем, что метод должен вызываться у переданного в bind единственного параметра. Но никто не мешает нам в качестве первого передаваемого параметра указать this, или любой другой указатель. Но, как говориться в современных набивших оскомину рекламах, это еще не все.

Использование с указателем на член данных

Помимо указателей на члены-функции можно использовать указатели на члены данных. Синтаксис подобный и правила использования при этом почти такие же. Возьмем задачу. Есть структура и вектор ее экземпляров:

struct Point
{

    int x;
    int y;
};
 
std::vector<Point> PointsArray;

Теперь надо удалить из этого массива все элементы, у которых координата x равна нулю. Сделать это просто:

std::remove_if(PointsArray.begin(), PointsArray.end(), 
    boost::bind(std::equal_to<int>(), boost::bind(&Point::x, _1), 0));

Т. е. для каждого элемента массива вызывается вложенный связыватель, который возвращает значение соответствующего элемента структуры, после чего производится его сравнение с нулем. Тут мы видим еще одну возможность связывателей:

Каскадное использование связывателей

Связыватели могут вкладываться друг в друга. Один из вариантов такого вкладывания проиллюстрирован предыдущем примером. Единственное, что в этом случае надо «держать в голове» - это то, что плейсхолдеры, вне зависимости от того, в каком bind'ере (по уровню вложенности) они находятся, «адресуют» параметры самого внешго binder'а. Усложним предыдущий пример. Нужно выбросить все точки, имеющие нулевые координаты:

std::remove_if( PointsArray.begin(), PointsArray.end(), boost::bind(

    std::logical_and(), 
        boost::bind(std::equal_to<int>(), boost::bind(&Point::x, _1), 0),
        boost::bind(std::equal_to<int>(), boost::bind(&Point::y, _1), 0)

    )
));

Это хотя и работает так, как хочется, но выглядит слишком наворочено. По этому начиная с версии 1.33 в boost::bind появилась новая возможность -

Перегруженные операторы

Для упрощения приведенных выше многоэтажных конструкций для boost::bind (начиная с версии 1.33 boost'а) перегружены следующие операторы: !, ==, !=, <, ?, > и >=. Таким образом, приведенное выше выражение упрощается до:

std::remove_if( PointsArray.begin(), PointsArray.end(), boost::bind(

    boost::bind(&Point::x, _1) == 0 && boost::bind(&Point::y, _1) == 0)

    ));

Использование ссылок

Одна из неприятностей заключается в том, что если связываемая функция принимает какой-то из своих аргументов по ссылке, то с использованием boost::bind его (напрямую) передать нельзя. Т. е. например, в следующем случае:

void foo(int& a, int& b);

 
int a = 1, b = 2;
boost::bind(foo, a, b);

аргументы a и b по ссылке переданы не будут. Для того, чтобы действительно передать ссылки, необходимо делать такой вызов:

boost::bind(foo, boost::ref(a), boost::ref(b));

В этом случае foo, вызываемый из связывателя, будет действительно работать со ссылками на соответствующие переменные.

Полную документацию и примеры использования можно найти в оригинальной документации: http://www.boost.org/libs/bind/bind.html

Пример использования.

#include <vector>
#include <boost/bind.hpp>
#include <boost/function.hpp>

class Test
{
public:
    void f_1()
    {
        std::cout << "void f()" << std::endl;
    }

    void f_2(int i)
    {
        std::cout << "void f_2(): " << i << std::endl;
    }

    void f_3(const int &i)
    {
        std::cout << "void f_2(): " << i << std::endl;
    }

    void two_params(int a, int b)
    {
        std::cout << "void two_params(int a, int b): " << a << ", " << b << std::endl;
    }
};

class Test2
{
public:
    void do_stuff(const std::vector<int>& v) 
    {
        std::copy(v.begin(), v.end(),  std::ostream_iterator<int>(std::cout, " "));
    }
};

void test(const std::string &a)
{
    std::cout << "void test(const std::string &a). a = " << a << std::endl;
}

void prn ( boost::function<void(int)> fn, int a )
{
    fn ( a );
}

int _tmain(int argc, _TCHAR* argv[])
{
    ////////////////////// bind //////////////////////
    std::cout << "boost::bind test" << std::endl;
    Test a;
    boost::bind(&Test::f_1, &a)();

    boost::bind(&Test::f_2, &a, 1)();
    int test_int(2);
    boost::bind(&Test::f_2, &a, _1)(test_int);

    boost::bind(&Test::f_3, &a, 3)();
    int test_int_2(4);
    boost::bind(&Test::f_3, &a, _1)(test_int_2);

    int one(100), two(200);
    boost::bind(&Test::two_params, &a, _1, _2)(one, two);
    boost::bind(&Test::two_params, &a, _2, _1)(one, two);

    std::string test_str("Hi there.");
    boost::bind(&test, test_str)();
    boost::bind(&test, _1)(test_str);
    std::cout << std::endl;
    
    ////////////////////// function //////////////////////
    std::cout << "boost::function test" << std::endl;
    
    boost::function<void (void)> func;
    func = boost::bind(&Test::f_1, &a);
    func();
    func = boost::bind(&Test::f_2, &a, 201);
    func();
    func = boost::bind(&Test::f_3, &a, 202);
    func();
    func = boost::bind(&Test::two_params, &a, 203, 204);
    func();

    boost::function<void (int)> func_2;
    func_2 = boost::bind(&Test::f_2, &a, _1);
    prn(func_2, 301);
    func_2 = boost::bind(&Test::f_3, &a, _1);
    prn(func_2, 302);

    int i_303(303), i_304(304), i_305(305), i_306(306);
    func_2 = boost::bind(&Test::two_params, &a, i_303, _1);
    prn(func_2, 1);
    func_2 = boost::bind(&Test::two_params, &a, _1, i_304);
    prn(func_2, 1);

    Test2 t;
    std::vector<int> vec;
    vec.resize(20);
    std::generate_n(vec.begin(), 20, rand);
    std::copy(vec.begin(), vec.end(),  std::ostream_iterator<int>(std::cout, " "));
    //simple_bind(&Test::do_stuff, t, _1)(vec);
    //boost::bind(&Test2::do_stuff, t, _1)(vec);

    return 0;
}

P.S.: Наглым образом спёрто здесь: [[doc:cpp:boost:bind]]

Использование boost::function

2009-04-01T21:40:00.001+03:00

Во многих современных языках существует понятие «делегата» - некоторой сущности, позволяющей косвенно вызвать тот или иной метод. Наиболее близкая аналогия в С++ - это указатель на функцию или член класса. Но каждый разработчик на С++, кто сталкивался с такого рода указателями, в итоге выясняет, что они - не полноценный аналог делегата. По двум причинам:

Указатель на функцию и указатель на член класса не могут быть преобразованы друг в друга.

Для доступа к члену класса по указателю обязательно требуется указатель на объект, относительно которого производится вызов.

А по этому, если указатели на свободные функции или статические функции еще можно как-то рассматривать в качестве делегатов, то с указателями на члены класса все гозаздо сложнее. Для устранения этих проблем и был создан шаблонный класс boost::function (а точнее - набор шаблонных классов).

Что это такое? По сути - boost::function (точнее, результат его инстанцирования) - это функтор (функциональный объект), к которому применим оператор »()» (вызова функции). А потому в исходный тексте программы вызов метода напрямую или через boost::function ничем не отличимы.

В качестве аргументов шаблона boost::function принимает сигнатуру метода, который он будет «эмулировать». Например:

boost::function<void ()> foo1;
// (соответствует методу с сигнатурой void foo1();)

boost::function<int (int, float, SomeClass&)> foo2;
// соответствует методу
// int foo2(int arg1, float arg2, SomeClass& arg3)

// и т. д.

А инициализироваться может либо указателем на соответствующий метод, либо другим функциональным объектом, который может быть вызван с указанными параметрами:

void foo1(int a) {;}

struct Foo1
{
   void operator() (int a) {;}
}

boost::function<void (int)> Delegate;

//...
Delegate = foo1;
// ...
Delegate(10); // будет реально вызван foo1(10)
// ...
// ...
Delegate = Foo1();
// ...
Delegate(10); // будет вызван Foo1::operator()(10);

Как это использовать

boost::function можно использовать:

Со свободными (глобальными) функциями.

С функциями-членами.

С функциональными объектами.

Синтаксис объявления экземпляра boost::function не меняется. Аргументы, которые может принимать boost::function такие же, какие может принимать обычная функция. При этом (как и для обычной функции) можно перечислять как просто типы аргументов, так и типы с формальными именами параметров:

// оба объявления равноценны
boost::function<void (int, float[], SomeClass&)> f1;
boost::function<void (int a, float arr[], SomeClass& sc)> f2;

Максимальное количество аргументов, которое может принимать boost::function зависит от реализации. Чаще всего - не больше 10.

После объявления экземпляра boost::function его необходимо обязательно заполнить (проинициализировать). До этого момента экземпляр будет считаться «пустым» и при попытки применить к нему оператор вызова функции будет выброшено исключение bad_function_call.

Использование вместе со свободными функциями

Для использования boost::function совместно со свободными функциями достаточно проинициализировать объект адресом соответствующей функции:

void foo(int, int) {;}

boost::function<void (int, int)> f1;
f1 = foo;
// или
f1 = &foo;

Использование вместе с функциями-членами

Используется также, как и со свободными функциями:

class SomeClass
{
public:
 void foo(int, int) {;}
}

boost::function<void (int, int)> f1;
f1 = &SomeClass::foo;

Но использование такого функционального объекта требует передачи ему экземпляра класса, для которого должна быть вызвана функция:

SomeClass obj;
f1(&obj, 10);

В случае необходимости передачи «чистого» функционального объекта ситуацию спасает использование boost::bind, или std::bind1st:

SomeClass* obj = ...;
f1 = boost::bind(&SomeClass::foo, obj, _1);
//...
f1(10); // эквивалентен вызову f1 из предыдущего примера

Статические функции члены передаются в boost::function также, как и свободные функции.

Использование с функциональными объектами

Если для какого-то объекта можно применить оператор вызова функции, то он также, как и обычные функции, может быть использован для инициализации boost::function. Пример был приведен в предыдущем разделе, когда boost::function инициализировался функциональным объектом boost::bind.

Поскольку функциональный объект в boost::function хранится по значению, то в случае необходимости передачи ссылки необходимо воспользоваться boost::ref:

SomeFunctionObject foo;
boost::function<void (int)> f1;
f1 = boost::ref(foo);
boost::function<void (int)> f2;
f2(f1);

В этом случае f1 и f2 будут использовать для работы один и тот же функциональный объект.

P.S.: Наглым образом спёрто отсюда: [[doc:cpp:boost:function]]

Использование boost:array

2009-04-01T21:20:00.001+03:00

Данный класс представляет собой STL-совместимый контейнер для массивов с постоянным размером.

Разработан Николаи Джоссатисом (автором таких книг как C++ Standard Library и C++ Templates)

Описание.

Конструктор.

template<typename U>
array& operator=(const array<U, N>& other);

Создаёт экземпляр объекта array

Итераторы.

iterator begin();
const_iterator begin() const;

Представляют соответственно неконстантный и константный итераторы для первого элемента array.

iterator end();
const_iterator end() const;

Представляют соответственно неконстантный и константный итераторы для конечного элемента array.

Обратные итераторы.

iterator rbegin();
const_iterator rbegin() const;

Представляют соответственно обратные неконстантный и константный итераторы для первого элемента array.

iterator rend();
const_iterator rend() const;

Представляют соответственно обратные неконстантный и константный итераторы для конечного элемента array.

Ёмкость.

array size_type size();

Возвращает число элементов array

bool empty();

Если array пустой возвращает true.

size_type max_size();

Возвращает максимальное число элементов.

Доступ к элементам array.

reference operator[](size_type i);
const_reference operator[](size_type i) const;

Возвращает элемент с индексом i.

В случает доступа к элементу с несуществующим индексом исключения не вызывается.

reference at(size_type i);
const_reference at(size_type i) const;

Возвращает элемент с индексом i.

В случает доступа к элементу с несуществующим индексом вызывается исключение std::range_error.

reference front();
const_reference front() const;

Возвращает первый элемент.

reference back();
const_reference back() const;

Возвращает последний элемент.

T* c_array();
const T* data() const;

Возвращает указатель на массив элементов типа T.

Модификаторы array.

void swap(array<T, N>& other);

Обмен элементами между двумя объектами типа array.

void assign(const T& value);

Заполнить array элементами из другого объектаСпециализированные алгоритмы

template<typename T, std::size_t N>
void swap(array<T, N>& x, array<T, N>& y);

Обмен элементами между двумя объектами типа array.

Операторы сравнения для array.

template<typename T, std::size_t N>
bool operator==(const array<T, N>& x, const array<T, N>& y);
template<typename T, std::size_t N>
bool operator!=(const array<T, N>& x, const array<T, N>& y);
template<typename T, std::size_t N>
bool operator<(const array<T, N>& x, const array<T, N>& y);
template<typename T, std::size_t N>
bool operator>(const array<T, N>& x, const array<T, N>& y);
template<typename T, std::size_t N>
bool operator<=(const array<T, N>& x, const array<T, N>& y);
template<typename T, std::size_t N>
bool operator>=(const array<T, N>& x, const array<T, N>& y);

P.S.: Нагло спёрто отсюда: forum.vingrad.ru -> Boost:Array

Использование характеристик типов boost/type_traits.hpp

2009-04-01T21:00:00.001+03:00

Вступление

Содержимое (классы) заголовочного файла <boost/type_traits.hpp> объявляется в пространстве имен boost.

В файле <boost/type_traits.hpp> определены три вида свойств типов:

свойства выбранного типа
отношения между двумя типами
преобразования от одного типа к другому

Если Вы ранее не работали с этой библиотекой, то предлагаем ознакомиться со статьей, где описываются основы и цели создания библиотеки.

Все целочисленные выражения в данной библиотеке являются константами времени компиляции, что иногда может вызвать проблемы с используемым компилятором.

Первичная категоризация типов

Нижеследующие шаблоны свойств типов позволяют определить, к какой категории типов принадлежит заданный тип. Для любого заданного типа только одно выражение получит значение true. Заметьте, что is_integral<T>::value и is_float<T>::value будут true только для встроенных типов; если есть необходимость проверки для пользовательских типов так же, как для встроенных, то следует использовать шаблон std::numeric_limits.

::boost::is_void<T>::value
становится true только если T является cv-qualified void типом.
::boost::is_float<T>::value
становится true только если T является cv-qualified типом с плавающей точкой
::boost::is_integral<T>::valueстановится true только если T является cv-qualified целым типом.
::boost::is_float<T>::valueстановится true только если T является cv-qualified типом с плавающей точкой
::boost::is_pointer<T>::valueстановится true только если T является cv-qualified указателем (включая указатели на функции, но исключая указатели на члены классов).
::boost::is_reference<T>::valueстановится true только если T является ссылкой.
если компилятор не поддерживает частичную специализацию шаблонов классов, тогда этот шаблон может давать неправильные результаты.
::boost::is_member_pointer<T>::valueстановится true только если T является a cv-qualified указателем на член класса (поле класса или метод).
::boost::is_array<T>::valueстановится true только если T является массивом.
если компилятор не поддерживает частичную специализацию шаблонов классов, тогда этот шаблон может давать неправильные результаты.
::boost::is_union<T>::valueстановится true только если T является типом union. В настоящее время требуется некоторая поддержка со стороны компилятора, иначе union'ы рассматриваются как классы.
Без определенной помощи со стороны компилятора (в настоящее время данная возможность не стандартизована), мы не можем отличить union от класса, в результате чего выражение никогда не получается true.
::boost::is_class<T>::valueстановится true только если T является классом или структурой.
Без определенной помощи со стороны компилятора (в настоящее время данная возможность не стандартизована), мы не можем отличать union от классов, в результате чего выражение дает неправильный ответ true для аргумента типа union.
::boost::is_enum<T>::valueстановится true только если T является перечислением (enum).
требуется правильно работающий шаблон is_convertible (это означает, что шаблон is_enum в настоящее время не работает в Borland C++ Builder 5, и в некоторых версиях компилятора Metrowerks).
::boost::is_function<T>::valueстановится true только если T является функциональным типом (но не ссылкой и не указателем на функцию).
если компилятор не поддерживает частичную специализацию шаблонов классов, тогда этот шаблон не компилируется для ссылочных типов.

Свойства типов

Нижеописанные шаблоны идентифицируют свойства, которые имеет заданный тип.

::boost::alignment_of<T>::value
идентифицирует величину выравнивания для T. в действительности возвращает величину, которая гарантированно является множителем действительной величины выравнивания. T должен быть полностью определен (complete type)
::boost::is_empty<T>::value
true если T является пустой структурой или классом. Если компилятор поддерживает метод оптимизации "пустые базовые классы нулевого размера", тогда шаблон is_empty может правильно определить, что T пустой. Используется шаблон is_class для определения, когда T является классом.
T должен быть полностью определен (complete type)
Компилятор должен поддерживать реализацию пустых базовых классов нулевого размера, чтобы обнаружение пустых классов работало.
Не может быть использован с неопределенными полностью типами.
Не может работать с union'ами до тех пор, пока шаблон is_union сможет работать (см. его описание).
Если компилятор не поддерживает частичную специализацию шаблонов классов, тогда этот шаблон не может быть использован с абстрактными типами.
::boost::is_const<T>::value
true только если T квалифицирован как const (top-level const-qualified).
::boost::is_volatile<T>::value
true только если T квалифицирован как volatile.
::boost::is_polymorphic<T>::value
true только если T является полиморфным типом.
T должен быть полностью определен (complete type)
Требуется знание ABI компилятора, в действительности шаблон работоспособен на большинстве существующих компиляторов.
::boost::is_pod<T>::value
true только если T является cv-qualified POD, то есть простой структурой без методов, с возможными квалификаторами const и volatile.
T должен быть полностью определен (complete type).
Без некоторой помощи (в настоящее время эти возможности не стандартизованы) со стороны компилятора, шаблон is_pod не может определить, что T является POD; это безопасно, хотя может быть не оптимальным.
Если компилятор не поддерживает частичную специализацию шаблонов классов, то данный шаблон не может быть использован с функциональными типами.
::boost::has_trivial_constructor<T>::value
true если T имеет простой деструктор, сгенерированный компилятором (trivial default constructor).
Без некоторой помощи (в настоящее время эти возможности не стандартизованы) со стороны компилятора, шаблон has_trivial_constructor не сможет определить, что заданный тип имеет пустой конструктор. Это всегда безопасно, хотя может быть неоптимальным.
Если компилятор не поддерживает частичную специализацию шаблонов классов, то данный шаблон не может быть использован с функциональными типами.
::boost::has_trivial_copy<T>::value
true если T имеет простой сгенерированный компилятором конструктор копирования ( trivial copy constructor).
T должен быть полностью определен (complete type).
Без некоторой помощи (в настоящее время эти возможности не стандартизованы) со стороны компилятора, шаблон has_trivial_copy не сможет определить, что заданный тип имеет пустой конструктор копирования. Это всегда безопасно, хотя может быть неоптимальным.
Если компилятор не поддерживает частичную специализацию шаблонов классов, то данный шаблон не может быть использован с функциональными типами.
::boost::has_trivial_assign<T>::value
true если T имеет простой сгенерированный компилятором оператор присваивания (trivial assignment operator).
T должен быть полностью определен (complete type).
Без некоторой помощи (в настоящее время эти возможности не стандартизованы) со стороны компилятора, шаблон has_trivial_assign не сможет определить, что заданный тип имеет пустой оператор присваивания. Это всегда безопасно, хотя может быть неоптимальным.
Если компилятор не поддерживает частичную специализацию шаблонов классов, то данный шаблон не может быть использован с функциональными типами.
::boost::has_trivial_destructor<T>::value
true если T имеет простой, сгенерированный деструктор (trivial destructor).
T должен быть полностью определен (complete type).
Без некоторой помощи (в настоящее время эти возможности не стандартизованы) со стороны компилятора, шаблон has_trivial_destructor не сможет определить, что заданный тип имеет пустой оператор присваивания. Это всегда безопасно, хотя может быть неоптимальным.
Если компилятор не поддерживает частичную специализацию шаблонов классовв, то данный шаблон не может быть использован с функциональными типами.
::boost::is_stateless<T>::value
true если T не имеет состояния, то есть T не выделяет память и его конструкторы и деструктор сгенерированы компилятором.
T должен быть полностью определен (complete type).
Без некоторой помощи (в настоящее время эти возможности не стандартизованы) со стороны компилятора, шаблон is_stateless не сможет определить, что заданный тип не имеет состояния. Это всегда безопасно, хотя может быть неоптимальным.
Выражение становится true только если становятся true все нижеуказанные:
::boost::has_trivial_constructor<T>::value,
::boost::has_trivial_copy<T>::value,
::boost::has_trivial_destructor<T>::value,
::boost::is_class<T>::value,
::boost::is_empty<T>::value
Если компилятор не поддерживает частичную специализацию шаблонов классов, то данный шаблон не может быть использован с функциональными типами.
::boost::has_nothrow_constructor<T>::value
true если T имеет конструктор по умолчанию, не генерирующий исключения.
T должен быть полностью определен (complete type).
Без некоторой помощи (в настоящее время эти возможности не стандартизованы) со стороны компилятора, шаблон has_nothrow_constructor не сможет определить, что заданный тип имеет конструктор, не генерирующий исключения. Это всегда безопасно, хотя может быть неоптимальным.
Если компилятор не поддерживает частичную специализацию шаблонов классов, то данный шаблон не может быть использован с функциональными типами.
::boost::has_nothrow_copy<T>::value
true если T имеет конструктор копирования, не генерирущий исключений.
T должен быть полностью определен (complete type).
Без некоторой помощи (в настоящее время эти возможности не стандартизованы) со стороны компилятора, шаблон has_nothrow_copy не сможет определить, что заданный тип имеет конструктор копирования, не генерирующий исключения. Это всегда безопасно, хотя может быть неоптимальным.
Если компилятор не поддерживает частичную специализацию шаблонов классов, то данный шаблон не может быть использован с функциональными типами.
::boost::has_nothrow_assign<T>::value
true если T имеет оператор присваивания, не генерирующий исключений.
T должен быть полностью определен (complete type).
Без некоторой помощи (в настоящее время эти возможности не стандартизованы) со стороны компилятора, шаблон has_nothrow_assign не сможет определить, что заданный тип имеет оператор присваивания, не генерирующий исключения. Это всегда безопасно, хотя может быть неоптимальным.
Если компилятор не поддерживает частичную специализацию шаблонов классов, то данный шаблон не может быть использован с функциональными типами.

Отношения между типами

Следующая таблица содержит шаблоны, с помощью которых можно выяснить, есть ли какая-либо зависимость между двумя типами:

::boost::is_same<T,U>::valueстановится true, если T и U - один и тот же тип.
Если компилятор не поддерживает частичную специализацию шаблонов классов, тогда этот шаблон не может быть использован с абстрактными, неполностью определенными или функциональными типами.
::boost::is_convertible<T,U>::value
становится true, если воображаемый объект типа T может быт преобразован в тип U.
Тип T не должен быть неполностью определенным типом.
Тип U не должен быть неполностью определенным, либо абстрактным типом, либо функциональным типом.
Подразумевается, что никакой тип не может быть преобразован в массив.
Обратите внимание, что данный шаблон работает неправильно с Borland C++ Builder 5 (и более ранними версиями) для преобразований через конструкторы, для с компилятором Metrowerks 7 (и более ранними версиями) во всех случаях.
::boost::is_base_and_derived<T,U>::value
становится true, если T является базовым классом для типа U.
Будут обнаружены не-публичные базовые классы, и неоднозначные базовые классы.
Обратите внимание, что любой класс не рассматривается как собственный базовый класс. Аналогично, если T или U не являются классами, тогда результат будет в любом случае false.
Типы T и U не должны быть неполностью описанными.
Если компилятор не поддерживает частичную специализацию шаблонов классов, тогда этот шаблон не может быть использован с функциональными типами.

Обратите внимание, что как is_convertible, так и is_base_and_derived могут привести к ошибке компиляции, если преобразование неоднозначно.:

struct A {};
struct B : A {};
struct C : A {};
struct D : B, C {};
bool const x = boost::is_base_and_derived<A,D>::value;  // ошибка
bool const y = boost::is_convertible<D*,A*>::value;     // ошибка

Преобразования между типами

Следующие шаблоны преобразовывают один тип в другой, основываясь на простом правиле: каждый шаблон имеет единственный член type, который является результатом применения преобразования к аргументу шаблона T:

::boost::remove_const<T>::type
Создает тип такой же как T, но убирает квалификатор const самого верхнего уровня. К примеру, "const int" становится"int", но "const int*" остается неизменным.
Если компилятор не поддерживает частичную специализацию шаблонов классов, тогда этот шаблон компилируется, но не работает, за исключением случаев, указанных в примечании ниже.
::boost::remove_volatile<T>::type
Создает тип такой же как T, но убирает квалификатор volatile самого верхнего уровня. К примеру, "volatile int" становится "int".
Если компилятор не поддерживает частичную специализацию шаблонов классов, тогда этот шаблон компилируется, но не работает, за исключением случаев, указанных в примечании ниже.
::boost::remove_cv<T>::type
Создает тип такой же как T, но убирает квалификаторы const и volatile самого верхнего уровня. К примеру "const volatile int" становится "int".
Если компилятор не поддерживает частичную специализацию шаблонов классов, тогда этот шаблон компилируется, но не работает, за исключением случаев, указанных в примечании ниже.
::boost::remove_reference<T>::type
Если T является ссылкой, тогда удаляет ссылку, иначе тип T остается неизменным. К примеру, "int&" становится "int", но "int*" не изменится.
Если компилятор не поддерживает частичную специализацию шаблонов классов, тогда этот шаблон компилируется, но не работает, за исключением случаев, указанных в примечании ниже.
::boost::remove_bounds<T>::type
Если T является типом массива, тогда удаляет квалификатор верхнего уровня массива, в противном случае T не изменяется. К примеру, "int[2][3]" становится "int[3]".
если компилятор не поддерживает частичную специализацию шаблонов классов, тогда этот шаблон компилируется, но не работает.
::boost::remove_pointer<T>::type
Если T является указателем, тогда удаляет указатель верхнего уровня (top-level indirection) у T, иначе T остается неизменным. К примеру, "int*" становится "int", но "int&" не меняется.
Если компилятор не поддерживает частичную специализацию шаблонов классов, тогда этот шаблон компилируется, но не работает, за исключением случаев, указанных в примечании ниже.
::boost::add_reference::type
Если T является ссылкой, тогда тип T не меняется, иначе преобразует T в ссылку. К примеру, "int&" не меняется, а "double" становится "double&".
::boost::add_pointer<T>::type
Результатом работы является тип, который получается как remove_reference<T>::type*. К примеру, "int" и "int&" становятся "int*".
Если компилятор не поддерживает частичную специализацию шаблонов классов, тогда этот шаблон на компилируется с ссылочными типами.
::boost::add_const<T>::type
То же, что "T const" для всех T.
::boost::add_volatile<T>::type
То же, что "T volatile" для всех T.
::boost::add_cv<T>::type
То же, что "T const volatile" для всех T.

Как видно по данной таблице, поддержка частичной специализации шаблонов классов необходима для правильной реализации шаблоном преобразования типов. С другой стороны, практика показывает, что многие шаблоны из данной категории очень полезны, и зачастую жизненно необходимы для реализации некоторых обобщенных библиотек (generic libraries). Отсутствие этих шаблонов часто является одним из главных ограничивающих факторов в портировании таких библиотек для компиляторов, которые все еще не поддерживают необходимые возможности языка C++. Поскольку некоторые из этих компиляторов будут использоваться еще какое-то время, а по крайней мере один из них широко распространен, было решено, что библиотека должна содержать решение проблемы, когда это возможно. Основной способ решения такой:

Вручную создать полные специализации шаблонов для всех типов преобразований для всех фундаментальных типов, а также всех их указателей (* и **) с/без квалификаторами const и volatile
Создать пользовательские макросы, которые будут определять такие явные специализации для любого пользовательского типа T.

Первый пункт гарантирует успешную компиляцию такого фрагмента:

BOOST_STATIC_ASSERT((is_same<char, remove_reference<char&>::type>::value));
BOOST_STATIC_ASSERT((is_same<char const, remove_reference<char const&>::type>::value));
BOOST_STATIC_ASSERT((is_same<char volatile, remove_reference<char volatile&>::type>::value));
BOOST_STATIC_ASSERT((is_same<char const volatile, remove_reference<char const volatile&>::type>::value));
BOOST_STATIC_ASSERT((is_same<char*, remove_reference<char*&>::type>::value));
BOOST_STATIC_ASSERT((is_same<char const*, remove_reference<char const*&>::type>::value));
....
BOOST_STATIC_ASSERT((is_same<char const volatile* const volatile* const volatile, remove_reference<char const volatile* const volatile* const volatile&>::type>::value));

и второй пункт обеспечивает для пользователей библиотеки механизм, с помощью которого вышеприведенный код будет работать не только для типов 'char', 'int' или других встроенных типов, но для любых пользовательских типов:

struct my {};
BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(my)
BOOST_STATIC_ASSERT((is_same<my, remove_reference<my&>::type>::value));
BOOST_STATIC_ASSERT((is_same<my, remove_const<my const>::type>::value));
// etc.

Заметьте, что макрос BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION становится пустым для компиляторов, которые не поддерживают частичную специализацию.

Синтезирование типов

Следующие шаблоны синтезируют типы с желаемыми свойствами.

::boost::type_with_alignment<Align>::type

Свойства функций

Шаблон класса ::boost::function_traits извлекает информацию о функциональном типе.

::boost::function_traits<F>::arity
определяет арность функционального типа F.
Без поддержки частичной специализации данный шаблон не компилируется для ссылочных типов.
::boost::function_traits<F>::result_type
тип, возвращаемый функциональным типом F.
Не компилируется без поддержки частичной специализации шаблонов классов.
::boost::function_traits<F>::argN_type
тип Nго аргумента функции F, где 1<=N<=арность(F).
Не компилируется без поддержки частичной специализации шаблонов классов.

Заголовочные файлы свойств типов

Библиотека свойств типов нормально подключается заголовочным файлом:

#include <boost/type_traits.hpp>

Однако в действительности библиотека разбита на ряд небольших файлов, так что иногда может быть удобнее включать один из этих файлов напрямую, чтобы получить только те шаблоны, которые нужны. Отдельные хидеры всегда имеют то же имя, что и соответствующий шаблон, и хранятся в каталоге boost/type_traits/. Так что если, к примеру, некоторый код нуждается в шаблоне is_class<>, тогда просто включайте:

<boost/type_traits/is_class.hpp>

Пользовательские специализации

В ряде случаев конечный пользователь может нуждаться в собственных специализациях для какого-либо из шаблонов свойств типов - обычно когда используемый компилятор требует, чтобы соответствующее свойство типа было реализовано полностью. Эти специализации должны наследовать от boost::mpl::true_ или boost::mpl::false_ соответственно:

#  include <boost/type_traits/is_pod.hpp>
#  include <boost/type_traits/is_class.hpp>
#  include <boost/type_traits/is_union.hpp>

struct my_pod{};
struct my_union
{
char c;
int i;
};

namespace boost
{
template<>
struct is_pod<my_pod> 
: public mpl::true_{};
template<>
struct is_pod<my_union> 
: public mpl::true_{};
template<>
struct is_union<my_union> 
: public mpl::true_{};
template<>
struct is_class<my_union> 
: public mpl::false_{};
}

Примеры

Есть четыре примера работы с шаблонами свойств типов:

Copy_example.cpp

Демонстрируется версия std::copy, которая использует функцию memcpy, когда это возможно, для выполнения копирования (то есть если тип - один из фундаментальных, либо POD, и т.д.);

//
// opt::copy
// same semantics as std::copy
// calls memcpy where appropiate.
//

namespace detail{

template<typename I1, typename I2>
I2 copy_imp(I1 first, I1 last, I2 out)
{
while(first != last)
{
*out = *first;
++out;
++first;
}
return out;
}

template <bool b>
struct copier
{
template<typename I1, typename I2>
static I2 do_copy(I1 first, I1 last, I2 out)
{ return copy_imp(first, last, out); }
};

template <>
struct copier<true>
{
template<typename I1, typename I2>
static I2* do_copy(I1* first, I1* last, I2* out)
{
memcpy(out, first, (last-first)*sizeof(I2));
return out+(last-first);
}
};


}

template<typename I1, typename I2>
inline I2 copy(I1 first, I1 last, I2 out)
{
typedef typename boost::remove_cv<typename std::iterator_traits<I1>::value_type>::type v1_t;
typedef typename boost::remove_cv<typename std::iterator_traits<I2>::value_type>::type v2_t;
return detail::copier<
::boost::type_traits::ice_and<
::boost::is_same<v1_t, v2_t>::value,
::boost::is_pointer<I1>::value,
::boost::is_pointer<I2>::value,
::boost::has_trivial_assign<v1_t>::value
>::value>::do_copy(first, last, out);
}

fill_example.cpp

Демонстрируется версия std::fill, которая использует функцию memset, когда это возможно, для оптимизации операции заполнения. Также используется шаблон call_traits для оптимизации передачи параметров, чтобы избежать проблем с синонимами (aliasing issues):

namespace opt{
///
// fill
// same as std::fill, uses memset where appropriate, along with call_traits
// to "optimise" parameter passing.
//
namespace detail{

template <typename I, typename T>
void do_fill_(I first, I last, typename boost::call_traits<T>::param_type val)
{
while(first != last)
{
*first = val;
++first;
}
}

template <bool opt>
struct filler
{
template <typename I, typename T>
struct rebind
{
static void do_fill(I first, I last, typename boost::call_traits<T>::param_type val)
{ do_fill_<I,T>(first, last, val); }
};
};

template <>
struct filler<true>
{
template <typename I, typename T>
struct rebind
{
static void do_fill(I first, I last, T val)
{
std::memset(first, val, last-first);
}
};
};

}

template <class I, class T>
inline void fill(I first, I last, const T& val)
{
typedef detail::filler<
::boost::type_traits::ice_and<
::boost::is_pointer<I>::value,
::boost::is_arithmetic<T>::value,
(sizeof(T) == 1)
>::value> filler_t;
typedef typename filler_t:: template rebind<I,T> binder;
binder::do_fill(first, last, val);
}
}};   // namespace opt

iter_swap_example.cpp

Демонстрируется версия алгоритма std::iter_swap, который работает с прокси-итераторами (proxying iterators), а также с обычными итераторами; вызывает std::swap для обычных итераторов, иначе выполняет медленный, но надежный обмен:

namespace opt{
///
// iter_swap:
// tests whether iterator is a proxying iterator or not, and
// uses optimal form accordingly:
//
namespace detail{

template <bool b>
struct swapper
{
template <typename I>
static void do_swap(I one, I two)
{
typedef typename std::iterator_traits<I>::value_type v_t;
v_t v = *one;
*one = *two;
*two = v;
}
};

template <>
struct swapper<true>
{
template <typename I>
static void do_swap(I one, I two)
{
using std::swap;
swap(*one, *two);
}
};

}

template <typename I1, typename I2>
inline void iter_swap(I1 one, I2 two)
{
typedef typename std::iterator_traits<I1>::reference r1_t;
typedef typename std::iterator_traits<I2>::reference r2_t;
detail::swapper<
::boost::type_traits::ice_and<
::boost::is_reference<r1_t>::value, 
::boost::is_reference<r2_t>::value,
::boost::is_same<r1_t, r2_t>::value
>::value>::do_swap(one, two);
}

};   // namespace opt

Trivial_destructor_example.cpp

Этот алгоритм выполняет обратную по отношению к std::unitialized_copy работу; он получает указатель на блок инициализированной памяти и вызывает деструкторы для каждого из объектов в нем. Это может быть использовано при реализации контейнерных классов, которые самостоятельно управляют своей памятью:

namespace opt{
//
// algorithm destroy_array:
// The reverse of std::unitialized_copy, takes a block of
// initialized memory and calls destructors on all objects therein.
//

namespace detail{

template <bool>
struct array_destroyer
{
template <class T>
static void destroy_array(T* i, T* j){ do_destroy_array(i, j); }
};

template <>
struct array_destroyer<true>
{
template <class T>
static void destroy_array(T*, T*){}
};

template <class T>
void do_destroy_array(T* first, T* last)
{
while(first != last)
{
first->~T();
++first;
}
}

}; // namespace detail

template <class T>
inline void destroy_array(T* p1, T* p2)
{
detail::array_destroyer<boost::has_trivial_destructor<T>::value>::destroy_array(p1, p2);
}
} // namespace opt

P.S.: Нагло утянуто отсюда: Библиотека BOOST C++: заголовочный файл <boost/type_traits.hpp>

Использование boost::static_assert

2009-04-01T20:40:00.001+03:00

Заголовочный файл <boost/static_assert.hpp> содержит определение макроса BOOST_STATIC_ASSERT(x), который генерирует сообщение об ошибке компиляции, если целочисленное константное выражение x не равно true. Другими словами, это эквивалент макросу assert на стадии компиляции; иногда эти средства называют "проверки во время компиляции", но здесь будут называться "статические проверки (static assertion)". Заметьте, что если условие равно true, то макрос не генерирует ни кода, ни данных, а также то, что этот макрос может быть использован в области видимости имен (scope) пространства имен, класса или функции. будучи использован в шаблоне, статическая проверка (static assertion) подставляется во время конкретизации шаблона (instantiation); это полезно для проверки параметров шаблона (см. - свойства типов).

Одной из целей создания BOOST_STATIC_ASSERT была генерация читабельных сообщений об ошибках. Эти сообщения непосредственно сообщают пользователю, что библиотека используется способом, который не поддерживается. Сообщения об ошибке варьируются для разных компиляторов, но Вы должны увидеть нечто вроде:

Illegal use of COMPILE_TIME_ASSERTION_FAILURE<false>

Это, по меньшей мере, должно привлечь внимание!

Вы можете использовать макрос BOOST_STATIC_ASSERT в любом месте кода, где синтаксически допустимо поместить объявление, то есть в области видимости класса, функции или пространства имен. Эти варианту иллюстрируются следующими примерами:

Использование в области видимости пространства имен.

Макрос может быть использован в области видимости (scope) пространства имен (namespace), когда некое требование должно быть удовлетворено; обычно это означает некоторые специфичные для конкретной платформы требования. Допустим, нам необходимо удостовериться, что тип int имеет по крайней мере 32 бита, и что wchar_t является беззнаковым типом. Мы можем проверить это во время компиляции таки образом:

#include <climits>
#include <cwchar>
#include <boost/static_assert.hpp>

namespace my_conditions {

BOOST_STATIC_ASSERT(sizeof(int) * CHAR_BIT >= 32);
BOOST_STATIC_ASSERT(WCHAR_MIN >= 0);

} // namespace my_conditions

Такое использование пространства мен my_conditions требует некоторых пояснений. Макрос BOOST_STATIC_ASSERT работает через объявление типа оператором typedef, а так как typedef должен получить имя создаваемого синонима типа, то макрос создает это имя автоматически путем комбинирования имени-заглушки (stub name) с макросом __LINE__. Когда макрос BOOST_STATIC_ASSERT используется в области видимости класса или функции, то каждое использование BOOST_STATIC_ASSERT гарантированно дает уникальное для данной области видимости имя (при условии, что макрос используется единожды в каждой строке). Однако, при использовании макроса в хидере в области видимости пространства имен, надо учесть, что пространство имен может быть разбросано на множестве хидеров, каждый из которых может содержать собственные статические проверки (static assertions), причем на одинаковых строках, что приведет к дублированию объявлений. В теории компилятор должен молча игнорировать дубликаты для синонимов типов в typedef, однако не все следуют этому правилу (и даже если следуют, то иногда генерируют предупреждения в таких случаях). Чтобы избежать потенциальных проблем, в хитере в области видимости пространства имен следует использовать макрос BOOST_STATIC_ASSERT внутри уникального для данного хидера пространства имен.

Использование в области видимости функции

Макрос обычно используется в области видимости внутри шаблонной функции, когда необходимо проверять аргументы. Представьте, что у нас есть алгоритм, использующий итераторы, который требует итераторы с произвольным доступом (random access iterators). Если данный алгоритм будет конкретизирован (instantiated) с итератором, который не удовлетворяет такому условию, то ошибка рано или поздно возникнет, но она возможно появится в глубине нескольких подставляемых шаблонов, что делает затруднительным для пользователя определить причину ошибки. Один из методов решения - добавить статическую проверку на верхний уровень шаблона, так что если условие не соблюдается, то ошибка генерируется способом, которые делает очевидным для пользователя причину - неверное использование шаблона.

#include <iterator>
#include <boost/static_assert.hpp>
#include <boost/type_traits.hpp>

template <class RandomAccessIterator >
RandomAccessIterator foo(RandomAccessIterator from, RandomAccessIterator to)
{
   // this template can only be used with
   // random access iterators...
   typedef typename std::iterator_traits< RandomAccessIterator >::iterator_category cat;
   BOOST_STATIC_ASSERT((boost::is_convertible<cat, const std::random_access_iterator_tag&>::value));
   //
   // detail goes here...
   return from;
}

Вот парочка сносок по поводу приведенного примера. Во-первых, дополнительный набор круголых скобочек в макросе проверки необходим, чтобы не допустить интерпретации запятой внутри шаблона is_convertible как разделителя аргументов макроса. Во-вторых, целевой тип для шаблона is_convertible является ссылочным типом, так как некоторые компиляторы имеют проблемы при использовании шаблона is_convertible, когда преобразование выполняется через определенный пользователем конструктор; в любом случае не существует гарантий, что классы свойств итераторов (iterator tag classes) могут конструироваться копированием (copy-constructible).

Использование в области видимости класса

макрос обычно используется внутри шаблонных классов. Предположим, что у нас есть шаблонный класс, для которого необходим беззнаковый целый тип с по крайней мере 16 битам в качестве параметра шаблона. Мы можем проверять такое условие таким, к примеру, образом:

##include <climits>
#include <boost/static_assert.hpp>

template <class UnsignedInt>
class myclass
{
private:
   BOOST_STATIC_ASSERT(sizeof(UnsignedInt) * CHAR_BIT >= 16);
   BOOST_STATIC_ASSERT(std::numeric_limits<UnsignedInt>::is_specialized
                        && std::numeric_limits<UnsignedInt>::is_integer
                        && !std::numeric_limits<UnsignedInt>::is_signed);
public:
   /* details here */
};

Как это работает

BOOST_STATIC_ASSERT работает так. Есть класс STATIC_ASSERTION_FAILURE, определенный так:

namespace boost{

template <bool> struct STATIC_ASSERTION_FAILURE;

template <> struct STATIC_ASSERTION_FAILURE<true>{};

}

Ключевой деталью является то, что сообщение об ошибке включается посредством неопределенного выражения sizeof(STATIC_ASSERTION_FAILURE<0>), которое вроде бы правильно отрабатывает на большом множестве компиляторов. Оставшаяся машинерия макроса BOOST_STATIC_ASSERT это просто передача выражения sizeof в оператор typedef. В данном случае использование макроса является немного неуклюжим, однако разработчики библиотека BOOST потратили значительные усилия в попытках изобрести реализацию статических проверок без макросов, и все безуспешно. В итоге было решено, что выгода от правильной работы статической проверки в области видимости пространства имен, функции и класса перевешивает неуклюжесть макроса.

Тестовые программы

Следующие тестовые программы доступны в библиотеке:

Тестовая программа	Компилируется ли	Описание
static_assert_test.cpp	Да	Иллюстрирует использование. Должна всегда успешно компилироваться, в действительности проверяет совместимость компилятора.
static_assert_example_1.cpp	Зависит от платформы.	Тестовая программа для использования в области видимости пространства имен. Может успешно компилироваться на некоторых платформах.
static_assert_example_2.cpp	Да	Тестовая программа для области видимости функции.
static_assert_example_3.cpp	Да	Тестовая программа для области видимости класса.
static_assert_test_fail_1.cpp	Нет	Пример генерации ошибки в области видимости пространства имен.
static_assert_test_fail_2.cpp	Нет	Пример генерации ошибки в области видимости не-шаблонной функции.
static_assert_test_fail_3.cpp	Нет	Пример генерации ошибки в области видимости не-шаблонного класса.
static_assert_test_fail_4.cpp	Нет	Пример генерации ошибки в области видимости не-шаблонного класса.
static_assert_test_fail_5.cpp	Нет	Пример генерации ошибки в области видимости шаблонного класса.
static_assert_test_fail_6.cpp	Нет	Пример генерации ошибки в области видимости метода шаблонного класса.
static_assert_test_fail_7.cpp	Нет	Пример генерации ошибки в области видимости класса.
static_assert_test_fail_8.cpp	Нет	Пример генерации ошибки в области видимости функции.
static_assert_test_fail_9.cpp	Нет	Пример генерации ошибки в области видимости функции (часть 2).

P.S.: Нагло спёрто отсюда: BOOST C++: проверки на стадии компиляции (static assertions)

Использование boos::call_traits

2009-04-01T20:20:00.001+03:00

Все содержимое <boost/call_traits.hpp> объявлено в пространстве имен boost.

Шаблонный класс call_traits<T> инкапсулирует "наилучший" метод передачи параметра определенного типа T в или из функции, и состоит из собрания операторов typedef, определенных как показано в нижеследующей таблице. Предназначение call_traits заключается в создании гарантий, что проблемы типа "ссылка на ссылку" не возникнут, и что параметры передаются наиболее эффективным допустимым способом (см. примеры).

Заметьте, что для компиляторов, которые не поддерживают частичную специализацию или шаблоны-члены, использование шаблона call_traits не принесет никаких выгод. Дополнительно к этому, если компилятор поддерживает шаблоны-члены и не поддерживает частичную специализацию (Visual C++ 6), тогда call_traits не может быть использован с типами массивов (хотя он может быть использован для решения проблемы ссылка на ссылку).

существующая практика	эквивалент с call_traits	описание	замечания
T (возвращается сама величина)	`call_traits<T>::value_type`	Определяет тип, который представляет "значение" типа T. Используйте для функций, которые возвращают значение, а также для хранения величин типа T.	2
T& (возврат по значению)	`call_traits<T>::reference`	Определяет тип, представляющий ссылку на тип T. Используйте для функций, которые должны возвращать T&.	1
const T& (возврат по значению)	`call_traits<T>::const_reference`	Определяет тип, представляющий константную ссылку на тип T. Используйте для функций, которые должны возвращать const T&.	1
const T& (параметр функции)	`call_traits<T>::param_type`	Определяет тип, который представляет "наилучший" способ передавать параметр типа T в функцию.	1,333

Внимание:

Если T уже является типом ссылки, тогда call_traits определяется таким способом, что проблема ссылка на ссылку не возникает (требуется поддержка компилятором частичной специализации).

Если T является типом массива, тогда call_traits определяет value_type как "константный указатель на тип" вместо "массива типов" (требуется частичная специализация). Обратите внимание, что если Вы используете value_type для хранения значения, то это приведет к хранению "константного указателя на массив" вместо хранения самого массива. Это может быть хорошим или плохим решением в зависимости от конкретной ситуации.

Если T это небольшой по размеру встроенный тип или указатель, тогда param_type определяется как T const, вместо T const&. Это может улучшить шансы компилятора на оптимизацию циклов в теле функции, если они зависят от передаваемого параметра. В остальных случаях сематника передаваемого параметра остается неизменной. Для реализации этой возможности необходима частичная специализация.

Возможность создания копированием

Следующая таблица определяет, какие типы в шаблоне call_traits всегда могут создаваться копированием из других типов. Случаи, отмеченные '?', справедливы только если T можно конструировать копированием:

	В:
Из:	T	value_type	reference	const_reference	param_type
T	?	?	Y	Y	Y
value_type	?	?	N	N	Y
reference	?	?	Y	Y	Y
const_reference	?	N	N	Y	Y
param_type	?	?	N	N	Y

Если T тип с работающим присваиванием, то следующие виды присваивания возможны:

	В:
Из:	T	value_type	reference	const_reference	param_type
T	Y	Y	-	-	-
value_type	Y	Y	--	-	-
reference	Y	Y	-	-	-
const_reference	Y	Y	--	-	-
param_type	Y	Y	--	-	-

Примеры

Следующая таблица показывает эффект, который получается применением call_traits к различным типам. Подразумевается, что компилятор поддерживает частичную специализацию: если это не так, то все типы ведут себя так же, как в графе для "myclass", и call_traits не может быть использован со ссылками или типами массивов.

	тип-результат call_traits:
исходный тип T	value_type	reference	const_reference	param_type	может применяться для:
myclass	myclass	myclass&	const myclass&	myclass const&	всех определенных пользователем типов.
int	int	int&	const int&	int const	всех небольших встроенных типов.
int*	int*	int*&	int*const&	int* const	любых указателей.
int&	int&	int&	const int&	int&	любых ссылок.
const int&	const int&	const int&	const int&	const int&	всех константных ссылок.
int[3]	const int*	int(&)[3]	const int(&)[3]	const int* const	всех типов маккисов.
const int[3]	const int*	const int(&)[3]	const int(&)[3]	const int* const	всех константных массивов.

Пример 1:

Следующий класс является простейшим случаем, он хранит величину типа T (см. файл call_traits_test.cpp). Демонстрируется, как можно использовать все возможные типы в call_traits:

template <class T>
struct contained
{
   // define our typedefs first, arrays are stored by value
   // so value_type is not the same as result_type:
   typedef typename boost::call_traits<T>::param_type       param_type;
   typedef typename boost::call_traits<T>::reference        reference;
   typedef typename boost::call_traits<T>::const_reference  const_reference;
   typedef T                                                value_type;
   typedef typename boost::call_traits<T>::value_type       result_type;

   // stored value:
   value_type v_;
   
   // constructors:
   contained() {}
   contained(param_type p) : v_(p){}
   // return byval:
   result_type value() { return v_; }
   // return by_ref:
   reference get() { return v_; }
   const_reference const_get()const { return v_; }
   // pass value:
   void call(param_type p){}

};

Пример 2 (проблема ссылки на ссылку):

Рассмотрим определение std::binder1st:

template <class Operation> 
class binder1st : 
   public unary_function<typename Operation::second_argument_type, typename Operation::result_type> 
{ 
protected: 
   Operation op; 
   typename Operation::first_argument_type value; 
public: 
   binder1st(const Operation& x, const typename Operation::first_argument_type& y); 
   typename Operation::result_type operator()(const typename Operation::second_argument_type& x) const; 
};

Теперь посмотрим, что будет в относительно общем случае, когда функтор получает свой второй аргумент как ссылку, что подразумевает, что Operation::second_argument_type является типом ссылки, operator() теперь определяется как получающий ссылку на ссылку, что некорректно для текущего стандарта C++. Решение заключается в том, чтобы модифицировать определение operator() с использованием call_traits:

typename Operation::result_type operator()(typename call_traits<typename Operation::second_argument_type>::param_type x) const;

Теперь в случае, если Operation::second_argument_type является типом ссылки, аргумент передается как ссылка, и проблема "ссылка на ссылку" не возникает.

Пример 3 (проблема с make_pair):

Если мы передает имя массива как один (или оба) аргумента в std::make_pair, тогда алгоритм вывода аргументов шаблона воспринимает преданный параметр как "константная ссылка на массив типов T", это также применимо к строковым литералам (которые на самом деле также являются массивами). Следовательно вместо возврата пары указателей, происходит возврат пары массивов, а так как тип массивов не может создаваться копированием, то код не компилируется. Одним решением может быть явное преобразование аргументов make_pair к указателям, но call_traits дает лучшее (т.е. автоматическое) решение (которое безопасно в обобщенном коде, где преобразования могут привести к неверному результату):

template <class T1, class T2>
std::pair<
   typename boost::call_traits<T1>::value_type, 
   typename boost::call_traits<T2>::value_type> 
      make_pair(const T1& t1, const T2& t2)
{
   return std::pair<

      typename boost::call_traits<T1>::value_type, 
      typename boost::call_traits<T2>::value_type>(t1, t2);
}

Здесь полученные при выводе типы аргументов будут автоматически усечены до указателей, если выведенные типы являются массивами. Аналогичная ситуация возникает со стандартными байндерами и адаптерами (binders and adapters): в принципе, это справедливо для любой функции, которая "обертывает" временный объект, чей тип выводится. Обратите внимание, аргументы функции для make_pair не выражаются в терминах call_traits: это могло бы привести к невозможности вывести аргументы шаблона.

Пример 4 (оптимизация алгоритма fill):

Шаблон call_traits может "оптимизировать" передачу небольших встроенных встроенных типов как аргументов функции. В следующем примере (см. fill_example.cpp), версия std::fill оптимизируется двумя способами: если передаваемый тип является встроенным однобайтовым типом, то используется std::memset, иначе используется обычная реализация алгоритма копирования, но с применением "оптимизации" передачи параметров через call_traits:

namespace detail{

template <bool opt>
struct filler
{{
   template <typename I, typename T>

   static void do_fill(I first, I last, typename boost::call_traits<T>::param_type val);
   {
      while(first != last)
      {
         *first = val;
         ++first;
      }
   }
};

template <>
struct filler<true>
{
   template <typename I, typename T>
   static void do_fill(I first, I last, T val)
   {
      memset(first, val, last-first);
   }
};

}

template <class I, class T>
inline void fill(I first, I last, const T& val)
{
   enum{ can_opt = boost::is_pointer<I>::value
                   && boost::is_arithmetic<T>::value
                   && (sizeof(T) == 1) };
   typedef detail::filler<can_opt> filler_t;
   filler_t::template do_fill<I,T>(first, last, val);}}

Примечение: причина того, что "оптимальным" небольших встроенных типов является передача как T const вместо const T& заключается в том, что компилятор может определить, что величина неизменна и для нее нет синонимов (aliases). С такой информацией компилятор способен закэшировать передаваемое значение в регистре, развернуть (unroll) цикл, или использовать параллельные инструкции. Точнее говоря, эффект от применения такой оптимизации зависит от компилятора.

Обратите внимание, аргументы функции для make_pair не выражаются в терминах call_traits: это могло бы привести к невозможности вывести аргументы шаблона. Вместо этого fill работает как "тонкая обертка", предназначенная для выполнения вывода аргументов шаблона. В любом случае компилятор соптимизирует вызов fill, заменив его на вызов filler<>::do_fill, который использует call_traits.

Обоснование

Следующие замечанию кратко описывают причины выбора решений в call_traits.

Все определенные пользователем типы следуют "существующей практике" и не нуждаются в комментариях.

Небольшие встроенные типы (то, что стандарт называет фундаментальными типами [3.9.1]) отличаются от существующей практики только реализацией call_traits<>::param_type. В этом случае передача "T const" совместима с существующей практикой, но может улучшить эффективность в некоторых случаях (см. Пример 4), в любом случае это не должно быть хуже, чем существующая практика.

Указатели ведут себя как небольшие встроенные типы.

Для ссылочных типов реализация следует примеру 2 - ссылки на ссылки не допускаются, так что call_traits предотвращает возникновение этой проблемы. Есть предложение изменить C++ таким образом, чтобы ссылка на ссылку была эквивалентна одной ссылке (предложение #106, сделано Bjarne Stroustrup), call_traits<T>::value_type и call_traits<T>::param_type обеспечивают этот же предложенный эффект, без необходимости менять язык.

Для типов массивов, функция, которая получает массив как аргумент, усекает его до указателя: это ознчает, что тип действительного параметра отличается от объявленного типа. Иногда это может вызвать проблемы в коде шаблона, который опирается на объявленный тип параметра. К примеру:

template <class T>
struct A
{
   void foo(T t);
};

В данном случае если мы конкретизируем A<int[2]>, тогда объявленный тип параметра, передаваемого в функцию-метод foo будет int[2], но действительный тип будет const int*. Если мы попытаемся использовать тип T внутри тела функции, тогда есть большая вероятность, что наш код не скомпилируется:

template <class T>

void A<T>::foo(T t)
{
   T dup(t); // doesn't compile for case that T is an array.
}

При использовании call_traits усечение массива к указателю является явным, и тип параметра тот же самый, что объявленный тип:

template <class T>
struct A
{
   void foo(typename call_traits<T>::value_type t);
};

template <class T>

void A<T>::foo(typename call_traits<T>::value_type t)
{
   typename call_traits<T>::value_type dup(t); // OK even if T is an array type.
}

Для value_type (возврат по значению) опять-таки только массив может быть возвращен, а не целый массив, и снова call_traits делает усечени явным. Член value_type полезен в любом случае, когда массив должен быть явно усечен до указателя - пример 3 показывает тестовый случай (примечание: специализация с массивом для call_traits наименее понятна из всех специализаций call_traits; если данная семантика вызывает у Вас какие-то трудности, или не решает какую-то проблему с массивами, тогда я буду рад услышать об этом. Большинству разработчиков данная специализация не нужна).

P.S.: Нагло спёрто отсюда: BOOST C++: заголовочный файл <boost/call_traits.hpp>

Использование идиомы boost::base_from_member

2009-04-01T20:00:00.001+03:00

Шаблон класса boost::base_from_member предоставляет возможность создавать классы, которые выполняют инициализацию своего базового класса членом класса. Шаблон класса находится в boost/utility/base_from_member.hpp, который включается в boost/utility.hpp. Предварительное (forward) объявление шаблона класса находится в boost/utility_fwd.hpp.

Пример использования - в файле base_from_member_test.cpp.

Содержание

Обоснование
Краткое описание
Использование
Пример

Обоснование

При разработке класса иногда возникает необходимость инициализировать базовый класс членом текущего класса. Простой пример:

#include <streambuf>  // for std::streambuf
#include <ostream>    // for std::ostream

class fdoutbuf
    : public std::streambuf
{
public:
    explicit fdoutbuf( int fd );
    //...
};

class fdostream
    : public std::ostream
{
protected:
    fdoutbuf buf;
public:
    explicit fdostream( int fd )
        : buf( fd ), std::ostream( &buf )
        {}  {}
    //.};

Поведение кода неопределено, так как порядок инициализации в C++ обязывает компилятор инициализировать базовый класс прежде, чем инициализировать члены класса. R. Samuel Klatchko разработал обходной маневр с надлежащим использованием порядка инициализации. Базовые классы инициализируются в порядке объявления, так что перемещение необходимого члена в другой базовый класс, который объявлен базовым перед другим базовым классом, позволяет гарантировать надлежащую инициализацию.

Собственный базовый класс может быть сделан из идиомы:

#include <streambuf>  // for std::streambuf

#include <ostream>    // for std::ostream

class fdoutbuf
    : public std::streambuf
{
public:
    explicit fdoutbuf( int fd );
    //.../...
};

struct fdostream_pbase
{
    fdoutbuf sbuffer;

    explicit fdostream_pbase( int fd )
        : sbuffer( fd )
        {}
};

class fdostream
    : private fdostream_pbase
    , public std::ostream
{
    typedef fdostream_pbase  pbase_type;
    typedef std::ostream     base_type;

public:
    explicit fdostream( int fd )
        : pbase_type( fd ), base_type( &sbuffer )
        {}
    //...
};

Другие проекты могут использовать похожие пользовательские базовые классы. Технология достаточно общая, чтобы создать шаблонный класс в данной библиотеке. Главный параметр шаблона имеет тип включенного члена класса. Шаблонный класс имеет несколько (явных) шаблонов конструктора, которые неявно определяют тип аргументов конструктора и передают их члену класса. Шаблонный класс имеет неявные конструктор копирования и оператор присваивания, что позволяет им отключаться, если включаемый член является некопируемым.

Manually coding a base class may be better if the construction and/or copying needs are too complex for the supplied template class, or if the compiler is not advanced enough to use it.

Since base classes are unnamed, a class cannot have multiple (direct) base classes of the same type. The supplied template class has an extra template parameter, an integer, that exists solely to provide type differentiation. This parameter has a default value so a single use of a particular member type does not need to concern itself with the integer.

Краткое описание

template < typename MemberType, int UniqueID = 0 >
class boost::base_from_member
{
protected:
    MemberType  member;

    base_from_member();

    template< typename T1 >
    explicit  base_from_member( T1 x1 );

    template< typename T1, typename T2 >

    base_from_member( T1 x1, T2 x2 );

    //...

    template< typename T1, typename T2, typename T3, typename T4,
     typename T5, typename T6, typename T7, typename T8, typename T9,
     typename T10 >
    base_from_member( T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7,
     T8 x8, T9 x9, T10 x10 );
};

Первый аргумент шаблонного класса MemberType - это тип члена в базовом классе (based-member). Последний аргумент шаблона UniqueID, имеющий тип int, предназначен для введения различий между несколькими базовыми классами, которые используют один и тот же член в базовом классе (based-member type). Последний параметр шаблона имеет значение по умолчанию 0. Шаблонный класс имеет защищенное поле member, которое производный класс может использовать для последующих базовых классов (или для себя самого).

Имеется конструктор по умолчанию и несколько шаблонов конструкторов. Эти шаблоны конструктора получают до 10 (в текущей версии) аргументов и передавать их в конструктор поля класса (data member). Так как C++ в любом случае не позволяет явно указывать параметры шаблона конструктора, следует убедиться, что аргументы максимально похожи по типу на действительные типы, используемые в соответствующем конструкторе поля класса.

Использование

В качестве начального примера можно рассмотреть под-объект (sub-object) fdoutbuf, который нужно заключить внутри базового класса, от которого происходит наследование перед std::ostream.

#include <boost/utility/base_from_member.hpp>

#include <streambuf>  // for std::streambuf
#include <ostream>    // for std::ostream

class fdoutbuf
    : public std::streambuf
{
public:
    explicit fdoutbuf( int fd );
    //...
};

class fdostream
    : private boost::base_from_member<fdoutbuf>
    , public std::ostream
{
    // Helper typedef's
    typedef boost::base_from_member<fdoutbuf>  pbase_type;
    typedef std::ostream                        base_type;

public:
    explicit fdostream( int fd )
        : pbase_type( fd ), base_type( &member )
        {}
    //...
};

Идиома base-from-member является деталью реализации, которая не должна быть видима пользователям класса класса fdostream. Из-за порядка инициализации, под-объект fdoutbuf инициализируется перед под-объектом std::ostream, что позволяет безопасно использовать последний под-объект в дальнейшем конструировании под-объектов. так как под-объект fdoutbuf конечного типа является единственным под-объектом с именем "member", это имя может быть пропущено (unqualified) внутри конечного класса.

Пример

Шаблоны классов, использующих идиому base-from-member, типично используют единственный под-объект base-from-member, обычно для прикрепления буфера к потоку ввода вывода (a stream-buffer to an I/O stream). Следующий пример демонстрирует, как использовать множественные под-объекты base-from-member, и показывает некоторые другие моменты, связанные с именованием полей.

#include <boost/utility/base_from_member.hpp>

#include <cstddef>  // for NULL

struct an_int
{
    int  y;

    an_int( float yf );
};

class switcher
{
public:
    switcher();
    switcher( double, int * );
    //...
};

class flow_regulator
{
public:
    flow_regulator( switcher &, switcher & );
    //...
};

template < unsigned Size >

class fan
{
public:
    explicit fan( switcher );
    //...
};

class system
    : private boost::base_from_member<an_int>
    , private boost::base_from_member<switcher>
    , private boost::base_from_member<switcher, 1>
    , private boost::base_from_member<switcher, 2>
    , protected flow_regulator
    , public fan<6>

{
    // Helper typedef's
    typedef boost::base_from_member<an_int>       pbase0_type;
    typedef boost::base_from_member<switcher>     pbase1_type;
    typedef boost::base_from_member<switcher, 1>  pbase2_type;
    typedef boost::base_from_member<switcher, 2>  pbase3_type;

    typedef flow_regulator  base1_type;
    typedef fan<6>          base2_type;

public:
    system( double x );
    //...
};

system::system( double x )
    : pbase0_type( 0.2 )
    , pbase1_type()
    , pbase2_type( -16, &this->pbase0_type::member )
    , pbase3_type( x, static_cast<int *>(NULL) )
    , base1_type( pbase3_type::member, pbase1_type::member )
    , base2_type( pbase2_type::member )
{
    //...
}

Конечный класс имеет несколько подобъектов с именем "member," поэтому любое использование этого имени должно сопровождаться квалификацией именем соответствующего базового класса. (Использование оператора typedef облегчает задачу). Однако, данное решение создает новую проблему, когда необходим указатель. Использование оператора взятия адреса с под-объектом, квалифицированным именем своего класса, дает указатель-на-член (pointer-to-member) (в данном случае, к типу an_int boost::base_from_member<an_int, 0> :: *) вместо указателя на член (к типу an_int *). Новая проблема решается через квалифицирование под-объекта с "this->," и необходимо только для указателей, а не для ссылок или значений.

При инициализации происходит несколько преобразований аргументов. Аргумент конструктора pbase0_type преобразуется из double в float. Первый аргумент конструктора для pbase2_type преобразуется из int в double. Второй аргумент конструктора для pbase3_type - это особый случай необходимого преобразования; все формы литерала для нулевого указателя в C++ выглядят как целочисленная константа времени компиляции, так что C++ всегда интерпретирует такой код как целое число в случаях, когда при перегрузке функций может быть целое число или указатель. Последнее преобразование необходимо для компилятора при вызове конструктора с точно определенным типом указателя в качестве аргумента при использовании в switcher's constructor.

P.S.: Нагло спёрто отсюда: BOOST C++: идиома Base-from-Member

Использование boost::utility

2009-04-01T19:40:00.001+03:00

Все объявления в хидере <boost/utility.hpp> включены в пространство имен boost.

Содержание

Шаблоны функций checked_delete() и checked_array_delete()
Шаблоны функций next() and prior()
Класс noncopyable
Шаблоны функций addressof()

Шаблоны функций checked_delete() и checked_array_delete()

Заголовный файл <boost/checked_delete.hpp> содержит определение двух шаблонов функций checked_delete и checked_array_delete, и два шаблона классов: checked_deleter и checked_array_deleter.

Стандарт C++ (в 5.3.5/5) разрешает освобождать указатели на неполные типы через delete. Когда класс имеет непустой деструктор или определенный для класса оператор delete, поведение такой операции становится неопределенным. Некоторые компиляторы печатают предупреждение, когда удаляется неполный тип, но, к несчастью, это делают не все компиляторы, а программисты иногда игнорируют или блокируют предупреждения.

В частности, проблемным случаем является использование деструктора в шаблоне умного указателя, такого как boost::scoped_ptr<T>::~scoped_ptr, для неполностью определенного типа. Это зачастую приводит к трудно обнаруживаемым сбоям в работе программ.

Предлагаемая функция и шаблон класса могут быть использованы для предотвращения этих проблем, потому что они требуют передачи им полностью определенного типа, и генерируют ошибку компиляции в противном случае.

Краткое описание

namespace boost
{
 template<class T> void checked_delete(T * p);
 template<class T> void checked_array_delete(T * p);
 template<class T> struct checked_deleter;

 template<class T> struct checked_array_deleter;
}

checked_delete

template<class T> void checked_delete(T *p);

Требует: T должен быть полным типом (complete type). Выражение delete p должно быть синтаксически верным.

Эффекты: delete p;

checked_array_delete

template<class T> void checked_array_delete(T * p);

Требует: T должен быть полным типом. Выражение delete [] p должно быть синтаксически верным.

Эффекты: delete [] p;

checked_deleter

template<class T> struct checked_deleter
{
    typedef void result_type;
    typedef T * argument_type;
    void operator()(T * p) const;
};

void checked_deleter<T>::operator()(T * p) const;

Требует: T должен быть полным типом (complete type). Выражение delete p должно быть синтаксически верным.

Эффекты: delete p;

checked_array_deleter

template<class T> struct checked_array_deleter
{
    typedef void result_type;
    typedef T * argument_type;
    void operator()(T * p) const;
};

void checked_array_deleter<T>::operator()(T * p) const;

Требует: T должен быть полным типом. Выражение delete [] p должно быть синтаксически верным.

Эффекты: delete [] p;

Благодарности

Шаблоны функций checked_delete и checked_array_delete изначально были частью boost/utility.hpp, и документация была разработана с участием Beman Dawes, Dave Abrahams, Vladimir Prus, Rainer Deyke, John Maddock, и др.

Шаблоны функций next() и prior()

Определенные типы данных, такие как итераторы категорий forward и bidirectional стандартной библиотеки C++, не поддерживают операции сложения и вычитания через operator+() или operator-(). Это означает, что не-модифицирующие вычисления последующего и предыдущего значения требуют создания временного объекта, даже если operator++() или operator--() допустимы. Это также означает, что написание кода типа itr+1 внутри шаблона ограничивает категорию итератора в рамках random access.

Функции next() и prior() предоставляют простой способ избежать этих проблем:

template <class T>
T next(T x) { return ++x; }

template <class T, class Distance>

T next(T x, Distance n)
{
    std::advance(x, n);
    return x;
}

template <class T>
T prior(T x) { return --x; }

template <class T, class Distance>
T prior(T x, Distance n)
{
    std::advance(x, -n);
    return x;
}

Использование предельно просто:

const std::list<T>::iterator p = get_some_iterator();
const std::list<T>::iterator prev = boost::prior(p);
const std::list<T>::iterator next = boost::next(prev, 2);

Расстояние от заданного итератора должно быть задано абсолютной величиной. К примеру, итератор, отстоящий на 4 шага итератора от заданного итератора p может быть получен как prior(p, 4).

Функции создал Dave Abrahams. Версии с двумя аргументами создал Daniel Walker.

Класс noncopyable

Класс noncopyable является базовым. Пользовательский класс должен наследовать от noncopyable, чтобы запретить создание объектов через копирование и копирование через присваивание.

Некоторые объекты, в частности те, которые управляют сложными ресурсами (файлами или сетевыми сессиями), не поддерживают семантику копирования. Иногда семантика копирования в принципе возможна, но она имеет либо весьма ограниченную полезность, либо слишком сложна для правильной реализации. Иногда Вы разрабатываете класс, который просто не нужно копировать, и Вы не желаете тратить время на написание соответствующих функций. Наследование от noncopyable предотвращает создание компилятором по умолчанию конструктора копирования и оператора присваивания, что предотвращает других программистов от ошибочного использования класса.

Обычный способ решения проблемы заключается в объявлении приватных конструктора копирования и оператора присваивания, и затем документирования причин, по которым это сделано. Но наследование от класса noncopyable проще и очевиднее, и не тредбует дополнительного документирования.

Программа noncopyable_test.cpp может быть использована для проверки правильного функционирования класса noncopyable. Она успешно откомпилирована с помощью GCC 2.95, Metrowerks CodeWarrior 5.0, и Microsoft Visual C++ 6.0 sp 3.

Создатель: Dave Abrahams.

Пример

// inside one of your own headers ...
#include <boost/utility.hpp>

class ResourceLadenFileSystem : boost::noncopyable {
...

Обоснование

Класс noncopyable имеет защищенные конструктор и деструктор, чтобы подчеркнуть тот факт, что он используется только как базовый класс. Dave Abrahams сделал замечание о возможном негативном влиянии на компиляторную оптимизацию кода после добавления (даже пустого) деструктора. Он заявил: "Возможно, эти опасения беспочвенны, потому что noncopyable будет использован главным образом для классов, которые управляют ресурсами и таким образом имеют нетривиальные деструкторы".

Шаблон функции addressof()

Функция addressof() возвращает адерс объекта.

template <typename T> inline T*                addressof(T& v);
template <typename T> inline const T*          addressof(const T& v);
template <typename T> inline volatile T*       addressof(volatile T& v);
template <typename T> inline const volatile T* addressof(const volatile T& v);

C++ разрешает программисту заменять унарный оператор в классе operator&() для получения адреса объекта. Получение истинного адреса объекта требует неуклюжих тюков с преобразованием (casting), чтобы избежать вызова перегруженного оператора operator&(). Функция addressof() обеспечивает обертку для необходимого кода< чтобы упростить получение истинного адреса объекта.

Программа addressof_test.cpp может быть использована для проверки правильной работы функции addressof().

Добавил: Brad King на основе идей, возникших в дискуссии с Doug Gregor.

Пример

#include <boost/utility.hpp>

struct useless_type {};
class nonaddressable {
  useless_type operator&() const;
};

void f() {
  nonaddressable x;
  nonaddressable* xp = boost::addressof(x);
  // nonaddressable* xpe = &x; /* error */
}

P.S.: Нагло спёрто отсюда: BOOST C++: заголовочный файл boost/utility.hpp

Использование boost::multi_index

2009-04-01T19:20:00.001+03:00

Все типы Boost.MultiIndex объявлены в пространстве имен boost::multi_index. Дополнительно в пространство boost включены шаблонный класс multi_index_container и глобальные функции get и project. Для краткости большинство приводимых фрагментов кода предполагают предшествующее расширение области видимости:

using namespace ::boost;
using namespace ::boost::multi_index;

Введение

Мы предлагаем ознакомится с основными концепциями Boost.MultiIndex на паре простых примеров.

Проведение различных сортировок одного множества

Шаблоны STL set и multiset являются массивами переменной длины, где элементы отсортированы согласно установленному сравнительному предикату (критерию). Эти контейнерные класс немногим способны помочь программисту, когда ему необходимо сортировать и искать элементы опираясь на несколько критериев. Взгляните на пример:

struct employee
{
int id;
std::string name;
employee(int id,const std::string& name):id(id),name(name){}
bool operator<(const employee& e)const{return id<e.id;}
};

Тот факт, что ID-ключ является уникальным для каждого служащего, определяет возможность перегрузки оператора «<», что в свою очередь позволяет держать такие переменные типа employee в контейнере std::set<employee>. Теперь, если мы хотим вывести список работников в алфавитном порядке, мы столкнемся с рядом трудностей и недостатков, начиная от неразумного расходования памяти, кончая громоздкостью и ненаглядностью кода. Вот, что первое приходит в голову:

Копировать переменную типа std::set<employee> в переменную типа vector и в качестве критерия сортировки определить функтор, работающий с полем структуры name.

Хранить кроме основного массива еще массив указателей на его элементы, соответственно отсортированный по полю name.

Их этих двух решений, пожалуй, второе принимается большинством программистов, заботящимся о быстродействии, однако оно предполагает постоянно в программе «тащить» вместо одной структуры – две. Если от такого кода потребовать еще и устойчивости к исключительным ситуациям, то поддерживать такую конструкцию становится невозможным.

Boost.MultiIndex отличает от других контейнеров наличие нескольких интерфейсов доступа (индексов упорядочения), каждый из которых сортирует элементы по определенному ключу. Этот шаблон разработан, чтобы помочь в решении задач на сортировку, поиск и др. элементов более чем по одному условному критерию. Определение индексов происходит при конкретизации шаблона multi_index_container; через каждый индекс доступ и сортировка будут происходить отдельно, тогда как сами элементы будут храниться в одном и том же контейнере. Задача, поставленная в примере при помощи Boost.MultiIndex решается следующим образом:

// определение бииндексированного множества с индексацией по полям name // и ID
typedef multi_index_container<
employee,
indexed_by<
// сортировка согласно перегруженному оператору “<”
ordered_unique<identity<employee> >,

// сортировка функтором less<string> по полю name
ordered_non_unique<member<employee,std::string,&employee::name> >
> 
> employee_set;

void print_out_by_name(const employee_set& es)
{
// установка доступа к элементам по первому индексу
const employee_set::nth_index<1>::type& name_index=es.get<1>();
// используйте name_index просто как std::set
std::copy(
name_index.begin(),name_index.end(),
std::ostream_iterator<employee>(std::cout));
}

Вместо единственного условного критерия сравнения, как в ассоциативных контейнерах STL, multi_index_container имеет typelist (список типов), называемый indexed_by, где конкретизируются типы, вы устанавливаете соответствующие индексы. Доступ через соответствующий индекс получается через get<N>(), где N изменяется от 0 до количества условных критериев минус один. Доступ через 0-ой индекс может осуществляется по умолчанию прямо из объекта multi_index_container без использования функции get<0>(). Например, es.begin() – то же, что и es.get<0>().begin().

Отметим, что get() возвращает ссылку на индексированное множество (будем называть множество, имеющее доступ к элементам основного массива, через один из индексов просто ИНДЕКСом) , а не объект. Индекс не может быть сконструирован в самостоятельный объект, отдельный от основного контейнера. Поэтому следующий код

// неверно: мы забыли & после employee_set::nth_index<1>::type
const employee_set::nth_index<1>::type name_index=es.get<1>();

будет вызывать ошибку, поскольку здесь осуществлена попытка сделать индекс-объект name_index. Это пример типичной ошибки среди пользователей этой библиотеки.

Двунаправленный список с быстрым поиском

На этом примере мы продемонстрируем работу так называемых последовательных индексов, узнаем, как можно их совместить с индексами упорядочения для построения более функциональных контейнеров. Допустим, мы имеем текст, разбитый на слова и хранящийся в списке, вреде этого:

typedef std::list<std::string> text_container;

std::string text=
"Alice was beginning to get very tired of sitting by her sister on the "
"bank, and of having nothing to do: once or twice she had peeped into the "
"book her sister was reading, but it had no pictures or conversations in "
"it, 'and what is the use of a book,' thought Alice 'without pictures or "
"conversation?'";

// внесение текста в список, используя шаблонный токенайзер из boost
text_container tc;
boost::tokenizer<boost::char_separator<char> > tok
(text,boost::char_separator<char>(" \t\n.,;:!?'\"-"));
std::copy(tok.begin(),tok.end(),std::back_inserter(tc));

//Если мы хотим посчитать, сколько раз слово включено в список, мы воспользуемся std::count:
std::size_t occurrences(const std::string& word)
{
return std::count(tc.begin(),tc.end(),word);
}

Однако исполнение такого алгоритма будет происходить за линейное время, что может быть неприемлемо в случае больших количеств текста. Аналогично, операция удаления слова из середины списка по времени также весьма затратна в std::list:

void delete_word(const std::string& word)
{
tc.remove(word); // scans the entire list looking for word
}

Если необходимо представление списка, к примеру, в алфавитном порядке, нам снова необходимо заводить отдельную структуру, индексирующую элементы в tc. Boost.MultiIndex делает это просто комбинируя последовательный и порядковый индексы:

// объявление multi_index_container со «списковым» индексом и порядковым 
// индексом 
typedef multi_index_container<
std::string,
indexed_by<
sequenced<>, // «списковый» индекс
ordered_non_unique<identity<std::string> > // слова в алфавит. Порядке
>
> text_container;

std::string text=...

// внесение текста в список
text_container tc;
boost::tokenizer<boost::char_separator<char> > tok
(text,boost::char_separator<char>(" \t\n.,;:!?'\"-"));
std::copy(tok.begin(),tok.end(),std::back_inserter(tc));

До сих пор, замена std::list на multi_index_container не давала особых преимуществ. Код для вставки текста в контейнер не изменился, поскольку последовательный индекс предоставляет интерфейс доступа, полностью аналогичный таковому у std::list (нет необходимости обращаться к этому индексу через get<0>(), поскольку, как было сказано выше, multi_index_container наследует весь интерфейс своего нулевого индекса.) Однако введение дополнительного порядкового индекса позволит нам выполнять процедуры подсчета слов и удаления слов более эффективно:

std::size_t occurrences(const std::string& word)
{
// устанавливаем доступ через №1 индекс
text_container::nth_index<1>::type& sorted_index=tc.get<1>();

// используем sorted_index просто как std::set
return sorted_index.count(word);
}

void delete_word(const std::string& word)
{
// устанавливаем доступ через №1 индекс
text_container::nth_index<1>::type& sorted_index=tc.get<1>();

// используем sorted_index просто как std::set
sorted_index.erase(word);
}

Теперь процедуры occurrences и delete_word выполняются за логарифмическое время. Программист может использовать №0 индекс для доступа к исходному тексту (как std::list) или использовать №1 индекс, когда необходим логарифмический поиск.

Определение индексов

Индексы в конкретизации multi_index_container объявляются внутри специальной конструкции indexed_by. Например, конкретизация:

typedef multi_index_container<
employee,
indexed_by<
ordered_unique<identity<employee> >,
ordered_non_unique<member<employee,std::string,&employee::name> >
> 
> employee_set;
включает уникальный порядковый индекс и неуникальный порядковый индекс, а, следующим кодом:
typedef multi_index_container<
std::string,
indexed_by<
sequenced<>,
ordered_non_unique<identity<std::string> >
>
> text_container;

мы установили два индекса, первый последовательного типа, а второй – неуникальный порядковый индекс. В общем случае мы можем объявлять произвольное число индексов: каждый аргумент конструкции indexed_by называется спецификатором индекса. В зависимости от типа индекса, объявление соответствующего спецификатора будет требовать дополнительной информации: например, спецификаторы ordered_unique и ordered_non_unique требуют указания ключевого поля и (необязательно) сравнительного условного предиката; вместе они полностью определяют, как будет производиться сортировка.

конкретизация multi_index_container может быть объявлена без конструкции indexed_by: в таком случае индексация по умолчанию производится таким образом, что конкретизированный шаблон эквивалентен конкретизированному std::set. Если конкретно - конкретизация

multi_index_container<(element)>
аналогична
multi_index_container<
(element),
indexed_by<
ordered_unique<identity<(element)> >
>
>

Метки

С целью получения доступа к индексу данного multi_index_container, программист должен помнить порядковый номер этого индекса в списке indexed_by. Однако такое обращение к индексу является неуклюжим и ненаглядным, поэтому в спецификатор индекса введен такой (необязательный) параметр, как метка (tag). Она всегда ставится первым параметром в соответствующем спецификаторе. Вот как будет выглядеть наш тип employee_set с использованием меток:

// метки
struct name{};

typedef multi_index_container<
employee,
indexed_by<
ordered_unique<identity<employee> >,
ordered_non_unique<tag<name>,member<employee,std::string,&employee::name> >
>
> employee_set;

Метка должна быть описана внутри конструкции tag. Любой тип может быть использован в качестве метки индекса, хотя, в основном, выбирают названия, которые так или иначе описывают индекс. Вызов соответствующего индекса по метке выглядит так:

typedef employee_set::index<name>::type employee_set_by_name;
employee_set_by_name::iterator it=es.get<name>().begin();

Если метка для индекса не определена (как в случае №0 индекса в предыдущем примере), доступ к данному индексу предоставляется только по его номеру. Отметим, что typedef-конструкции для получения доступа к индексу через номер и через метку различны. Например:

// тип переменной доступа к индексу #1,
employee_set::nth_index<1>::type
// тип переменной доступа к индексу, меченному name (в данном случая эти два определения эквивалентны)
employee_set::index<name>::type

Наоборот, метод get() перегружен и используется одинаково в обоих случаях:

employee_set::index<name>::type& name_index=es.get<name>();
employee_set::nth_index<1>::type& name_index2=es.get<1>(); // тот же индекс

К тому же шаблон класса tag может получать в качестве параметров несколько меток для одного индекса: например, спецификация №1 индекса в предыдущем примере может быть переписана с использованием двух различных меток name и by_name:

// метки
struct name{};
struct by_name{};

typedef multi_index_container<
...
ordered_non_unique<
tag<name,by_name>,
member<employee,std::string,&employee::name>
>
...
> employee_set;

Типы индексов

В настоящее время Boost.MultiIndex имеет следующие типы индексов:

Порядковые индексы сортируют элементы как std::set-ы и предоставляют аналогичный интерфейс. Они могут быть двух вариантов: уникальные и неуникальные; первые не позволяют хранить идентичные элементы, тогда как вторые – позволяют (как std::multiset)

Последовательные индексы разработаны по образу и подобию std::list : они хранят элементы аналогично двунаправленному списку.

Пример во введении демонстрирует использование всех видов индексов.

Порядковые индексы

Порядковые индексы сортируют элементы multi_index_container согласно заданному ключевому полю и заданному сравнительному предикату. Доступ через эти индексы аналогичен работе с контейнерами std::set, и более того – полностью копируют их интерфейс, хотя присутствуют некоторые небольшие отличия, диктуемые общими принципами Boost.MultiIndex.

Уникальный и неуникальный варианты

Последовательные индексы могут быть описаны как уникальные, тогда они запрещают наличие двух элементов с одинаковыми значениями ключевого поля, и неуникальные, которые это позволяют. Посмотрим снова на инсталляцию

typedef multi_index_container<
employee,
indexed_by<
ordered_unique<identity<employee> >,
ordered_non_unique<member<employee,std::string,&employee::name> >
> 
> employee_set;

Первый индекс объявлен как уникальный (поскольку поле ID уникально для каждого рабочего) и поэтому описан как тип ordered_unique, тогда как второй индекс неуникален (поскольку два Джона Смита могут служить в одной компании) и соответственно описан как ordered_non_unique.

Разделение порядковых индексов на уникальный и неуникальные влияет на то, какие элементы можно вставлять в multi_index_container. Короче включение через уникальный порядковый индекс проходит аналогично включению в std::set, тогда как через неуникальный – аналогично std::multiset. Например, employee_set может содержать структуры employee(0, “George Brown”) и employee(1, “George Brown”), но добавить структуру с таким же ID, какой там уже имеется, нельзя.

В конкретизации multi_index_container может быть объявлено несколько уникальных индексов. Например, если мы собираем данные об ИНН работников, который также уникален, мы можем организовать контейнер таким образом:

struct employee
{
int id;
std::string name;
int ssnumber;

employee(int id,const std::string& name,int ssnumber):
id(id),name(name),ssnumber(ssnumber){}

bool operator<(const employee& e)const{return id<e.id;}
};

typedef multi_index_container<
employee,
indexed_by<
// сортировать по employee::operator<
ordered_unique<identity<employee> >,

// сортировать согласно less<string> по полю name
ordered_non_unique<member<employee,std::string,&employee::name> >,

// сортировать согласно less<int> по полю ssnumber
ordered_unique<member<employee,int,&employee::ssnumber> >
>
> employee_set;

Спецификация индексов

Синтаксис спецификатора порядкового индекса в поле шаблона indexed_by выглядит следующим образом:

(ordered_unique | ordered_non_unique)
<[(tag)[,(key extractor)[,(comparison predicate)]]]>

(ordered_unique | ordered_non_unique)
<[(key extractor)[,(comparison predicate)]]>

Первый необязательный аргумент используется, когда индексу приписывается метка. Сейчас мы немного поговорим об остальных двух.

Ключевое поле

Первым параметром шаблона спецификации индекса (или второй, если есть метка) является ключевое поле. Этот параметр передает ссылку на элемент (в нашем примере на всю структуру employee) и частично информацию о способе сортировки таких элементов. Вот основные варианты определения ключевого поля:

Целый элемент служит ключом, как в случае первого индекса в employee_set. А для определения ключевого поля можно использовать; identity как раз используется, когда ключом является целый объект.

Сравнение осуществляется по отдельному полю структуры элемента – это очень напоминает работу с индексами отдельной колонки реляционной базы данных. Boost.MultiIndex имеет шаблон member, который возвращает ключ на поле структуры, определяемое указателем

В качестве примера снова рассмотри наш employee_set. Первый индекс:

ordered_unique<identity<employee> >

определяется при помощи identity, причем объект элемента выступает в качестве ключа. Теперь посмотрим на второй индекс:

ordered_non_unique<member<employee,std::string,&employee::name> >

Здесь мы используем шаблон member, чтобы определяем (извлекаем) ключ из поля структуры employee. Тип этого ключа – std::string.

Другой общий случай – когда сортировка производится по заданной функции-члену класса элемента. Это напоминает случай вычисляемого индекса в некоторых реляционных БД. В таких случаях ключ не является переменной-членом структуры элемента, а получает значение из заданной функции-члена. Boost.MultiIndex поддерживает такой механизм «извлечения» ключа посредством шаблона const_mem_fun. Рассмотрим расширение нашего примера, когда сортировка по третьему индексу проводится на основе длины поля name:

struct employee
{
int id;
std::string name;

employee(int id,const std::string& name):id(id),name(name){}

bool operator<(const employee& e)const{return id<e.id;}

// возвращает длину поля name
std::size_t name_length()const{return name.size();}
};

typedef multi_index_container<
employee,
indexed_by<
// сортировать согласно employee::operator<
ordered_unique<identity<employee> >,

// сортировать согласно less<string> по полю name
ordered_non_unique<member<employee,std::string,&employee::name> >,

// сортировать согласно less<int> по ключу name_length()
ordered_non_unique<
const_mem_fun<employee,std::size_t,&employee::name_length>
>
>
> employee_set;

Пример 2 в разделе примеров содержит законченную программу, демонстрирующую использование const_mem_fun. Почти всегда, используются именно константные функции-члены, поскольку в multi_index_container-е (как и в std::set-е) элементы предполагаются постоянными. Однако шаблон mem_fun предоставляет вам возможность использовать неконстантные функции-члены. Их использование и применение подробно обсуждено в параграфе о дополнительных характеристиках ключевых полей Boost MultiIndex в разделе дополнительной информации.

Более сложные типы контейнеров могут потребовать сложных ключей, собирающих информацию сразу от нескольких ключевых полей. Сложные ключи введены в Boost.MultiIndex при помощи конструкции composite_key.

identity, member и const_mem_fun (или их комбинации при помощи composite_key) наиболее часто используемые шаблоны, используемые для разработки multi_index_container-ов. Однако пользователь имеет возможность написать собственную процедуру «извлечения» ключа для более экзотических ситуаций, чем те, которые предполагает данная концепция. В примере №6 демонстрируется использование нескольких технологий «извлечения» ключа, которые необходимы когда доступ к элементам и/или ключам осуществляется через указатели.

Условные предикаты сравнения

И наконец, последнее поле спецификатора порядкового индекса – это предикат (критерий) сравнения, который представляет из себя оператор «меньше» (на деле – функтор), определенных для типа ключа. Этот критерий не отличается от таковых, использующихся в контейнерах STL, таких как std::set. По умолчанию (если поле предиката в спецификаторе не заполнено), индекс с ключом типа key_type сортирует элементы согласно функтору std::less<key_type>. Если требуется определить какой-то другой критерий сравнения, ссылка на него дается в конце объявления индекса:

// определяет полииндексированное множество с индексами по id и name
// в обратном алфавитном порядке
typedef multi_index_container<
employee,
indexed_by<
ordered_unique<identity<employee> >, // обычный индекс
ordered_non_unique<
member<employee,std::string,&employee::name>,
std::greater<std::string> //по умолчанию std::less<std::string>
>
>
> employee_set;

Специальные функции поиска

Наличие порядкового индекса позволяет проводить поиск элементов согласно определенному для этого индекса ключу. Например, чтобы найти Веронику Круз в employee_set вы можете написать:

employee_set es;
...
typedef employee_set::index<name>::type employee_set_by_name;
employee_set_by_name::iterator it=es.get<name>().find("Veronica Cruz");

Кроме того, Boost.MultiIndex предоставляет специальные операции поиска, который ведется по ключу, отличному по типу от key_type-а нашего индекса. Это оказывается чрезвычайно полезным, когда затратно создавать переменные типа key_type. Последовательные контейнеры STL не имеют аналогичных возможностей, поэтому приходится прибегать к неэлегантным обходным путям. Например, рассмотрим задачу определения рабочих, чьи ID лежат в промежутке [0,100]. Принимая во внимание, что ключ индекса №0 это сам элемент employee, можем для начала написать следующее:

employee_set::iterator p0=es.lower_bound(employee(0,""));
employee_set::iterator p1=es.upper_bound(employee(100,""));

Однако помните, что std::less<employee> в действительности сравнивает ID рабочих, поэтому более уместно было бы запретить создание структуры employee целиком, а извлекать только их ID. Boost.MultiIndex предлагает для этой цели определить другой критерий-функтор:

struct comp_id
{
// compare an ID and an employee
bool operator()(int x,const employee& e2)const{return x<e2.id;}

// compare an employee and an ID
bool operator()(const employee& e1,int x)const{return e1.id<x;}
};

и написать теперь уже:

employee_set::iterator p0=es.lower_bound(0,comp_id());
employee_set::iterator p1=es.upper_bound(100,comp_id());

Здесь в ходе поиска мы не просто перебираем ID элементов вместо перебор целых employee-структур, мы создаем новый критерий поиска. В общем, если мы хотим перегрузить критерии поиска, мы должны позаботиться об их совместимости. Если не прибегать к строгим определениям (а их вы можете найти в главе «MultiIndex: Руководство»), то критерии называются совместимыми, когда любая последовательность, отсортированная по одному из них также отсортирована и по другому. Вот более интересный пример сортировки:

// сортировка по инициалам
struct comp_initial
{
bool operator()(char ch,const std::string& s)const{
if(s.empty())return false;
return ch<s[0];
}

bool operator()(const std::string& s,char ch)const{
if(s.empty())return true;
return s[0]<ch;
}
};

// получение первого рабочего с именем на 'J' (сортировка по имени)
typedef employee_set::index<name>::type employee_set_by_name;
employee_set_by_name& name_index=es.get<name>(); 
employee_set_by_name::const_iterator it=
name_index.lower_bound('J',comp_initial());

Получение диапазонов

Диапазонный поиск, то есть поиск всех элементов данного интервала – очень частая операция, для которой стандартные lower_bound и upper_bound могут быть использованы, разве что в простейших случаях. Например, этот код отбирает элементы multi_index_container<double>, расположенные в интервале [100; 200]:

typedef multi_index_container<double> double_set;
// напомним, что параметры при конркретизации по умолчанию:
// multi_index_container<double,indexed_by<unique<identity<double> > > >.

double_set s;
...
double_set::iterator it0=s.lower_bound(100.0);
double_set::iterator it1=s.upper_bound(200.0);
// диапазон [it0,it1) содержит элементы [100,200]

Небольшие изменения в код следует внести, если мы хотим сделать одну из границ интервала нестрогой. Если мы, к примеру, ищем элементы интервала (100, 200), то писать надо так:

double_set::iterator it0=s.upper_bound(100.0);
double_set::iterator it1=s.lower_bound(200.0);
// диапазон [it0,it1) содержит элементы (100;200)

Чтобы внести в код такое усложнение, аккуратный программист обязан принимать во внимание, что верхняя и нижняя границы интервала – вещи нестрогие. Если, к примеру, нижняя грань 200, а верхняя – 100, итераторы it0 и it1, определенные в порядке, обратном приведенному, не будут охватывать никакого диапазона. При попытке пройтись в цикле по элементам от it0 до it1 вы вполне можете проворонить исключение. Эти особенности делают поиск диапазона стандартными STL функциями ненаглядным и незащищенным.

Встроенная функция range, часто в сочетании с выражениями Boost.Lambda, может сильно облегчить программирование такого рода поисков. Взгляните:

using namespace boost::lambda;

typedef multi_index_container<double> double_set;
double_set s;
...
std::pair<double_set::iterator,double_set::iterator> p=
s.range(100.0<=_1,_1<=200); // 100<= x <=200
...
p=s.range(100.0<_1,_1<200); // 100< x < 200
...
p=s.range(100.0<=_1,_1<200); // 100<= x < 200
Одна или обе границы могут быть обозначены ключевым словом unbounded (неограничен):
p=s.range(100.0<=_1,unbounded); // 100 <= x
p=s.range(unbounded,_1<200.0); // x < 200
p=s.range(unbounded,unbounded); // то же, что std::make_pair(s.begin(),s.end())

Обновление

Встроенная функция replace выполняет замену в месте, указанном итератором:

typedef index<employee_set,name>::type employee_set_by_name;
employee_set_by_name& name_index=es.get<name>();

employee_set_by_name::iterator it=name_index.find("Anna Jones");
employee anna=*it;
anna.name="Anna Smith"; // она уже вышла за муж за К. Смита
name_index.replace(it,anna); // обновляем запись

replace-процедура имеет в данном случае ряд особенности:

Выполнение ее происходит за постоянное время, если элемент после замены остается на то же месте, относительно всех индексов; в обратном случае она происходит за логарифмическое время.

Корректность итератора и ссылки проверяется.

Вся процедура выполнена защищенной от исключений, т.е. multi_index_container остается неизменными даже в том случае, если система или пользовательский тип данных возбуждает исключение в ходе выполнения процедуры.

replace – очень полезная функция, не объявленная в стандартах STL, очень удобна как раз когда требуется надежная защита от исключительных ситуаций.

Наблюдательный читатель может заметить, что удобство процедуры replace «влетает в копеечку»: элемент копируется целиком дважды. Первый раз при получении замещающего элемента, второй – при вставлении его в контейнер. Если структура громоздка для копирования, будет выгоднее модифицировать отдельные поля элемента. Для этого в Boost.MultiIndex введен альтернативный механизм обновления – функция modify:

struct change_name
{
change_name(const std::string& new_name):new_name(new_name){}
void operator()(employee& e)
{
e.name=new_name;
}

private:
std::string new_name;
};
...
typedef employee_set::index<name>::type employee_set_by_name;
employee_set_by_name& name_index=es.get<name>();

employee_set_by_name::iterator it=name_index.find("Anna Jones");
name_index.modify(it,change_name("Anna Smith"));

Функция Modify получает на вход функтор (или указатель на функцию), который модифицирует элемент, тем самым, избавляя программиста от необходимости создавать лишнюю структуру, как это нужно было бы в случае replace. Так же, как и replace, эта функция хорошо защищена и сохраняет информацию контейнера при сбоях. Однако механизм ее действия не полностью аналогичен механизму replace. Рассмотрим, что происходит, если в результате замены возникает повтор по уникальному индексу. В случае replace, исходное значение поля будет возвращено и функция завершится, никак не повлияв на контейнер. В случае modify, такой возможности у функции нет, поэтому ошибочный элемент, появившийся в результате модификации, будет немедленно удалее, а функция вернет false. Это различие необходимо должно учитываться программистом при выборе между функциями replace и modify.

Аналогично modify, объявлена функция для модификации ключевого поля -- modify_key. В таком случае модифицирующий функтор получает ссылку на поле key_value элемента контейнера, а не на весь элемент. Обратите внимание, что такие модификации возможны (разумеется, иначе никак), только в том случае, когда ключ не извлекается специальными процедурами (как const_mem_fun), а получается прямо из поля структуры элемента

struct change_str
{
change_str(const std::string& new_str):new_str(new_str){}

// работает со строкой, не со структурой employee
void operator()(std::string& str)
{
str=new_str;
}

private:
std::string new_str;
};
...
typedef employee_set::index<name>::type employee_set_by_name;
employee_set_by_name& name_index=es.get<name>();

employee_set_by_name::iterator it=name_index.find("Anna Jones");
name_index.modify_key(it,change_str("Anna Smith"));

Точно так же, как и modify, modify_key удаляет элемент, если результат модификации вызывает противоречие в каком-то из индексов. Modify и modify_key позволяют использование удобного синтаксиса Boost.Lambda в указании модификаторов:

using namespace boost::lambda;

typedef employee_set::index<name>::type employee_set_by_name;
employee_set_by_name& name_index=es.get<name>();

employee_set_by_name::iterator it=name_index.find("Anna Jones");
name_index.modify_key(it,_1="Anna Smith");

Последовательные индексы

В отличие от порядковых индексов, последовательные индексы не имеют фиксированного правила следования элементов – наоборот, элементы могут быть помещены в любую точку последовательности (как в std::list). Интерфейс последовательных индексов, соответственно задуман очень похожим на std::list, по крайней мере, все функции std::list здесь продублированы. Их реализация может быть слегка отличной по аргументам и/или семантике, дабы удовлетворять единой концепции Boost.MultiIndex. В частности, имеется существенное ограничение в доступе к элементам через последовательный индекс: изменение элементов multi_index_container через итератор запрещено:

multi_index_container<
int,
indexed_by<sequenced<> >
> s; // контейнер-список

s.push_front(0);
*(s.begin()) = 1; // ERROR: элементы нельзя изменять ТАК

Получается, что итераторы последовательного индекса (в действительности, любого индекса) указывают на константные элементы. Это ограничение может показаться странным, однако оно продиктовано принципами работы multi_index_container-а. Если мы позволим изменять элементы таким образом, мы можем нарушить целостность других индексов контейнера. Изменение элементов может быть осуществлено только посредством функций обновления.

Если в нашем multi_index_container-е есть два или более индексов, один из которых последовательный, при вставлении элемента посредством любого непоследовательного индекса, элемент автоматически добавляется в конец последовательного. Пример поможет вам понять это:

multi_index_container<
int,
indexed_by<
sequenced<>, // последовательный тип
ordered_unique<identity<int> > // дополнительный день
>
> s;

s.get<1>().insert(1); // вставка «1» посредством индекса #1
s.get<1>().insert(0); // вставка «0» посредством индекса #1

// список элементов, упорядоченных по индексу #0
std::copy(s.begin(),s.end(),std::ostream_iterator<int>(std::cout));
// результат: 1 0

Таким образом, последовательные индексы располагают элементы в порядке их вставления, даже если вставка производилась посредством непоследовательного индекса.

Спецификация

Последовательные индексы описываются при помощи шаблона sequenced:

sequenced<[(tag)]>

Параметр tag является необязательным.

Функции списка

Как было отмечено ранее, последовательные индексы довольно точно копируют интерфейс std::list (большинство функций практически идентичны). Однако семантика и внутренняя организация таких процедур совпадает далеко не всегда. Еще раз повторим, что эти отличия диктуются тем, что вставка элемента может повлечь за собой разрушение внутренней структуры других индексов multi_index_container. Для более подробной информации смотрите руководство.

Обновление

Так же, как и порядковые индексы, последовательные индексы предоставляют аналогичные функции modify и replace. Однако аналога modify_key нет, поскольку порядковые индексы не имеют ключа.

Проекция итераторов

Если в нашем multi_index_container-е определены два индекса i1 и i2, то при помощи функции project можно получить значение i1-итератора некоего элемента по известному i2-итератору того же элемента. Эта процедура позволяет программисту быстро перемещаться между различными индексами multi_index_container-а. Рассмотрим пример:

typedef employee_set::index<name>::type employee_set_by_name;
employee_set_by_name& name_index=es.get<name>();

// Список работников, упорядоченных по ID, начиная с ID Роберта Брауна

employee_set_by_name::iterator it1=name_index.find("Robert Brown");

// получение итератора по 0-индексу из it1
employee_set::iterator it2=es.project<0>(it1); 

std::copy(it2,es.end(),std::ostream_iterator<employee>(std::cout));

Чуть более сложный пример:

text_container tc;

// доступ к элементам через #1 (индекс, упорядоченный по словам)
text_container::nth_index<1>::type& sorted_index=tc.get<1>();

// вставка "older" после каждой из "sister"

text_container::nth_index_iterator<1>::type it1=
sorted_index.lower_bound("sister");

while(it1!=sorted_index.end()&&*it1=="sister"){
// преобразование итератора в итератор последовательного индекса
text_container::iterator it2=tc.project<0>(it1);

tc.insert(it2,"older");
++it1;
}

При необходимости может быть использован в сочетании с tags.

Безопасность и дополнительные возможности

multi_index_container предосталяет дополнительные возможности и гарантирует определенный уровень безопасности, как это делает STL. Обращение к элементам через итераторы защищено в смысле операций вставки, замены и редактирования элементов.

Конкретизация multi_index_container может быть проведена абсолютно аналогично std::set, std::multiset и (с небольшими ограничениями) std::list, см. дополнительные вопросы. Эта аналогия продолжается не только на синтаксис, но и на эффективность выполнения операций. Для получения дополнительной информациии касательно дополнительных функций смотри руководство. Для получения данных о производительности multi_index_container - смотрите презентацию.

P.S.: ... Нагло утянуто отсюда: BOOST C++: Multi_Index

Использование библиотеки boost::signals

2009-04-01T19:00:00.001+03:00

Нередко при проектировании систем возникают задачи следующего характера. В системе появляется сущность, являющаяся генератором (источником) некоторых событий. И есть ряд других сущностей, которые должны быть уведомлены о возникновении этих событий. Простейший пример – на некоторой интерфейсной форме есть кнопка, по клику на которой необходимо выполнить некоторый код. Кнопка – источник события. Класс формы – получатель уведомления о возникновении события и его обработчик. В книге «Паттерны проектирования» от GoF такое взаимодействие сущностей описано как паттерн «Команда» или «Действие». Непосредственной поддержки описанного механизма подписки-уведомления в языке С++ (в отличии от C#, например) нет. Но реализацию этого механизма можно найти в boost. А именно – в библиотеке boost::signal. Описанный простейший пример с кнопкой и формой будет выглядеть следующим образом:

#include <iostream>
#include <boost/signal.hpp>
#include <boost/bind.hpp>

 
//////////////////////////////////////////////////////////////////////////////////////////
// Класс кнопки
// Пример класса-источника событий
//////////////////////////////////////////////////////////////////////////////////////////
class SampleButton
{
public:
 // Метод, добавляющий новый обработчик события

 // h - функтор, реализующий обработчик
 void SetOnClick(boost::function<void()> h) 
 {
  // Присоединяем к событию новый обоаботчик

  m_OnClick.connect(h);
 }
 // Метод, инициирущий событие
 void FireOnClick() {m_OnClick();}

private:
 // Член данных, хранящий коллекцию обработчиков события OnClick
 boost::signal<void ()> m_OnClick;
};
 
//////////////////////////////////////////////////////////////////////////////////////////

// Класс формы
// Пример класса-обработчика событий
//////////////////////////////////////////////////////////////////////////////////////////
class SampleForm
{
public:
 // Конструктор
 SampleForm()

 {
  // Добавляем к каждой кнопке обработчики события OnClick
  m_Button1.SetOnClick(boost::bind(&SampleForm::Handler1, this));
  m_Button2.SetOnClick(boost::bind(&SampleForm::Handler2, this));
  m_Button3.SetOnClick(boost::bind(&SampleForm::Handler2, this));
  m_Button3.SetOnClick(boost::bind(&SampleForm::Handler1, this));
 }

 
 // Тестовый обработчик события
 void Handler1()
 {
  std::cout << "Handler 1 entered" << std::endl;
 }

 
 // Тестовый обработчик события
 void Handler2()
 {
  std::cout << "Handler 2 entered" << std::endl;
 }

 
 // Пример кнопок
 SampleButton m_Button1;
 SampleButton m_Button2;
 SampleButton m_Button3;
};
 
int main(int argc, char** argv)

{
 // Создаем форму
 SampleForm form;
 
 // Для каждой кнопки на форме инициируем событие OnClick
 form.m_Button1.FireOnClick();
 form.m_Button2.FireOnClick();
 form.m_Button3.FireOnClick();

 
 // Вывод на консоль следующий
 // Handler 1 entered
 // Handler 2 entered
 // Handler 2 entered
 // Handler 1 entered
 return 0;

}

Что, собственно, здесь происходит.

Объявляется член данных, описывающий событие. В этом примере это SampleButton::m_OnClick. Тип этого члена данных – boost::signal. Этот класс – шаблонный, и в качестве обязательного параметра принимает сигнатуру обработчика сигнала. В примере эта сигнатура – void (). Т. е. обработчик не принимает параметров и ничего не возвращает.
Реализуется метод, осуществляющий подписку на соответствующее событие. В примере – это метод AddOnClick. Подписка осуществляется с помощью метода signal::connect, в который передается обработчик, с которым необходимо связать событие.
Где-то в коде производится инициация события. В данном случае это делается в методе SampleButton::FireOnClick. Инициация события производится путем применения оператора () к члену данных, описывающего событие. В данном случае – к члену m_OnClick.

Класс boost::signal реализует концепцию функционального объекта, по этому для инициации события, как сказано выше, достаточно применить к этому классу оператор вызова функции. При этом аргументы, передаваемые при вызове, должны соответствовать сигнатуре, переданной в качестве параметра шаблона при объявлении соответствующего члена данных.

Как видно из примера, на одно событие можно назначить сразу несколько обработчиков. При этом (в простейшем случае) будут вызваны все назначенные обработчики. Правда, последовательность их вызова разработчиками библиотеки не гарантируется. Нередко для обозначения сущности, описывающей событие (члена данных m_OnClick) используется термин сигнал (signal). А для обозначения подписчиков на это событие – термин слот (slot). В частности, эта терминология используется в оригинальной документации на эту библиотеку.

Объявление объекта-сигнала

Объект-сигнал объявляется как экземпляр класса boost::signal<Sig, Comb, Group, GroupComp, SlotFn>. У этого шаблонного класса первый аргумент является обязательным, и определяет сигнатуру вызова сигнала. Оставшиеся – определяют некоторые аспекты поведения объекта-сигнала, о которых будет рассказано ниже. Примеры объявления объекта-сигнала:

boost::signal<void ()> sig; // Сигнал без аргументов, который ничего не возвращает
boost::signal<int ()>sig; // Сигнал без аргументов, возвращающий целое число

boost::signal(void (float, int)> sig; // Сигнал, принимающий два аргумента и ничего не возвращающий

и т. п. Сигнатура сигнала определяет сигнатуру слотов, которые могут быть присоединены к такому сигналу. Вообще говоря, в ряде случаев требуется точное соответствие сигнатур слотов сигнатуре сигнала.

В случае, если в сигнатуре сигнала указывается, что сигнал принимает параметры, то аргументы, переданные при инициации (вызове) сигнала передаются на вход каждому из слотов, присоединенных к сигналу. В случае, если указывается, что сигнал возвращает некое значение, то (в общем случае) возвращается значение, полученное в результате вызова последнего слота в цепочке. Но такое поведение по-умолчанию может быть изменено. Подробнее об этом – в разделе «комбинирование возвращаемых слотами возвращаемых значений».

Присоединение слотов

Слот может быть присоединен к сигналу с помощью метода connect. В общем случае этот метод принимает на вход один аргумент – сущность, реализующую концепцию функционального объекта. Таким образом, к слоту может быть присоединено все что угодно, если к этому примени оператор вызова функции с подходящей сигнатурой. В частности, это означает, что вместе с boost::signal может легко применяться такие компоненты boost, как boost::function и boost::bind.

Указание порядка вызова слотов

В случае простого присоединения нескольких слотов к сигналу библиотека, вообще говоря, не специфицирует, в каком порядке будут вызваны соответствующие слотам функции. Если все слоты присоединяются в одном месте, то порядок предсказать можно (вызываться они будут в порядке присоединения). Если же присоединение слотов «размазано по коду», то такое предсказание сделать гораздо сложнее. И, если порядок вызова слотов важен, то его надо специфицировать явно путем специальной формы вызова метода connect:

float foo(int, int)

{
 return 1.5;
}
 
int bar(float, float)
{
 return 2.5;

}
 
boost::signal<float (int, int)> test_sig;

В случае такого присоедининия слотов:

test_sig.connect(0, &foo);
test_sig.connect(1, &bar);
std::cout << test_sig(1.5, 2.5) << std::endl;

на экран будет выведено число 1.5. А в случае такого присоединения:

test_sig.connect(1, &foo);
test_sig.connect(0, &bar);
std::cout << test_sig(1.5, 2.5) << std::endl;

число 2.

Не сложно понять, что все дело в первом параметре метода connect. В общем случае – это целое число, задающее очередность вызова слотов при инициации сигнала. Но, вообще говоря, это может быть и совсем не целое число, а, например строка. Тип группирующего параметра а также способ их упорядочивания задаются третьим и четвертым шаблонным параметром класса signal (Group и GroupComp). По умолчанию это int и less<int> соответственно. Например:

boost::signal<float (int, int), boost::last_value<float>, std::string> test_sig;

 
test_sig.connect("aaa", &foo);
test_sig.connect("bbb", &bar);
std::cout << test_sig(1.5, 2.5) << std::endl;

Выведет на экран число 2.

У метода connect может быть еще один параметр (последний), определяющий место, куда помещается новый слот при присоединении. Варианты этого параметра – boost::signals::at_front (слот добавляется в начало списка) или boost::signals::at_back (слот добавляется в конец списка). По умолчанию этот параметр равен boost::signals::at_back, т. е. слоты добавляются в конец списка. Если добавляемый слот не содержит идентификатора группы, то (в зависимости от значения этого параметра) он добавляется либо в начало, либо в конец общего списка слотов. В случае указания идентификатора группы этот параметр определяет способ добавления слота в рамках других слотов с тем же идентификатором. Например:

boost::signal<float (int, int), boost::last_value<float>, std::string> test_sig;

 
test_sig.connect("aaa", &foo, boost::signals::at_front);
test_sig.connect("aaa", &bar, boost::signals::at_front);
std::cout << test_sig(1.5, 2.5) << std::endl;

Выведет на экран число 1.5.

P.S.: Нагло спёрто отсюда: [[doc:cpp:boost:signal]]

Использование boost::tokenizer

2009-04-01T18:40:00.001+03:00

Нередко в практике программистов встречаются задачи, когда нужно разобрать строку (как еще иногда говорят - распарсить). Решений этой задачи - множество. Это и простейший поиск очередного символа-разделителя, и регулярные выражения, и специальные алгоритмы (например, из коллекции boost::string_algo). Но иногда логика разбиения строки на части (т. е. логика разбора) может быть ну совсем уж специфичная. Или регулярное выражение получается очень уж навороченное. Или по каким-то причинам библиотека регулярных выражений (тот же boost::regex) неприменима. Тогда на помощь может придти boost::tokenizer.

Вот пример его использования:

#include <iostream>
#include <string>
#include <list>

#include <boost/tokenizer.hpp>
#include <boost/iostreams/device/file.hpp> // file_source
#include <boost/iostreams/stream.hpp>      // stream

int _tmain(int argc, _TCHAR* argv[])
{
    try
    {
        // определяем длиннючие типы
        typedef boost::iostreams::file_source file_device_type;
        typedef boost::iostreams::stream<file_device_type> stream_type;
        typedef boost::char_separator<char> token_func_type;
        typedef boost::tokenizer<token_func_type> tokenizer_type;
        typedef std::list<std::string> token_list_type;
        
        // открываем файл
        stream_type strm ( file_device_type("C:\\temp.txt", BOOST_IOS::out|BOOST_IOS::binary) );
        strm >> std::noskipws;
        
        // читаем его содержимое в буфер
        std::string buffer;
        std::copy (
            std::istream_iterator<char>(strm),
            std::istream_iterator<char>(),
            std::back_inserter<std::string>(buffer) );
    
        // разбиваем буфер на токены-слова
        // и помещаем их в список строк
        //boost::tokenizer<> tok(buffer);
        token_func_type sep(" \t\n");
        tokenizer_type tok(buffer, sep);
        token_list_type tokens_list;
        std::copy (
            tok.begin(),
            tok.end(),
            std::back_inserter<token_list_type>(tokens_list) );

        // выводим список на печать
        std::copy (
            tokens_list.begin(),
            tokens_list.end(),
            std::ostream_iterator<std::string>(std::cout, "\n") );
    }
    catch ( std::exception & exc )
    {
        std::cerr << "Exception: " << exc.what() << std::endl;
    }
    return 0;
}

Использование boost::lexical_cast

2009-04-01T18:20:00.001+03:00

Каждому в своей программисткой практике приходилось сталкиваться с ситуациями, когда необходимо было что-либо преобразовать из строки в, предположим, число, или обратно. В зависимости от того, что, куда и как преобразовывается, для этого можно применять sprintf/sscanf, _itoa/atoi (и другие функции из этой группы), strtoi, и т. п. Все эти методы по своему хороши, но для каждого варианта преобразования необходимо помнить - «а что лучше всего для этого преобразования подходит?»

Стандарт языка C/C++ предусматривает ряд средств для выполнения таких преобразований. Однако они различаются по простоте использования, расширяемости и безопасности.

К примеру, существует ряд ограничений для стандартной для языка C функции atoi:

Преобразование выполняется только в одном направлении: из текстовой формы во внутренний тип данных. Обратное преобразование с использованием стандартных функций C требует либо использования неудобной и не совсем безопасной функции sprintf, или потери платформонезависимости при использовании таких функций, как itoa.
Набор поддерживаемых типов является лишь подмножеством встроенных числовых типов, а именно int, long, и double.
Этот набор типов не может быть расширен однородным образом. К примеру, преобразование из строкового представления в complex или rational.

Стандартная функция C strtol имеет те же же основные ограничения, хотя предлагает более аккуратный контроль за процессом преобразования. Однако, в общем случае такой контроль или не требуется, или не используется. Семейство функций scanf предоставляет еще больший контроль, однако им не хватает надежности и простоты использования.

Стандартная библиотека языка C++ содержит stringstream как возможную основу для обсуждаемого форматирования с преобразованием. Она предлагает удобный набор средств для контроля за форматированием и преобразованием I/O из и в произвольный тип через текст. Для простых преобразований непосредственное использование stringstream может быть неудобным (или введения дополнительных локальных переменных и невозможности использования удобной инфиксной формы выражений) или неочевидным и туманным (когда объекты типа stringstream создаются как временные объекты в выражении). Локаль (facets) содержит приемлемый набор средств для контроля за представлением в текстовом виде, однако сложность кода приводит к тому, что использовать эти средства удобно только небольшму количеству программистов.

Шаблон функции lexical_cast предлагает удобный и целостный подход для поддержки распространенных преобразований в и из произвольных типов, когда они представлены в виде текста. Предлагаемое ей упрощение заключается в использовании удобстве применения в выражениях. Для более сложных преобразований, когда, к примеру, требуется контролировать точность, вместо lexical_cast лучше использовать удобный подход stringstream. Для преобразования одного числа в другое вместо lexical_cast рекомендуется использовать numeric_cast.

Детальное обсуждение всех опций и вопросов, возникающих при форматировании строк, включая сравнение stringstream, lexical_cast, и других средств, можно найти в статье Херба Саттера (Herb Sutter) The String Formatters of Manor Farm.

boost::lexical_cast позволяет снять эту проблему. Для его использования достаточно знать - какой тип в какой вы ходите преобразовать. И все. Например:

// преобразует целое в строку
std::string str = boost::lexical_cast<std::string>(10);

// строку в целое
int value = boost::lexical_cast<int>("10");
// преобразует пару целых в экземпляр класса Point
Point pt = boost::lexical_cast<Point>("10, 20");

// обратное преобразование
std::wstring wstr = boost::lexical_cast<std::wstring>(pt);

// и т. д.

Достаточно удобно, не правда ли?

Принципы работы.

Принцип работы boost::lexical_cast очень прост. Для преобразования он использует строковый поток (std::strstream), выводя (с помощью оператора «) в него преобразуемое значние, после чего читая из него значение типа, в который делается преобразование. Т. е. вызов boost::lexical_cast эквивалентен:

// положим, что from_val и to_val - это, соответственно преобразуемое

// значение и приемник результата преобразования
std::ostringstream o_str;
o_str << from_val
std::istringstream i_str(o_str.str());
i_str >> to_val;

Из этого становится очевидным, что для корректного выполнения преобразования необходимо (и достаточно) наличия для преобразуемого типа перегруженного оператора вывода в поток и/или чтения из потока. Для всех примитивных типов такие операторы реализованы в библиотеке STL, а для «пользовательских» типов такой оператор может написать сам разработчик.

Краткое описание

Определенные в хидере "boost/lexical_cast.hpp" части библиотеки:

namespace boost
{
    class bad_lexical_cast;
    template <typename Target, typename Source>
      Target lexical_cast(Source arg);
}

Тестовая программа - в файле lexical_cast_test.cpp.

lexical_cast

template <typename Target, typename Source>
  Target lexical_cast(Source arg);

Функция возвращает результат передачи значение arg в стандартный строковый поток и обратного преобразования в объект типа Target. Когда тип Target это std::string или std::wstring, извлечение из потока получает полное содержимое строки, включая пробелы, вместо того, чтобы использовать operator>> по умолчанию. Если преобразование дает ошибку, то генерируется исключение bad_lexical_cast.

Требования к аргументу и возвращаемому значению:

Source является OutputStreamable, что значает, что определен operator<<, который получает объект типа std::ostream или std::wostream слева и объект типа аргумента справа.

Target является InputStreamable, что означает, что определен operator>>, который берет объект типа std::istream или std::wistream слева (left hand side) и объект возвращаемого типа справа.

Source и Target следуют парадигме CopyConstructible [20.1.3].

Target следует парадигме DefaultConstructible, что означает, что возможна инифиализация по умолчанию объекта этого типа [8.5, 20.1.4].

Символьный тип используемого потока должен быть char, если только Source или Target не требуют использования потоков с wchar_t. Типы Source, которые требую использования wchar_t-потоков это wchar_t, wchar_t *, и std::wstring. Типы Target, которые требуют использования wchar_t-потоков это wchar_t и std::wstring.

Если требуется более высокий уровень контроля за преобразованием, лучше использовать std::stringstream и std::wstringstream. Когда требуется выполнить преобразования без использования потоков, lexical_cast является неподходящим средством.

bad_lexical_cast

class bad_lexical_cast : public std::bad_cast
{
{
public:
    ... // same member function interface as std::exception
};

Для сообщений об ошибках преобразования в lexical_cast используется генерация исключений.

Недостатки

Но не смотря на свою красоту, универсальность и соответствие общепринятым стандартам преобразования, у boost::lexical_cast есть и следущие недостатки:

Низкая скорость работы. По тестам, проведенным Гербом Саттером, результаты которых он описал в своих «Новых сложных задачах на С++», boost::lexical_cast работает на порядок медленнее, чем тот же sprintf.
При преобразованиях нельзя специфицировать формат желаемой или исходной строки. Т. е. преобразования выполняются в соответствии со стандартными настройками потоков.
(для компилятора Visual C++) нельзя (без дополнительных телодвижений) выполнять преобразования в std::wstring/wchar_t*, если в настройках проекта не указано, что wchar_t считается встроенным типом.
приведение в тип double из строкового типа, возможно лишь в том случае если в качестве разделителя (дробной части от целой) используется точка.

Достоинства

Два из трех указанных выше недостатков достаточно легко обходятся. Поскольку boost::lexical_cast - это шаблон, то достаточно несложно написать необходимую специализацию, выполняющую преобразование настолько быстро, насколько это необходимо разработчику, а также учитывающую особенности типа wchar_t в VC++.

Изменения

Предыдущая версия шаблона lexical_cast использовала установки точности в потоках по умолчанию для чтения и записи чисел с плавающей запятой. Для числовых типов есть соответствующая специализация в std::numeric_limits, а текущая версия шаблона преобразования соответствующую точность.
Предыдущая версия шаблона lexical_cast не поддерживала преобразование в или из типов на основе wchar_t. Для компиляторов, которые имеют полную поддержку для wchar_t, lexical_cast теперь поддерживает преобразование из wchar_t, wchar_t *, и std::wstring и в wchar_t и std::wstring.
Предыдущая версия шаблона exical_cast основывалась на предположении, что обычные операторы извлечения из потока (stream extractor operators) достаточны для чтения значений. Однако, строковый ввод/вывод асимметричен, так как пробелы играют роль разделителей, а не входят в состав строк. Текущая версия исправляет эту ошибку для std::string и, где возможно, std::wstring: lexical_cast<std::string>("Hello, World") выполняется успешно вместо ошибки с генерацией исключения bad_lexical_cast.
Предыдущая версия шаблона lexical_cast допускала небезопасное и бессмысленное преобразование к указателям. Текущая версия генерирует исключение bad_lexical_cast для преобразований в указатель: lexical_cast<char*>("Goodbye, World") генерирует исключение вместо неопределенного поведения в предыдущей версии.

Пример использования.

Следующий пример преобразует аргументы командной строки в последовательность чисел:

int main(int argc, char * argv[])
{
    using boost::lexical_cast;
    using boost::bad_lexical_cast;

    std::vector<short> args;

    while(*++argv)
    {
        try
        {
            args.push_back(lexical_cast<short>(*argv));
        }
        catch(bad_lexical_cast &)
        {
            args.push_back(0);
        }
    }
    ...
}

Приведенный далее пример использует числовые величины в строковой выражении:

void log_message(const std::string &);

void log_errno(int yoko)
{
    log_message("Error " + boost::lexical_cast<std::string>(yoko) + ": " + strerror(yoko));
}

Приведенный далее пример переводит числовые величины в строковое представление:

#include <string>
#include <iostream>
#include <boost/lexical_cast.hpp>

int _tmain(int argc, _TCHAR* argv[])
{
    try {
        int a(41);
        std::string b;
        b = boost::lexical_cast<std::string>(a);
        std::cout << b << std::endl;
    }
    catch (const std::exception& exc)
    {
        std::cout << exc.what() << std::endl;
    }
    return 0;
}

P.S.: Нагло спёрто отсюда [[doc:cpp:boost:lexical_cast]] и отсюда библиотека преобразований - хидер boost/lexical_cast.hpp

P.P.S.: Об эффективности boost::lexical_cast<> можно прочитать здесь: http://www.rsdn.ru/forum/flame.comp/2986431.flat.1.aspx

Использование Boost.Regex

2009-04-01T18:00:00.002+03:00

В данной статье рассматриваются следующие вопросы касательно регулярных выражений:

regex_match
regex_search
regex_replace
regex_iterator
regex_token_iterator
Partial match

Введение

Я не хочу вступать в полемику по поводу нужности или не нужности регулярных выражений, каждый для себя решает сам. Моей целью было донести простоту использования Boost.Regex для тех, кому нравится использовать регулярные выражения. Для тех кому регулярные выражения не знакомы я советую прочесть хотя бы Википедию, а если кто-то хочет поглубже с ними познакомится, то я бы посоветовал Mastering regular expressions.
Boost.Regex является собираемой библиотекой, т.е для ее использования необходимо ее собрать. Как это сделать написано в Getting started.
Собирая библиотек вы можете выбрать один из двух алгоритмов, которые будет использоваться в движке регулирных выражений: рекурсивный и не-рекурсивный. Первый быстрый, но может грозить переполнением стека, второй немного медленней, но безопасный. Макросы для определения разных способов BOOST_REGEX_RECURSIVE и BOOST_REGEX_NON_RECURSIVE соответственно. Так же, каждый алгоритм может быть немного настроен. Макросы для настройки и их описание можно посмотреть Здесь
Boost.Regex поддерживает следующие типы синтаксисов для регулярных выражений:

Необходимо учесть, что '.'(точка) по умолчанию включает в себя '\n'. Это может быть изменено передачей специального флага, в соответствующий алгоритм.

Основные алгоритмы

boost::regex_match

Данный алгоритм используется для проверки соответсвия входящей строки и некоторого регулярного выражения, возвращая true Если строка соответсвует и false в другом случае.
Типичный способ использования: regex_match(входящая_строка, [результаты_нахождения_соответствий], регулярное_выражение, [флаги]).
Полный список всех перегруженных объявлений смотри в документации.
Пример его использования:

std::string xStr("AAAA-12222-BBBBB-44455"); boost::regex xRegEx("(\\w+)-(\\d+)-(\\w+)-(\\d+)"); boost::smatch xResults; std::cout << "==========================Results============================== \n"; std::cout << "Does this line match our needs? " << std::boolalpha << boost::regex_match(xStr, xResults, xRegEx) << "\n"; std::cout << "Print entire match:\n " << xResults[0] << std::endl; std::cout << "Print the former string into another format:\n" << xResults[1] << "+" << xResults[2] << "+" << xResults[3] << "+" << xResults[4] << std::endl; * This source code was highlighted with Source Code Highlighter.

Результатом работы будет:

==========================Results==============================
Does this line match our needs? true
Print entire match:
AAAA-12222-BBBBB-44455
Print the former string into another format:
AAAA+12222+BBBBB+44455

Небольшое отступление от алгоритма, для описания его параметров. Эти параметры используются во всех алгоритмах, но рассмотрим их только здесь.

результаты_нахождения_соответствий — является опциональным параметром и есть ни что иное, как объект класса match_results. Этот объект является массивом объектов класса sub_match, который в свою очередь, не более чем объект-хранитель итераторов на начало и конец найденного соответсвия в строке. результаты_нахождения_соответствий служит для сохранения результатов работы алгоритма. Так, если алгоритм был выполнен успешно, то нулевой член массива будет хранить sub_match для всего найденного соответствия(исключение состовляет использование partial match, но об этом позже). Каждый последующий член массива будет хранить итераторы на каждый capture содержащийся в регулярном выражении. Каждый элемент массива может быть проверен на наличие контента через флаг matched. Важно помнить, что каждый sub_match хранит итераторы на входящую_строку, поэтому нельзя передавать в качестве исходной строки временный объект и в дальнейшем использовать результаты алгоритма, в лучшем случае получите assert в дебаге, в худшем undefined behavior с головной болью. При рекурсивном capture в регулярном выражении(например "(\w)+")) в результирующий match_result попадет только последний capture, это поведение по умолчание, которое можно изменить. Чтобы мы могли получить доступ ко всем рекурсивным capture, мы должны передать флаг match_extra в [флаги], но это еще не все, для того, чтобы match_extra сработал, необходим объявить дефайн BOOST_REGEX_MATCH_EXTRA во всех транслируемых юнитах. Или просто раскомментировать define в boost/regex/user.hpp. Это функциональность помечена как эксперементальная и сильно уменьшающая производительность. У меня так и не получилось ее опробовать, т.к моя VS2008 выдает Access violation в недрах xutulity при попытке использования алгоритмов regex_* с раскомментированным дефайном. Не протестированный пример ее использования:

std::string xStr("The boost library has a great opportunity for the regex!"); boost::regex xRegEx("(\\b\\w{5}\\b)*"); boost::smatch xResults; std::cout << "==========================Results============================== \n"; if( boost::regex_search(xStr, xResults, xRegEx, boost::match_extra) ) { std::cout << "Words consist from exact 5 digits have been found in our line:\n"; for(int j = 0; j < xResults.captures(1).size(); ++j) std::cout << xResults.captures(1)[j] << std::endl; } * This source code was highlighted with Source Code Highlighter.

[Флаги] — необязательный параметр, с дефолтовым значением match_default. Про доступные флаги, можно посмотреть здесь. Флаги комбинируются посредством '|'(or).

Partial match

Частичное соответсвие необходимо для проверки входной строки, на частичное соответсвие регулярному выражению. Это может быть полезным при валидации поступающих асинхронно данных или при больших объемах данных, т.е в тех случаях когда в конкретный момент времени нет возможности провести полное соответсвие между регулярным выражением и исходной строкой. Чтобы использовать partial match, необходимо передать флаг match_partial в [флаги]. При этом, если используется частичное соответствие, то используемый алгоритм(regex_match, regex_search etc.) вернет true, но флаг matched у нулевого элеменат match_results будет уставновлен в false. То, что было найдено в результате частичного соответствия, можно получить через этот же нулевой элемент.
Пример использования:

std::string xStr("AAAA-12222"); boost::regex xRegEx("(\\w+)-(\\d+)-(\\w+)-(\\d+)"); boost::smatch xResults; std::cout << "==========================Results============================== \n"; std::cout << "Does this line match the regex? " << std::boolalpha << boost::regex_match(xStr, xResults, xRegEx, boost::match_default | boost::match_partial) << "\n"; std::cout << "Is it the partial match? " << std::boolalpha << !xResults[0].matched << "\nPrint the partial match:\n" << xResults[0] << std::endl; * This source code was highlighted with Source Code Highlighter.

Вывод:

==========================Results==============================
Does this line match the regex? true
Is it the partial match? true
Print the partial match:
AAAA-12222

regex_search

Данный алгоритм предназначен для поиска подстроки в исходной строке, по заданному регулярному выражению.
Формат использования выглядит следующим образом:
regex_search(входящая_строка, [результаты_нахождения_соответствий], регулярное_выражение, [флаги]).
Пример использования:

std::string xStr("The boost library has a great opportunity for the regex!"); boost::regex xRegEx("\\b(?:\\w+?)((\\w)\\2)(?:\\w+?)\\b"); boost::smatch xResults; std::cout << "==========================Results============================== \n"; std::string::const_iterator xItStart = xStr.begin(); std::string::const_iterator xItEnd = xStr.end(); while( boost::regex_search(xItStart, xItEnd, xResults, xRegEx) ) { std::cout << "Word, we've searched, is \"" << xResults[0] << "\". It has two \"" << xResults[2] << "\" inside itself.\n"; xItStart = xResults[1].second; } * This source code was highlighted with Source Code Highlighter.

Вывод:

==========================Results==============================
Word, we've searched, is «boost». It has two «o» inside itself.
Word, we've searched, is «opportunity». It has two «p» inside itself.

regex_replace

Алгоритм используется для замены всех вхождений подстрок, соответсвующих регулярному выражению, на строку заданному в определенном формате. Результат может быть получен через итератор, переданный в качестве аргумента либо как возращаемая строка. Части сроки которые не соответствуют регулярному выражению, копируются в выходнуб строку не измененными, если не задан флаг format_no_copy, который оставляет только заматченные строки в результате. При переданном флаге format_first_only, заменяется только первая подстрока, соответствующая регулярному выражению.
Типично используемый формат:
regex_replace(входящая_строка, регулярное_выражение, форматная_строка, [флаги]).
форматная_строка определяет строку, на которую будет заменятся найденная подстрока.
Она может подчинятся одному из следующих правил синтаксиса:

sed флаг:format_sed
Perl(по умолчанию) флаг:format_perl
Boost-extended флаг:format_all
Литеральный, т.е не использует никаких специальных символов. Флаг:format_literal

Пример использования:

std::string xStr("AAAA-12222-BBBBB-44455"); boost::regex xRegEx("(\\w+)-(\\d+)-(\\w+)-(\\d+)"); std::string xFormatString("$1*$2*$3*$4"); boost::smatch xResults; std::cout << "==========================Results============================== \n"; std::cout << "Print string after replace:\n " << boost::regex_replace(xStr, xRegEx, xFormatString, boost::match_default | boost::format_perl) << std::endl; * This source code was highlighted with Source Code Highlighter.

Вывод:

==========================Results==============================
Print string after replace:
AAAA*12222*BBBBB*44455

Вспомогательные средства

regex_iterator

Данный итератор может быть удобен для последовательного поиска вхождений подстроки, соответствующей регулярному выражению. При каждом инкрементировании находится следующая подстрока, с помощью regex_search. При разыменовывании итератора мы получаем объект типа match_results, с помощью которого мы можем получить всю необходимую информацию.
Формат использования: regex_iterator(начальный_итератор, конечный _итератор, регулярное_выражение)
Пример использования:

std::string xStr("AAAA-12222-BBBBB-44455"); boost::regex xRegEx("(\\w|\\d)+"); boost::smatch xResults; std::cout << "==========================Results============================== \n"; boost::sregex_iterator xIt(xStr.begin(), xStr.end(), xRegEx); boost::sregex_iterator xInvalidIt; while(xIt != xInvalidIt) std::cout << *xIt++ << "*"; * This source code was highlighted with Source Code Highlighter.

Вывод:

==========================Results==============================
AAAA*12222*BBBBB*44455*

regex_token_iterator

Очень полезный интрумент для разбиаения строки на токены,
Формат использования: regex_token_iterator(начальный_итератор, конечный _итератор, регулярное_выражение, [submatch])
[submatch] используется для указания, как следует интерпретировать токены в строке.
При -1 итератор возвращает часть последовательности, которая не соответствует регулярному выражению. Т.е возвращается либо строка, которая идет после первого совпадения, до начала следующего совпадения(не включая первый символ совпадения). Либо, с начала строки, если начала строки не удовлетворяет регулярному выражению. Т.е при передаче -1, регулярное выражения является разделителем. При 0, каждое смещение итератора(++) дает следующую часть строки которая была “заматчена“, т.е каждый разыменованный итератор является capture строки. При любом положительном числе, в качестве параметра, выбирается capture регулярного выражения соответствующий числу, переданному в качестве параметра. Так же можно передать массив индексов в качестве параметра, тогда итератор будет искать каждый capture согласно индексам в массиве, т.е если массив состоит из {4, 2, 1}, тогда начальный итератор будет указывать на 4 capture, следующий итератор на 2 и т.д. Процесс будет повторятся для всей последовательности, пока не закончатся соответствия для данного регулярного выражения. По дефолту это параметр равен 0.
Разыменованный итератор является объектом класса sub_match.
Примеры использования:

std::string xStr("AAAA-12222-BBBBB-44455"); boost::regex xRegEx("(\\w|\\d)+"); boost::smatch xResults; std::cout << "==========================Results============================== \n"; boost::sregex_token_iterator xItFull(xStr.begin(), xStr.end(), xRegEx, 0); boost::sregex_token_iterator xInvalidIt; std::cout << "Result the same as the regex_iterator: \n"; while(xItFull != xInvalidIt) std::cout << *xItFull++ << "*"; //Parts of captures boost::regex xRegEx2("(\\w+)-(\\d+)"); boost::sregex_token_iterator xItFirstCapture(xStr.begin(), xStr.end(), xRegEx2, 1); std::cout << "\nShow only first captures: \n"; while(xItFirstCapture != xInvalidIt) std::cout << *xItFirstCapture++ << "*"; //Reverse order int aIndices[] = {2,1}; boost::sregex_token_iterator xItReverseCapture(xStr.begin(), xStr.end(), xRegEx2, aIndices); std::cout << "\nShow captures in the reverse order: \n"; while(xItReverseCapture != xInvalidIt) std::cout << *xItReverseCapture++ << "*"; //Delimiters boost::regex xRegEx3("(\\w|\\d)+"); boost::sregex_token_iterator xItDelimiters(xStr.begin(), xStr.end(), xRegEx3, -1); std::cout << "\nShow delimiters: \n"; while(xItDelimiters != xInvalidIt) std::cout << *xItDelimiters++ << " "; * This source code was highlighted with Source Code Highlighter.

Вывод:

==========================Results==============================
Result the same as the regex_iterator:
AAAA*12222*BBBBB*44455*
Show only first captures:
AAAA*BBBBB*
Show captures in the reverse order:
12222*AAAA*44455*BBBBB*
Show delimiters:
— — -

Замечание

Любой алгоритм может выбросить исключение типа std::runtime_error в случае если сложность проверки полного соответствия(matching) N элементов начнет превышать О(N^2) или в случае переполнения стека(если Boost.Regex был собран в рекурсивном режиме)

_________

P.S.: ... наглым и безобразным образом утянуто отсюда: Boost это просто. Часть 1. Boost.Regex

P.S.: ... также о boost::regex можно прочитать здесь: BOOST C++: библиотека Regex - регулярные выражения

Сборка библиотеки LibTorrent

2009-04-01T16:00:00.002+03:00

Скачать либу здесь или здесь
Уже должны быть собраны Boost и OpenSSL

прочитайте прежде статью: Development Environment Settings

Сборка с помощью Visual Studio 2005

cd "%LIBRARIES_ROOT%libtorrent"

set INCLUDE=%BOOST_ROOT%;%LIBRARIES_ROOT%\libtorrent;%LIBRARIES_ROOT%\openssl\include;
CALL "C:\Program Files\Microsoft Visual Studio 8\Common7\Tools\VSVARS32.BAT"
%LIBRARIES_ROOT%boost-jam-3.1.17\bin.ntx86\bjam --v2 toolset=msvc-8.0 link=static debug logging=none dht-support=on runtime-link=static asynch-exceptions=on character-set=unicode openssl=pe

set INCLUDE=%BOOST_ROOT%;%LIBRARIES_ROOT%\libtorrent;%LIBRARIES_ROOT%\openssl\include;
CALL "C:\Program Files\Microsoft Visual Studio 8\Common7\Tools\VSVARS32.BAT"
%LIBRARIES_ROOT%boost-jam-3.1.17\bin.ntx86\bjam --v2 toolset=msvc-8.0 link=static release logging=none dht-support=on runtime-link=static asynch-exceptions=on character-set=unicode openssl=pe

set INCLUDE=%BOOST_ROOT%;%LIBRARIES_ROOT%\libtorrent;%LIBRARIES_ROOT%\openssl\include;
CALL "C:\Program Files\Microsoft Visual Studio 8\Common7\Tools\VSVARS32.BAT"
%LIBRARIES_ROOT%boost-jam-3.1.17\bin.ntx86\bjam --v2 toolset=msvc-8.0 link=static debug logging=none dht-support=on runtime-link=static asynch-exceptions=off character-set=unicode openssl=pe

set INCLUDE=%BOOST_ROOT%;%LIBRARIES_ROOT%\libtorrent;%LIBRARIES_ROOT%\openssl\include;
CALL "C:\Program Files\Microsoft Visual Studio 8\Common7\Tools\VSVARS32.BAT"
%LIBRARIES_ROOT%boost-jam-3.1.17\bin.ntx86\bjam --v2 toolset=msvc-8.0 link=static release logging=none dht-support=on runtime-link=static asynch-exceptions=off character-set=unicode openssl=pe

set INCLUDE=%BOOST_ROOT%;%LIBRARIES_ROOT%\libtorrent;%LIBRARIES_ROOT%\openssl\include;
CALL "C:\Program Files\Microsoft Visual Studio 8\Common7\Tools\VSVARS32.BAT"
%LIBRARIES_ROOT%boost-jam-3.1.17\bin.ntx86\bjam --v2 toolset=msvc-8.0 link=static debug logging=none dht-support=on runtime-link=shared asynch-exceptions=on character-set=unicode openssl=pe

set INCLUDE=%BOOST_ROOT%;%LIBRARIES_ROOT%\libtorrent;%LIBRARIES_ROOT%\openssl\include;
CALL "C:\Program Files\Microsoft Visual Studio 8\Common7\Tools\VSVARS32.BAT"
%LIBRARIES_ROOT%boost-jam-3.1.17\bin.ntx86\bjam --v2 toolset=msvc-8.0 link=static release logging=none dht-support=on runtime-link=shared asynch-exceptions=on character-set=unicode openssl=pe

set INCLUDE=%BOOST_ROOT%;%LIBRARIES_ROOT%\libtorrent;%LIBRARIES_ROOT%\openssl\include;
CALL "C:\Program Files\Microsoft Visual Studio 8\Common7\Tools\VSVARS32.BAT"
%LIBRARIES_ROOT%boost-jam-3.1.17\bin.ntx86\bjam --v2 toolset=msvc-8.0 link=static debug logging=none dht-support=on runtime-link=shared asynch-exceptions=off character-set=unicode openssl=pe

set INCLUDE=%BOOST_ROOT%;%LIBRARIES_ROOT%\libtorrent;%LIBRARIES_ROOT%\openssl\include;
CALL "C:\Program Files\Microsoft Visual Studio 8\Common7\Tools\VSVARS32.BAT"
%LIBRARIES_ROOT%boost-jam-3.1.17\bin.ntx86\bjam --v2 toolset=msvc-8.0 link=static release logging=none dht-support=on runtime-link=shared asynch-exceptions=off character-set=unicode openssl=pe

Сборка с помощью Visual Studio 2008

set INCLUDE=%BOOST_ROOT%;%LIBRARIES_ROOT%\libtorrent;%LIBRARIES_ROOT%\openssl\include;
CALL "C:\Program Files\Microsoft Visual Studio 9.0\Common7\Tools\VSVARS32.BAT"
%LIBRARIES_ROOT%boost-jam-3.1.17\bin.ntx86\bjam --v2 toolset=msvc-9.0 link=static debug logging=none dht-support=on runtime-link=static asynch-exceptions=on character-set=unicode openssl=pe

set INCLUDE=%BOOST_ROOT%;%LIBRARIES_ROOT%\libtorrent;%LIBRARIES_ROOT%\openssl\include;
CALL "C:\Program Files\Microsoft Visual Studio 9.0\Common7\Tools\VSVARS32.BAT"
%LIBRARIES_ROOT%boost-jam-3.1.17\bin.ntx86\bjam --v2 toolset=msvc-9.0 link=static release logging=none dht-support=on runtime-link=static asynch-exceptions=on character-set=unicode openssl=pe

set INCLUDE=%BOOST_ROOT%;%LIBRARIES_ROOT%\libtorrent;%LIBRARIES_ROOT%\openssl\include;
CALL "C:\Program Files\Microsoft Visual Studio 9.0\Common7\Tools\VSVARS32.BAT"
%LIBRARIES_ROOT%boost-jam-3.1.17\bin.ntx86\bjam --v2 toolset=msvc-9.0 link=static debug logging=none dht-support=on runtime-link=static asynch-exceptions=off character-set=unicode openssl=pe

set INCLUDE=%BOOST_ROOT%;%LIBRARIES_ROOT%\libtorrent;%LIBRARIES_ROOT%\openssl\include;
CALL "C:\Program Files\Microsoft Visual Studio 9.0\Common7\Tools\VSVARS32.BAT"
%LIBRARIES_ROOT%boost-jam-3.1.17\bin.ntx86\bjam --v2 toolset=msvc-9.0 link=static release logging=none dht-support=on runtime-link=static asynch-exceptions=off character-set=unicode openssl=pe

set INCLUDE=%BOOST_ROOT%;%LIBRARIES_ROOT%\libtorrent;%LIBRARIES_ROOT%\openssl\include;
CALL "C:\Program Files\Microsoft Visual Studio 9.0\Common7\Tools\VSVARS32.BAT"
%LIBRARIES_ROOT%boost-jam-3.1.17\bin.ntx86\bjam --v2 toolset=msvc-9.0 link=static debug logging=none dht-support=on runtime-link=shared asynch-exceptions=on character-set=unicode openssl=pe

set INCLUDE=%BOOST_ROOT%;%LIBRARIES_ROOT%\libtorrent;%LIBRARIES_ROOT%\openssl\include;
CALL "C:\Program Files\Microsoft Visual Studio 9.0\Common7\Tools\VSVARS32.BAT"
%LIBRARIES_ROOT%boost-jam-3.1.17\bin.ntx86\bjam --v2 toolset=msvc-9.0 link=static release logging=none dht-support=on runtime-link=shared asynch-exceptions=on character-set=unicode openssl=pe

set INCLUDE=%BOOST_ROOT%;%LIBRARIES_ROOT%\libtorrent;%LIBRARIES_ROOT%\openssl\include;
CALL "C:\Program Files\Microsoft Visual Studio 9.0\Common7\Tools\VSVARS32.BAT"
%LIBRARIES_ROOT%boost-jam-3.1.17\bin.ntx86\bjam --v2 toolset=msvc-9.0 link=static debug logging=none dht-support=on runtime-link=shared asynch-exceptions=off character-set=unicode openssl=pe

set INCLUDE=%BOOST_ROOT%;%LIBRARIES_ROOT%\libtorrent;%LIBRARIES_ROOT%\openssl\include;
CALL "C:\Program Files\Microsoft Visual Studio 9.0\Common7\Tools\VSVARS32.BAT"
%LIBRARIES_ROOT%boost-jam-3.1.17\bin.ntx86\bjam --v2 toolset=msvc-9.0 link=static release logging=none dht-support=on runtime-link=shared asynch-exceptions=off character-set=unicode openssl=pe

P.S.: Смотри также:
http://www.rsdn.ru/forum/network/3404574.flat.aspx#3404574
http://www.rsdn.ru/forum/dotnet/3404592.flat.aspx#3404592

Сборка библиотеки OpenSSL

2009-04-01T15:00:00.001+03:00

Скачать либу здесь : openssl-0.9.8j.tar.gz
Скачать Active Perl отсюда: http://www.softportal.com/get-70-activeperl.html
Установить Active Perl

Сборка с помощью Visual Studio 2005:

set OPTS=no-asm

perl Configure VC-WIN32
perl util\mkfiles.pl >MINFO
perl util\mk1mf.pl %OPTS% debug VC-WIN32 >d32.mak
perl util\mk1mf.pl %OPTS% VC-WIN32 >32.mak
perl util\mk1mf.pl %OPTS% debug dll VC-WIN32 >d32dll.mak
perl util\mk1mf.pl %OPTS% dll VC-WIN32 >32dll.mak
perl util\mkdef.pl 32 libeay > ms\libeay32.def
perl util\mkdef.pl 32 ssleay > ms\ssleay32.def

rem set PATH=%MSSDK6DIR%\VC\Bin;%PATH%
call "c:\Program Files\Microsoft Visual Studio 8\Common7\Tools\vsvars32.bat"

nmake -f d32.mak
@if errorlevel 1 goto end
nmake -f 32.mak
@if errorlevel 1 goto end
nmake -f d32dll.mak
@if errorlevel 1 goto end
nmake -f 32dll.mak

:end

Сборка с помощью Visual Studio 2008:

set OPTS=no-asm

perl Configure VC-WIN32
perl util\mkfiles.pl >MINFO
perl util\mk1mf.pl %OPTS% debug VC-WIN32 >d32.mak
perl util\mk1mf.pl %OPTS% VC-WIN32 >32.mak
perl util\mk1mf.pl %OPTS% debug dll VC-WIN32 >d32dll.mak
perl util\mk1mf.pl %OPTS% dll VC-WIN32 >32dll.mak
perl util\mkdef.pl 32 libeay > ms\libeay32.def
perl util\mkdef.pl 32 ssleay > ms\ssleay32.def

rem set PATH=%MSSDK6DIR%\VC\Bin;%PATH%
call "c:\Program Files\Microsoft Visual Studio 9.0\Common7\Tools\vsvars32.bat"

nmake -f d32.mak
@if errorlevel 1 goto end
nmake -f 32.mak
@if errorlevel 1 goto end
nmake -f d32dll.mak
@if errorlevel 1 goto end
nmake -f 32dll.mak

:end

Сборка с помощью Vista SDK

set OPTS=no-asm

perl Configure VC-WIN32
perl util\mkfiles.pl >MINFO
perl util\mk1mf.pl %OPTS% debug VC-WIN32 >d32.mak
perl util\mk1mf.pl %OPTS% VC-WIN32 >32.mak
perl util\mk1mf.pl %OPTS% debug dll VC-WIN32 >d32dll.mak
perl util\mk1mf.pl %OPTS% dll VC-WIN32 >32dll.mak
perl util\mkdef.pl 32 libeay > ms\libeay32.def
perl util\mkdef.pl 32 ssleay > ms\ssleay32.def

@SET VSINSTALLDIR=c:\Program Files\Microsoft Visual Studio 8
@SET VCINSTALLDIR=%VSINSTALLDIR%\VC
@SET FrameworkDir=c:\WINDOWS\Microsoft.NET\Framework
@SET FrameworkVersion=v2.0.50727
@SET FrameworkSDKDir=%VSINSTALLDIR%\SDK\v2.0
@set DevEnvDir=%VSINSTALLDIR%\Common7\IDE
@set PATH=%MSSDK6DIR%\VC\Bin;%VSINSTALLDIR%\Common7\IDE;%VCINSTALLDIR%\BIN;%VSINSTALLDIR%\Common7\Tools;%VSINSTALLDIR%\Common7\Tools\bin;%VCINSTALLDIR%\PlatformSDK\bin;%VSINSTALLDIR%\SDK\v2.0\bin;c:\WINDOWS\Microsoft.NET\Framework\v2.0.50727;%VCINSTALLDIR%\VCPackages;%PATH%
@set INCLUDE=%MSSDK6DIR%\Include;%MSSDK6DIR%\VC\INCLUDE;%VCINSTALLDIR%\ATLMFC\INCLUDE;%VCINSTALLDIR%\INCLUDE;%VCINSTALLDIR%\PlatformSDK\include;%VSINSTALLDIR%\SDK\v2.0\include;%INCLUDE%
@set LIB=%MSSDK6DIR%\Lib;%MSSDK6DIR%\VC\LIB;%VCINSTALLDIR%\ATLMFC\LIB;%VCINSTALLDIR%\LIB;%VCINSTALLDIR%\PlatformSDK\lib;%VSINSTALLDIR%\SDK\v2.0\lib;%LIB%
@set LIBPATH=c:\WINDOWS\Microsoft.NET\Framework\v2.0.50727;%VCINSTALLDIR%\ATLMFC\LIB

nmake -f d32.mak
@if errorlevel 1 goto end
nmake -f 32.mak
@if errorlevel 1 goto end
nmake -f d32dll.mak
@if errorlevel 1 goto end
nmake -f 32dll.mak

:end

Скрипт для инсталла:

set OPENSSL_ROOT=%~dp0
set TOOLSET=%1%

cd %OPENSSL_ROOT%
call :CreateDirectories
call :MoveOutFiles
call :RemoveOldDirectories
goto end

:CreateDirectories
mkdir lib
cd ./lib
mkdir %TOOLSET%
cd ./%TOOLSET%
mkdir debug
cd ./debug
mkdir shared
mkdir static
cd ..
mkdir release
cd ./release
mkdir shared
mkdir static
cd ..
exit /b

:MoveOutFiles
cd %OPENSSL_ROOT%
move %OPENSSL_ROOT%out32\* %OPENSSL_ROOT%lib\%TOOLSET%\release\static\
move %OPENSSL_ROOT%out32dll\* %OPENSSL_ROOT%lib\%TOOLSET%\release\shared\
move %OPENSSL_ROOT%out32.dbg\* %OPENSSL_ROOT%lib\%TOOLSET%\debug\static\
move %OPENSSL_ROOT%out32dll.dbg\* %OPENSSL_ROOT%lib\%TOOLSET%\debug\shared\
cd %OPENSSL_ROOT%
exit /b

:RemoveOldDirectories
del /S /Q %OPENSSL_ROOT%out32\*
del /S /Q %OPENSSL_ROOT%out32dll\*
del /S /Q %OPENSSL_ROOT%out32.dbg\*
del /S /Q %OPENSSL_ROOT%out32dll.dbg\*
del /S /Q %OPENSSL_ROOT%out32
del /S /Q %OPENSSL_ROOT%out32dll
del /S /Q %OPENSSL_ROOT%out32.dbg
del /S /Q %OPENSSL_ROOT%out32dll.dbg
del /S /Q %OPENSSL_ROOT%tmp32\*
del /S /Q %OPENSSL_ROOT%tmp32dll\*
del /S /Q %OPENSSL_ROOT%tmp32.dbg\*
del /S /Q %OPENSSL_ROOT%tmp32dll.dbg\*
del /S /Q %OPENSSL_ROOT%tmp32
del /S /Q %OPENSSL_ROOT%tmp32dll
del /S /Q %OPENSSL_ROOT%tmp32.dbg
del /S /Q %OPENSSL_ROOT%tmp32dll.dbg
exit /b

:end

P.S.: Возможно после конфигурации придётся слегуа поправить make-файлы, поскольку собирают они библиотеку не во всех возможных конфигурациях. Например когда собирается статическая версия OpenSSL, то с С++ CRT она линкуется статически, если же собирается динамическая версия OpenSSL, то она с С++ библиотекой линкуется динамически. Скажем если вы хотите собрать статическую версию OpenSSL, а запользовать её в проекте, линкующимся с CRT динамически, вот тогда и придётся править фалики.

Смотри также: Compiling OpenSSL for Windows, Linux, and Macintosh

Библиотека Boost

2009-04-01T14:00:00.004+03:00

Boost — собрание библиотек, расширяющих C++. Cвободно распространяются по лицензии Boost Software License вместе с исходным кодом. Проект был создан после принятия стандарта C++, когда многие были недовольны не включением в стандарт некоторых библиотек. Проект является своего рода «испытательным полигоном» для различных расширений языка и часть библиотек являются кандидатами на включение в следующий стандарт C++.

Boost имеет заметную направленность на исследования и расширяемость (метапрограммирование и обобщённое программирование с активным использованием шаблонов). Благодаря тщательному подбору и контролю качества, библиотеки, включённые в Boost, обладают высокой надёжностью и производительностью. У "велосипедов" из boost существует огромное количество пользователей - С++ разработчиков, поэтому код библиотек boost является очень хорошо протестирован и является очень надёжным.

Крайне рекомендую данную коллекцию библиотек всем C++ разработчикам для использования в своих проектах. Вместо написания собственных велосипедов, лучше загляните в boost, не присутствует ли там уже готовое решение, поскольку качество вашего велосипеда будет насравнимо ниже чем boost'овского аналога, потому что пользователем вашего вилосипеда будете только вы и оттестировать его во всех возможных случаях вы не сможете физически. Если вас не совсем устроит эффективность некоторых библиотек из boost (как например boost::lexical_cast), то не забывайте, что библиотеки boost чрезвычайно гибки и вы всегда можете расширить функциональность того или иного велосипеда с помощью C++ шаблонов (скажем, специализировать шаблон boost::lexical_cast<> для определённого типа), предоставив свою "эффективную реализацию".

Сборка библиотеки Boost

Качаем архив с исходными текстами здесь: http://www.boost.org/users/download/
Распаковываем архив в директорию %BOOST_ROOT% (см. статью Development Environment Settings).

Все что вам надо знать на первое время - это:

%BOOST_ROOT%\
|---- tools       - инструменты, в частности bjam
|---- boost       - заголовочные файлы boost
|---- libs        - документация
|---- lib   - динамические и статические библиотеки, появятся после сборки
|---- index.html  - начало знакомства с boost
...

Собираем bjam и настраиваем Boost.Build

Bjam - это мощная утилита, автоматизирующая процесс сборки. Boost.Build - это система сборки на базе bjam, набор скриптов для множества компиляторов, позволяет управлять ими через единый интерфейс. Т.е. вам не надо знать как, например, для gcc настроить precompiled headers…

Запускаем "%BOOST_ROOT%\tools\jam\build_dist.bat", который собирет bjam.exe

Теперь копируем bjam.exe из "%BOOST_ROOT%\tools\jam\stage\boost-jam-3.1.17-1-ntx86? в "%SystemRoot%\system32" или добавляем директорию "%BOOST_ROOT%\tools\jam\stage\boost-jam-3.1.17-1-ntx86" в системную переменную PATH. Что бы проверить, что все идет по плану - запускаем консоль и выполняем команду:

bjam.exe

В результате должны получить сообщение:

Unable to load Boost.Build: could not find "boost-build.jam"
---------------------------------------------------------------
Attempted search from C:\Documents and Settings\Tanya up to the root
and in these directories from BOOST_BUILD_PATH and BOOST_ROOT: D:\c++\libs\boost
_trunk\tools\build\v21, D:\c++\libs\boost_trunk1.
Please consult the documentation at 'http://www.boost.org'.

Boost.Build

BOOST_ROOT

Development Environment Settings

BOOST_BUILD_PATH

bjam.exe

Если вы получили следующее сообщение значит вы на правильном пути:

warning: No toolsets are configured.
warning: Configuring default toolset "msvc".
warning: If the default is wrong, your build may not work correctly.
warning: Use the "toolset=xxxxx" option to override our guess.
warning: For more configuration options, please consult
warning: http://boost.org/boost-build2/doc/html/bbv2/advanced/configuration.html

error: error: no Jamfile in current directory found, and no target references sp
ecified.

Завершающая стадия - компиляция boost.

Создаем %BOOST_ROOT%\build.bat с содержимым:

@echo off
bjam ^
    -j2 ^
    --toolset=msvc-8.0 ^
    release debug ^
    --without-math ^
    --without-graph ^
    --without-python ^
    threading=multi link=static link=shared runtime-link=static runtime-link=shared ^
   stage --stagedir="./lib";
   pause

-j2

--toolset=msvc-8.0

release debug

--without-math

--without-graph

--without-python

threading=multi link=static link=shared runtime-link=static runtime-link=shared

stage

Для использования boost в своих проектах, настраивайте конфигурацию проектов следующим образом:
Добавьте путь "$(BOOST_ROOT)" в список "Additional Include Directories" опций компиллятора.
Добавьте путь "$(BOOST_ROOT)\lib" в список "Additional Library Directories" опций линкера.
Многие добавляют эти пути в "Tools/Options/Projects and Solutions/VC++ Directories", однако я так не делаю, и вам не рекомендую, ибо "юзаю/неюзаю" boost есть свойство отдельно проекта, ну накрайняк solution'а, а никак не всей студии, ведь не все проекты, которые, возможно, у вас собираются, зависят от boost, соответсвенно нехрен всяким неандертальским проектам иметь видимость boost'овских заголовочных файлов.

Частично стянуто отсюда: http://www.gigamega.net/category/boost/

P.S.: Я Boost собираю следующим образом:

"bjam.exe" -j 12 --buid-dir="build" --build-type=complete --toolset=msvc-8.0 address-model=32  --stagedir="./lib" stage
"bjam.exe" -j 12 --buid-dir="build" --build-type=complete --toolset=msvc-9.0 address-model=32  --stagedir="./lib" stage

P.P.S.: Улыбнуло мнение, взятое отсюда: http://www.gigamega.net/category/boost/ :):) :
Некоторые C++ программисты используют boost, некоторые о нем только слышали, некоторые - нет. Так вот, последние 2 категории - тупиковая ветвь развития (о тех, кому не позволяет железо или компилятор я не говорю), как правило, такие люди даже не доросли до стандартной библиотеки, а их стиль программирования можно назвать “Си с классами”.

P.P.S.: Удачи вам в использовании Boost в ваших проектах!