logic

tribool Sınıfı
Şu satırı dahil ederiz.

#include "boost/logic/tribool.hpp"

Constructor
Şöyle yaparız.

boost::logic::tribool b;

operator bool metodu
Şöyle yaparız.

bool safe = b;  // no need to call anything, just let the conversion happen.

// or just:
if (b) { ... }

Şöyle yaparız.

if (boost::logic::indeterminate(b))
{
    std::cout << "indeterminate -> " << std::boolalpha << b << std::endl;
}
else if (b)
{
    std::cout << "true -> " << std::boolalpha << b << std::endl;
}
else if (!b)
{
    std::cout << "false -> " << std::boolalpha << b << std::endl;
}

operator = metodu
Şöyle yaparız.

b = true;

safe_bool metoud
İmzası şöyle. Bu bir conversion operator

BOOST_CONSTEXPR operator safe_bool() const noexcept;

Şöyle yapamayız.

bool safe = b.safe_bool(); <<---- error here

asio stream_protocol

Giriş
Şu satırı dahil ederiz.

#include <boost/asio.hpp>

Bu sınıf Linux'taki socketpair() ile aynıdır. fork() ile yapılan IPC için kullanılır.

Constructor
Şöyle yaparız.

using boost::asio::local::stream_protocol;

boost::asio::io_service ios;

stream_protocol::socket parentSocket(ios);
stream_protocol::socket childSocket(ios);

Kullanım
İki socket birbirine bağlanır. Şöyle yaparız.

//create socket pair
boost::asio::local::connect_pair(childSocket, parentSocket);

fork() çağrısı yapılır. Şöyle yaparız.

std::string request("Dad I am your child, hello!");
std::string dadRequest("Hello son!");

//Create child process
pid_t pid = fork();
if( pid < 0 ){
  std::cerr << "fork() erred\n";
} else if (pid == 0 ) { //child process
  parentSocket.close(); // no need of parents socket handle,
  boost::asio::write(childSocket, boost::asio::buffer(request)); //Send data

  std::vector<char> dadResponse(dadRequest.size(),0);
  boost::asio::read(childSocket, boost::asio::buffer(dadResponse)); //Wait

  std::cout << "Dads response: ";
  std::cout.write(&dadResponse[0], dadResponse.size());
  std::cout << std::endl;


} else { //parent
  childSocket.close(); //Close childSocket here use one bidirectional socket
  std::vector<char> reply(request.size());
  boost::asio::read(parentSocket, boost::asio::buffer(reply)); //Wait for child

  std::cout << "Child message: ";
  std::cout.write(&reply[0], request.size());
  std::cout << std::endl;

  sleep(5); //Add 5 seconds delay before sending response
  boost::asio::write(parentSocket, boost::asio::buffer(dadRequest)); //Send

}

geometry segment Sınıfı

Tanımlama
Şöyle yaparız.

namespace bg = boost::geometry;

typedef bg::model::d2::point_xy<int> Point;
typedef boost::geometry::model::segment<Point> Segment;
typedef boost::geometry::segment_view<Segment> SegmentView;

Constructor
Şöyle yaparız.

Segment seg;

algorithm

all_of metodu
Bu metod C++11'den itibaren mevcut. Eğer C++11 kullanıyorsak, boost gidip C++11 kodunu çağırır.
Şöyle yaparız.

bool all_ok =
 boost::algorithm::all_of(v.begin(), v.end(),(std::string &p){ return ...; });

for_each metodu
Şu satırı dahil ederiz.

#include <boost/range/algorithm/for_each.hpp>

std::vector<boost::fibers::fiber> myfibers(4);
...
boost::for_each(myfibers, [](boost::fibers::fiber& aFiber) {
  aFiber.join();
});

generate metodu
Şu satırı dahil ederiz.

#include <boost/range/algorithm/generate.hpp>

Şöyle yaparız.

boost::fibers::barrier barrier(2);
std::vector<boost::fibers::fiber> myfibers(4);
boost::generate(myfibers, [&barrier]() {
  return boost::fibers::fiber([](boost::fibers::barrier& barrier) {
    ...
  }, std::ref(barrier) );
});

serialization polymorphic_binary_oarchive Sınıfı

Giriş
Şu satırı dahil ederiz.

#include <boost/archive/polymorphic_binary_oarchive.hpp>

serialization polymorphic_binary_iarchive Sınıfı

Giriş
Şu satırı dahil ederiz.

#include <boost/archive/polymorphic_binary_iarchive.hpp>

log basic_formatter_factory

Tanımlama
Şöyle yaparız.

class ServerityFormatterFactory : public
  logging::basic_formatter_factory<char_t, logging::trivial::severity_level> {
  ...
};

Kullanmak için şöyle yaparız.

logging::register_formatter_factory(
  logging::aux::default_attribute_names::severity().string(),
   boost::make_shared<ServerityFormatterFactory>()
);

create_formatter metodu
Elimizde bir formatter olsun

class SeverityLevelFormatter {
private:
  mutable boost::format format_;

public:
  SeverityLevelFormatter(const std::string& format) : format_(format) {
  }

  void operator() (logging::formatting_ostream& strm,
    const logging::value_ref<logging::trivial::severity_level>& value) const {
    strm << boost::format(format_) % to_string(value.get());
  }
};

Şöyle yaparız.

formatter_type create_formatter(const logging::attribute_name& name,
                                const args_map& args) {
  auto it = args.find(L"format");
  if (it != args.end()) {
    return boost::phoenix::bind(SeverityLevelFormatter(it->second),
       expr::stream, expr::attr<logging::trivial::severity_level>(name));
  }
  else {
    return expr::stream << expr::attr<logging::trivial::severity_level>(name);
  }
}