Библиотека BOOST C++ - список компонентов

Работа со строками и текстом

Полноценное применение средств замечательной библиотеки BOOST требует профессионального  владения тонкостями языка C++

Полный справочник по C++: подробнее

Герберт Шилдт
Полный справочник по C++

Контейнеры

Итераторы

Алгоритмы

Функциональные объекты и адаптеры

Общее программирование

Шаблонное метапрограммирование

Препроцессорное метапрограммирование

Многопоточное программирование

Математические и числовые функции

Корректность и тестирование

Структуры данных

Ввод/вывод

Python

Работа с памятью

Прочее

Поддержка старых компиляторов

 

Примеры

lexical_cast:
short n = lexical_cast(*argv[1])
show_error("Error: "+lexical_cast(err))
format:
cout << format("(x,y) = (%+5d,%+5d) \n") % -23 % 35
regex:

Найти E-mail в строке и выделить имя пользователя и домен.

   using namespace std;
   using namespace boost;

   regex expression("([_a-zA-Z\\d\\-\\.]+)@([_a-zA-Z\\d\\-]+(\\.[_a-zA-Z\\d\\-]+)+)");
   string str("Мой E-mail: sem@ciam.ru. Задавайте любые вопросы.");
   cmatch what;

   if(regex_search(str, what, expression)) {
        string name,domain;
        name.assi gn(what[1].first, what[1].second);
        domain.assign(what[2].first, what[2].second);
        cout << "Имя: " << name;
        cout << ", домен: " << domain << endl;
   } else
        cout << "E-Mail в строке не найден" << endl;
Результат: Имя: sem, домен: ciam.ru

tokenizer:

   string s = "This is,  a test";
   tokenizer<> tok(s);
   for(tokenizer<>::iterator beg=tok.begin(); beg!=tok.end();++beg){
       cout << *beg << "\n";
   }
Результат:
This
is
a
test
xtime:
#include <boost/thread/thread.hpp>
#include <boost/thread/xtime.hpp>

using namespace boost;
int main(int argc, char* argv[])
{
   xtime xt;
   xtime_get(&xt, TIME_UTC);
   xt.sec += 1;
   thread::sleep(xt); // Sleep for 1 second
}
thread:
#include <boost/thread/thread.hpp>
#include <boost/thread/xtime.hpp>
#include <iostream>

using namespace std;
using namespace boost;

struct thread_alarm
{
   thread_alarm(int secs) : m_secs(secs) { }
   void operator()()
   {
       xtime xt;
       xtime_get(&xt, TIME_UTC);
       xt.sec += m_secs;

       thread::sleep(xt);

       cout << "alarm sounded..." << endl;
   }

   int m_secs;
};

int main(int argc, char* argv[])
{
   int secs = 5;
   cout << "setting alarm for 5 seconds..." << endl;
   thread_alarm alarm(secs);
   thread thrd(alarm);
   thrd.join();
}
mutex:
#include <boost/thread/mutex.hpp>
#include <boost/thread/thread.hpp>
#include <iostream>

using namespace std;
using namespace boost;

mutex io_mutex; // The iostreams are not guaranteed to be thread-safe!

class counter
{
    mutex mutex;
    int count;
public:
    counter() : count(0) { }

    int increment() {
        mutex::scoped_lock scoped_lock(mutex);
        return ++count;
    }
};

counter c;

void change_count()
{
    int i = c.increment();
    mutex::scoped_lock scoped_lock(io_mutex);
    cout << "count == " << i << endl;
}

int main(int, char*[])
{
    const int num_threads = 4;
    thread_group thrds;
    for (int i=0; i < num_threads; ++i)
        thrds.create_thread(&change_count);

    thrds.join_all();

    return 0;
}
condition:
#include <iostream>
#include <vector>
#include <boost/utility.hpp>
#include <boost/thread/condition.hpp>
#include <boost/thread/thread.hpp>

using namespace std;
using namespace boost;

class bounded_buffer : private noncopyable
{
public:
    typedef mutex::scoped_lock lock;

    bounded_buffer(int n) : begin(0), end(0), buffered(0), circular_buf(n) { }

    void send (int m) {
        lock lk(monitor);
        while (buffered == circular_buf.size())
            buffer_not_full.wait(lk);
        circular_buf[end] = m;
        end = (end+1) % circular_buf.size();
        ++buffered;
        buffer_not_empty.notify_one();
    }
    int receive() {
        lock lk(monitor);
        while (buffered == 0)
            buffer_not_empty.wait(lk);
        int i = circular_buf[begin];
        begin = (begin+1) % circular_buf.size();
        --buffered;
        buffer_not_full.notify_one();
        return i;
    }

private:
    int begin, end, buffered;
    vector circular_buf;
    condition buffer_not_full, buffer_not_empty;
    mutex monitor;
};

bounded_buffer buf(12);

void sender() {
    int n = 0;
    while (n < 100) {
       buf.send(n);
       cout << "sent: " << n << endl;
       ++n;
    }
    buf.send(-1);
}

void receiver() {
    int n;
    do {
       n = buf.receive();
       cout << "received: " << n << endl;
    } while (n != -1); // -1 indicates end of buffer
}

int main(int, char*[])
{
    thread thrd1(&sender);
    thread thrd2(&receiver);
    thrd1.join();
    thrd2.join();
    return 0;
}

Автором исходного варианта является Matveychuk Sergey
Последняя правка: 13.07.2005

библиотека BOOST C++ http://www.boost.org
перевод Elijah Koziev www.solarix.ru

  © Mental Computing 2010