Value Initialization

Value Initialization Nedir? (C++03)
Bir değişkene ileride okuma yapılacağı farz edilerek değer atanması anlamına gelir.

Value Initizalization ve Primitive Tipler
Pritimive tipler için C++ standardında aşağıda belirtilen başlama değeri kullanılır. Görüldüğü gibi primitive tipler için value initialization, zero initialization ile aynıdır.

int = 0, 
bool = false, 
float = 0.0f,  
enum = (enum type)0, 
pointer = null pointer
pointer to member = null member pointer

Value Initialization ve Primitive Array
Elimizde şöyle bir kod olsun. Bu bellek alanı  0 ile doldurulur.

new char [size]()

Value Initialization ve Constructor
Eğer bir member variable initializer list içinde ise value initialize edilir. Initializer list içinde yoksa default initialize edilir.

struct B
{
  int i, j, k;
};

struct A
{
  A() : b() {} // value-initializes b: b.i, b.j, b.k zero initialized

  B b;
};

struct AA
{
  AA() {} // default-initializes b: b.i, b.j, b.k have no initialization

  B b;
};

std::owner_less Yapısı

Giriş
Şu satırı dahil ederiz.

#include <memory>

std::weak_ptr nesneleri için < operator sağlar.

Constructor - std::weak_ptr
Şöyle yaparız

#include <map>
#include <memory>
#include <string>

struct Foo
{
};

using my_key = std::weak_ptr<Foo>;
using my_comp = std::owner_less<my_key>;

int main()
{
    auto m = std::map<my_key, std::string, my_comp>();

    auto p = std::make_shared<Foo>();
    auto p1 = std::make_shared<Foo>();

    m.emplace(p, "foo");
    m.emplace(p1, "bar");

    p.reset();
    p1.reset();
}

Variadic Template C++11

Giriş
C++11 ile variadic template özyinelemeli çalışır.

Örnek
Verilen her parametrenin [0-16] arasında olduğunu kontrol etmek için şöyle yaparız.

bool check(int a) {
  return 0 <= a && a < 16;
}   

template<typename... Args>
bool check(int a, Args... args) {
  return check(a) && check(args...);
}

Örnek
Verilen sayıları çarpmak için şöyle yaparız.

template<size_t... N_i>
struct product { 
  static const size_t value = 1; 
};

template<size_t N_1, size_t... N_i>
struct product<N_1, N_i...> {
  static const size_t value = N_1 * product<N_i...>::value;
};

std::array< float, product<N_i...>::value> arr;

Örnek
Eğer bir sayı ile çağırıyorsak 0 olunca duran kodu yazmak gerekir.

template<typename T, unsigned N, typename... REST>
struct generate_tuple_type
{
 typedef typename generate_tuple_type<T, N-1, T, REST...>::type type;
};

template<typename T, typename... REST>
struct generate_tuple_type<T, 0, REST...>
{
  typedef std::tuple<REST...> type;
};

Bu kod bize bir std::tuple döndürür.

using gen_tuple_t = generate_tuple_type<int, 3>::type;
using hand_tuple_t = std::tuple<int, int, int>;
static_assert( std::is_same<gen_tuple_t, hand_tuple_t>::value, "different" );

Örnek
Şöyle yaparız. sizeof...(args) şeklinde kullanım ile parametre sayısı anlaşılıyor.

template <class A, class... Args>
void print(A arg, Args... args) {
  std::cout << arg;
  if constexpr (sizeof...(Args) > 0) {
    std::cout << sep;
    print(args...);
  }
}

Örnek
Kaç tane paramete geçtiğini anlamak için şöyle yaparız.

[](auto...p){return sizeof...(p);}

Örnek
Bu örnekte variadic  template kullanarak kalıtım gösteriliyor. Verilen tip kadar üye alana yarartmak için şöyle yaparız.

template<typename... Members>
class Composition;

template<typename FirstMember, typename... MoreMembers>
class Composition<FirstMember, MoreMembers...>
    : public Composition<MoreMembers...> {
protected:
    FirstMember member;
};

template<typename FirstMember>
class Composition<FirstMember>
{
protected:
    FirstMember member;
};

Şöyle yaparız.

Composition<Composition<
    Composition<int>, Composition<int>*>, double> composition;