filesystem linkleme

Şöyle yaparız.

g++ ... -lboost_system -lboost_filesystem

Şöyle yaparız

... -lboost_system-mt -lboost_filesystem-mt

multi_index hashed_unique Sınıfı

Giriş
Şu satırı dahil ederiz.

#include <boost/multi_index/hashed_index.hpp>

std::unordered_map gibidir. Şu satırı dahil ederiz.

namespace bi = boost::multi_index;

Tag + const_mem_fun - Üye Metod
Şu satırı dahil ederiz.

#include <boost/multi_index/key_extractors.hpp>

Şöyle yaparız.

boost::multi_index_container<
  Foo,
  bi::indexed_by<
    bi::hashed_unique<
      bi::tag<IndexByUniqueId>,
      bi::const_mem_fun<Foo, const std::string, &Foo::getName> 
    >
  >
> container;

mem_fun - Üye Metod
Şu satırı dahil ederiz.

#include <boost/multi_index/key_extractors.hpp>

Şöyle yaparız.

boost::multi_index_container<
  Foo,
  bi::indexed_by<    
    bi::hashed_unique<bi::mem_fun<Foo, std::string, &Foo::getName> >,
    bi::hashed_unique<bi::mem_fun<Foo, int, &Foo::getAge> >  > 
>;

Tag + member - Üye Alan

Şu satırı dahil ederiz.

#include <boost/multi_index/key_extractors.hpp>

veya şu satırı dahil ederiz.

#include <boost/multi_index/member.hpp>

Elimizde şöyle bir yapı olsun.

struct X
{
  long long l; // assume unique
  int i1; // assume unique
  int i2; // assume non-unique
  // plus any ohter data you have in your class X
};

Index'ler için tag'ler tanımlarız.

struct IndexByL {};
struct IndexByI1 {};
struct IndexByI2 {};

Şöyle yaparız.

using Container = boost::multi_index_container<
  X*, // the data type stored
  bi::indexed_by< // list of indexes
    bi::hashed_unique<  //hashed index over 'l'
      bi::tag<IndexByL>, // give that index a name
      bi::member<X, long long, &X::l> //index's key
    >,
    ...
  >
> container;

Composite Key İle Tanımlama

Şu satırı dahil ederiz.

#include <boost/multi_index/key_extractors.hpp>

veya şu satırları dahil ederiz.

#include <boost/multi_index/mem_fun.hpp>
#include <boost/multi_index/composite_key.hpp>

Şöyle yaparız.

boost::multi_index_container<
  MyClass,
  bi::indexed_by<
    bi::hashed_unique< bi::tag<struct hash> ,
      bi::composite_key< 
        MyClass,
        bi::const_mem_fun<MyClass,int,&MyClass::get_int >,
        bi::const_mem_fun<MyClass,const std::vector<int>&,&MyClass::get_vec >
      >
    >,
    ...
  >
> container;

Tag + identity
Şu satırı dahil ederiz.

#include <boost/multi_index/key_extractors.hpp>

veya su satırı dahil ederiz.

#include <boost/multi_index/identity.hpp>

Şöyle yaparız. Pointer için kullanılabilir.

typedef std::shared_ptr<Foo> FooPtr;

boost::multi_index_container<
  FooPtr,
  bi::indexed_by<
    bi::hashed_unique<
      bi::tag<struct ByPtr>
      bi::identity<FooPtr> 
    >
  >
> container;

iterator
Açıklaması şöyle. Yani iterator ile nesneyi değiştirmemeli. Container nesnesinin update metodları kullanılmalı.

The iterators provided by every index are constant, that is, the elements they point to cannot be mutated directly. This follows the interface of std::set for ordered indices but might come as a surprise for other types such as sequenced indices, which are modeled after std::list, where this limitation does not happen. This seemingly odd behavior is imposed by the way multi_index_containers work; if elements were allowed to be mutated indiscriminately, we could introduce inconsistencies in the ordered indices of the multi_index_container without the container being notified about it. Element modification is properly done by means of update operations on any index.

find metodu
Aynı bir std::unordered_map iterator gibi çalışır. Şöyle yaparız.

Foo foo = ..;
auto iterator = container.get<MyTag>().find (foo);
if (iterator != container.get<MyTag>().end())
  found(*iterator);
else
  notFound();

insert metodu

C++11 kullanmıyorsak indeksler için typedef yapmak iyi bir fikir.

typedef bi::index<my_list, hash>::type hashed_index;

Aşağıdaki kodda C++11 kullandığım için auto kelimesi ile iş kolayca halloluyor. Şöyle yaparız.

Container c;  // empty container
X x1{...};

// Insert some elements
auto& indexByL = c.get<IndexByL>();
indexByL.insert (&x1);

range algorithm

Giriş
Topluca kullanmak için şu satırı dahil ederiz.

#include <boost/range/algorithm.hpp>

max_element metodu
Şöyle yaparız.

int arr[] = {1, 2, 3, 4, 5, 6, 7};

auto str = std::make_pair(&arr[0], &arr[8]);
std::cout << *boost::range::max_element (str)

min_element metodu

Şöyle yaparız.

int arr[] = {1, 2, 3, 4, 5, 6, 7};

auto str = std::make_pair(&arr[0], &arr[8]);
std::cout << *boost::range::min_element (str)

remove_erase_if metodu
Şu satırı dahil ederiz.

#include <boost/range/algorithm_ext/erase.hpp>

Şöyle yaparız.

std::vector<Item> items;...

boost::range::remove_erase_if (items, [&](const Item& item)
{
  // do whatever else you want to item
  // return true to erase the item, or
  return false; // to keep it
});

STL'i kullanmaktan daha kolaydır.

items.erase(std::remove_if(items.begin(), items.end(),[&](const Item& i) {
  return false; // return true to erase the item
}), items.end());

integer

integer_mask
Giriş
Şu satırı dahil ederiz.

#include <boost/integer/integer_mask.hpp>

low_bits_mask_t
Şöyle yaparız.

uint mask =  boost::low_bits_mask_t<1>::sig_bits;

geometry exterior_ring metodu

Giriş
Şu satırı dahil ederiz.

#include <boost/geometry.hpp>

Polygon
Elimizde dolu bir polygon olsun

using PointType = boost::geometry::model::d2::point_xy <double>;
using PolygonType = boost::geometry::model::polygon <PointType>;

// Construct
PolygonType polygon;
...

Şöyle yaparız.

for(point_t p : boost::geometry::exterior_ring(poly_a)) {
  std::cout << "(" << boost::geometry::get<0>(p) << ", "
            << boost::geometry::get<1>(p) << ")" << std::endl;
}