program_options parse_command_line metodu

Giriş
Bu metodu kullanmak command_line_parser sınıfını kullanmaktan daha kolay.

po::parse_config_file() metoduna benzer.

parse_command_line metodu - argc + argv + options_description
Şöyle yaparız.

namespace po = boost::program_options;
po::options_description config_descriptor;
po::variables_map vm;

config_descriptor.add_options ()
...
auto popts = po::parse_command_line (argc, argv, config_descriptor);
po::store (popts,vm);
po::notify (vm);

parse_command_line metodu - argc + argv + options_description + style
style için açıklama şöyle

allow_dash_for_short : Allow "-" in short options.
allow_slash_for_short : Allow "/" in short options.

Şöyle yaparız.

po::command_line_style::style_t style = po::command_line_style::style_t(
            po::command_line_style::unix_style |
            po::command_line_style::case_insensitive |
            po::command_line_style::allow_long_disguise );

po::store(po::parse_command_line(argc, argv, commandOptions,style), vm);
po::notify(vm);

smart_ptr

scoped_array Sınıfı
Giriş
Şu satırı dahil ederiz.

#include <boost/scoped_array.hpp>

operator unspecified-bool-type () const
Açıklaması şöyle

Returns an unspecified value that, when used in boolean contexts, is equivalent to get() != 0.

Şöyle yaparız.

bool foo(const boost::scoped_array<int>& bar) {
  return static_cast<bool>(bar);
}

bool foo2(const boost::scoped_array<int>& bar) {
  const bool r = static_cast<bool>(bar);
  return r;
}

scoped_ptr Sınıfı
Giriş

Şu satırı dahil ederiz.

#include <boost/scoped_ptr.hpp>

Açıklaması şöyle

boost::scoped_ptr doesn't allow shared or transfer of ownership

Eğer C++11 kullanıyorsak bu sınıf yerine unique_ptr tercih edilmeli.

Constructor

Örnek 1

Elimizde bir hiyerarşi olsun

class A { virtual ~A() {} };
class B : public A { virtual ~B() {} void foo() {} };

Şöyle yaparız.

boost::scoped_ptr<A> p1(new B);

get metodu
Şöyle yaparız.

B* p2 = dynamic_cast<B*>(p1.get());

shared_array Sınıfı
Giriş
Şu satırı dahil ederiz.

#include <boost/smart_ptr/shared_array.hpp>

Constructor
Şöyle yaparız.

boost::shared_array<uint8_t> val;

shared_ptr Sınıfı
shared_ptr Sınıfı yazısına taşıdım.

mpl

Giriş
mpl meta programming language anlamına gelir.

vector Sınıfı
Açıklaması şöyle

The mpl::vector is more a convenience type from the pre C++11 era.

Tanımlama
Şöyle yaparız

typedef boost::mpl::vector<
    char, unsigned char, short, unsigned short, int, unsigned int, float, double
> TTypes;

boost::any_cast metodu

Pointer'a Olmayan Çevrim

Metodun içi şöyle.

template<typename ValueType>
ValueType * any_cast(any * operand) BOOST_NOEXCEPT
{
  return operand && operand->type() == boost::typeindex::type_id<ValueType>()
  ? 
  &static_cast<any::holder<BOOST_DEDUCED_TYPENAME remove_cv<ValueType>::type> *>
   (operand->content)->held
  : 0;
}

Eğer çevrim gerçekleştirilemiyorsa bad_any_cast exception atılır. Elimizde şöyle bir değişken olsun

boost::any a = 1;

Bu değişkeni bool'a çevirmek istersek exception fırlatılır.

try {
  boost::any_cast<bool>(a);
}
catch(...) {
  std::cout << "caught" << std::endl;
}

Pointer'a Çevrim
Eğer çevrim gerçekleştirilemiyorsa null döner. Açıklaması şöyle

Returns: If passed a pointer, it returns a similarly qualified pointer to the value content if successful, otherwise null is returned. If T is ValueType, it returns a copy of the held value, otherwise, if T is a reference to (possibly const qualified) ValueType, it returns a reference to the held value.

Throws: Overloads taking an any pointer do not throw; overloads taking an any value or reference throws bad_any_cast if unsuccessful.

Elimizde şöyle bir değişken olsun

boost::any a = 1;

Değişken aynı tipten pointer'a çevrilemiyorsa null döner.

bool *p = boost::any_cast<bool>(&a); 
// Prints true
std::cout << std::boolalpha << (p == nullptr) << std::endl;

Çevrilebiliyorsa düzgün bir pointer döner

int *q = boost::any_cast<int>(&a); 
// Prints false
std::cout << std::boolalpha << (q == nullptr) << std::endl;

Çevrim Örnekleri

Şöyle yaparız.

#include <boost/any.hpp>
int main()
{
  // Any holding a value
  {
    boost::any any_value(1);
    int  value = boost::any_cast<int>(any_value);
    int& reference = boost::any_cast<int&>(any_value);
    int* pointer = boost::any_cast<int>(&any_value);
  }

  // Any holding a pointer (which is nothing else but a value)
  {
    int integer = 0;
    boost::any any_ptr(&integer);
    int * pointer = boost::any_cast<int*>(any_ptr);
    int*& pointer_reference = boost::any_cast<int*&>(any_ptr);
    int** pointer_pointer = boost::any_cast<int*>(&any_ptr);
  }
}