format

Giriş
Şu satırı dahil ederiz.

#include <boost/format.hpp>

format kütüphanesi kendi içinde bir ostream kullanır. Formatlama için kullanılan indeksler %1%'den başlar.

wformat sınıfı şöyle tanımlıdır.

typedef basic_format<wchar_t > wformat;

Constructor
Elimizde şöyle değişkenler olsun.

unsigned short vendorID =...;
unsigned short productID = ...;

Bu değişkenleri formatlamak için şöyle yaparız.

boost::format fmt("[Vendor= %1%] [Product= %2%]") % vendorID %productID;

Eğer format string'i hatalıysa boost::bad_format_string atılır.

operator %
Kendi sınıfımızı boost::format ile kullanmak için şöyle yaparız.

#include <boost/format.hpp>
#include <iostream>

struct A
{
    int n;

    A() : n() {}

    friend std::ostream &operator<<(std::ostream &oss, const A &a) {
        oss << "[A]: " << a.n;
    }
};

int main() {
    A a;
    boost::format f("%1%");
    std::cout << f % a << std::endl;
}

str metodu
free style str metodu şöyle kullanılır

boost::str(fmt);

Formatlama Seçenekleri
Format string içinde kullanılan formatlama seçenekleri platformadan bağımsızdır.

1. double için
Yuvarlama gerekiyorsa çift rakama doğru yuvarlamak yapılır ("round half to even")

Örnek
Şöyle yaparız. Çıktı olarak 102262 alırız

double nbr = 102262.5;

boost::format("%.0f") % nbr;

Şöyle yaparız. Çıktı olarak 34088 alırız

double nbr = 34087.5;

boost::format("%.0f") % nbr;

Elimizde şöyle bir kod olsun

double d = 0.0009;

Şöyle yaparız. Çıktı olarak  0.0009 alırız

std::string s = (boost::format("%1$.4f") % d).str();

2. float için
Şöyle yaparız.

format f ("%1$.2f");

Şöyle yaparız

boost::str(boost::format("%0.3f") % 5.453)

Şöyle yaparız. %4.3e gibi bir girdi alır.

#include <boost/format.hpp>

std::string FloatToScientificString(float val, int width, int precision)
{
  const std::string fmt = "%" + std::to_string(width) + "." +
    std::to_string(precision) + "e";

  return boost::str(boost::format(fmt) % val);
}

3. integer için
Şöyle yaparız.

boost::format header("%+3d") % i; // Add "+" when is not negative

4. llx seçeneği
64 bit integer için kullanılır. Şöyle yaparız.

boost::format("0x%016llx") % (unsigned long long)(u64)).str();

iostreams mapped_file Sınıfı

Giriş
Açıklaması şöyle.

It is a memory-mapping API for files, and you can open the same file in multiple processes.

Constructor
Şöyle yaparız.

boost::iostreams::mapped_file file("foo.bin");

data metodu
Şöyle yaparız.

Eigen::Map<Eigen::MatrixXf> matrix(reinterpret_cast<float*>(file.data()), rows, columns);

size metodu
Şöyle yaparız.

const std::size_t rows = 163840;
const std::size_t columns = 163840;
if (rows * columns * sizeof(float) > file.size()) {
  ...
}

range-v3

Giriş
Şu satırı dahil ederiz.

#include <range/v3/all.hpp>

Kolay kullanım için şu satırı dahil ederiz.

using namespace ranges;

concat metodu
Şöyle yaparız.

const std::vector<std::string> v1{"A", "B", "C"}, v2{"D", "E", "F"};

for (const auto& s : ranges::view::concat(v1, v2)) {
  std::cout << s << std::endl;   
}

filter metodu
Elimizde struct içinde struct olsun.

struct Foo {};
struct FooBar{
  bool is_valid;
  Foo foo;
};

Şöyle yaparız.

std::vector<Foo> get_valid_foos(const std::vector<FooBar>& foobars) {
    return foobars
        | view::filter(&FooBar::is_valid)
        | view::transform(&FooBar::foo);
}

ints metodu
Örnek
Şöyle yaparız.

using namespace ranges;
int x = accumulate(view::ints(0) | view::take(10), 0); // 45

Örnek
Şöyle yaparız.

int x = accumulate(view::ints(0, 10), 0);

Örnek
Şöyle yaparız.

const std::vector<int> result = ranges::view::ints(23, 58); // upper bound is exclusive

iota metodu
Örnek
Elimizde iki yapı olsun.

std::vector<int> numbers;
...
std::vector<std::vector<int>::iterator> pointers;

Şöyle yaparız.

copy(view::iota(numbers.begin(), numbers.end()), back_inserter(pointers));

Örnek
Şöyle yaparız.

int N = 7;
std::vector<int> numbers = ranges::view::iota(0, N);

std::vector<std::vector<int>::iterator> pointers =
    ranges::view::iota(numbers.begin(), numbers.end());

std::cout << "indirectly printing out the numbers from 0 to " << N << '\n';
ranges::copy(ranges::view::indirect(pointers),
    ranges::ostream_iterator<>(std::cout, " "));
std::cout << '\n';

stride metodu  - Ayırarak dolaşmak
Şöyle yaparız.

std::vector<std::size_t> src {1, 2, 3, 4, 5, 6, 7};
const auto min_max = minmax (src | view::stride (3));
std::cout << min_max.first << " " << min_max.second << std::endl;

transform metodu
Elimizde bir struct olsun.

struct MyStruct {
  explicit MyStruct(std::string name) : name_(name){}
  std::string name() const { return name_; }
private:
  std::string name_;
};

std::vector<MyStruct> vm;
vm.emplace_back("asd");
vm.emplace_back("qwe");
vm.emplace_back("zxc");

Şöyle yaparız.

std::vector<std::string> vs = vm | ranges::view::transform (&MyStruct::name);