std::tuple_cat

Giriş

Şu satırı dahil ederiz

#include <tuple>

Bir veya daha fazla tuple'ı birleştirerek yeni bir tuple oluşturur. Genelde std::make_tuple ile kullanılır. 

Örnek

Çok basitleştirilimiş bu örnekte önce bir pair yaratılıyor. pair make_tuple() ile tuple haline getiriyor ve diğer tuple nesneleri ile birleştiriliyor.

return std::tuple_cat(std::make_tuple(std::make_pair(...,...)),...);

Örnek

Şöyle yaparız. Bu örnek çok daha karışık.  std::make_index_sequence ile n tane tekrar eden elemanlı yapı yaratılıyor ve bu bir tuple'a çevriliyor. Daha sonra tüm tuple nesneleri std::tuple_cat ile birleştirilip yeni bir tuple yaratılıyor.

template <typename T,size_t reps>
struct repeated_type {
    using type = T;
    static const size_t N = reps;
};

template <typename T,std::size_t...n>
auto n_tuple_impl(std::index_sequence<n...>){ 
    return std::make_tuple( (n,T{})...); 
}

template <typename repT>
using n_tuple_single = decltype( n_tuple_impl<typename repT::type>(
   std::make_index_sequence<repT::N>() )
);

template <typename...repT>
using n_tuple = decltype( std::tuple_cat( ( n_tuple_single<repT>() )... ) );

int main() {
    using two_ints = repeated_type<int,2>;
    using three_doubles = repeated_type<double,3>;
    using my_tuple = n_tuple<two_ints,three_doubles>;
    static_assert(std::is_same<std::tuple<int,int,double,double,double>,my_tuple>::value);
}

Exposition

Giriş
Tam olarak ne işe yaradığını anlamadım ancak bazı alanlar exposition only olarak işaretli.

std::error_code::val_
std::wstring_convert::byte_err_string
std::array::elems
std::move_iterator::current
std::reverse_iterator::current
std::ostream_iterator::delim
// And a lot of others

C++ Smart Pointer

Observer Pointer

Bu sınıfın C++14 ile standarda girmesi bekleniyor. Sınıfın sadece marker interface gibi kullanılması düşünülüyor.

Strict Weak Ordering

Strict Weak Ordering Nedir?
Strictk Weak Ordering key değerlerinin karşılaştırılması için "<" işlemini kullanması anlamına gelir.

Hangi Veri Yapıları Kullanır?
std::map ve std::set elemanların eşitliği için bu yöntemi kullanır. Tüm veri yapıları için Compare kavramına bakmak gerekir.

Hangi Algoritmalar Kullanır?
std::sort sıralama için bu yöntemi kullanır. Tüm veri yapıları için Compare kavramına bakmak gerekir.

Java'da Nasıldır?
Java'da elemanların eşitliğ için nesnenin equals() metodu kullanılır.

Strict Weak Ordering Tablosu

Bir tablo haline dökersek şöyle gösteririz

For all a, comp(a,a)==false
If comp(a,b)==true then comp(b,a)==false
if comp(a,b)==true and comp(b,c)==true then comp(a,c)==true

veya şöyle gösteririz

X    a;
X    b;

Condition:                  Test:     Result
a is equivalent to b:       a < b     false
a is equivalent to b        b < a     false

a is less than b            a < b     true
a is less than b            b < a     false

b is less than a            a < b     false
b is less than a            b < a     true

En Çok Yapılan Hata - İki Nesne Eşitse

Kural şudur. Yani kısaca iki nesne eşitse false dönmek gerekir.

they are equivalent if !comp(a,b) && !comp(b,a)

Aynı kuralın bir başka şekilde ifade edilişi de şöyle

In imprecise terms, two objects a and b are considered equivalent (not unique) if neither compares less than the other: !comp(a, b) && !comp(b, a)

Şöyle de ifade edilebilir.

Two objects x and y are equivalent if both f(x, y) and f(y, x) are false. Note that an object is always (by the irreflexivity invariant) equivalent to itself. 

Örnek - Yanlış Kullanım

Şu kod yanlış. Çünkü comp(a,a) false döneceğine true dönüyor.

bool comp (string s1, string s2) {
  if (s1.size() < s2.size())
    return false;
  else
    return true;
}

sort ile comparator sınıfı kullanmak

Örneğin yeni bir b key değerini eklerken mevcut a key değeri ile karşılaştırma yapılır. a < b ifadesinin false olması a'nın b'den küçük olmasını garanti etmek için yeterli değildir. Aynı zamanda b < a ifadesinin de false olması gerekir. Eğer bu ikinci karşılaştırma da false dönerse a = b sonucu çıkarılır ve map insert() metodu yeni girdiyi kabul etmez.

Yani < karşılaştırması map'e yeni bir değer eklerken biraz daha fazla karşılaştırma yapılmasına sebep olur.

< Nasıl Kodlanır
Normalde kalıtım kullanmaya pek ihtiyaç olmaz. Ancak kalıtım kullanan bir örnek göstermek istedim. Şöyle yaparız.

class Base
{
public:
  virtual bool operator<(Base & other) const
  {
    std::cout << "Base";
  }
};

class Derived : public Base
{
public:
  bool operator<(Base & other) const override
  {
    std::cout << "Derived";
  }
};

int main()
{
  Derived a;
  Derived b;
  a < b; //prints "Derived"
  a.Base::operator <(b); //prints "Base"
}

std::set_terminate

Eğer yakalanmamış exception'lar varsa ve de temizlik yaparak uygulamadan çıkmak istiyorsak aşağıdaki gibi bir yöntem izleyebiliriz.

terminate_handler old_terminate_handler = nullptr;

void new_terminate_handler() {
    std::cerr << "terminate due to error" << std::endl;
    if( old_terminate_handler != nullptr ) {
        old_terminate_handler();
    } else {
        exit (-1);
    }
}

int main(int, char**) {
    old_terminate_handler = get_terminate();
    set_terminate(new_terminate_handler);
}

std::set_terminate() metodu ile yakalanmamış exceptionları kendimiz yakalar ve std::exit() metodunu çağırırsak, programımız düzgün bir şekilde çıkar. Hem static destructorlar işletilir, hem de std::atexit() metodu ile atanan metotlar çağırılır ve de en önemlisi I/O streamleri boşaltılır (flush) .

Callable

Callable Nedir
C++17 ile gelen bir kavram. Açıklaması şöyle

Callable applies only to object types, and include everything from pointer-to-members to types with an overloaded operator() to types with an implicit conversion to function pointers to function pointers themselves.

Yani basitçe "operator ()" metodunu sağlayan sınıf, struct gibi düşünülebilir. Bir function Callable değildir !

Declaration ve Definiton

Declaration
Derleyiciye bir değişken, sınıf veya metodun tipi bildirilir. Değişken için bellek ayrılmaz."Genelde" header dosyasındaki satırlar declaration olarak tabir edilirler. Declaration örnekleri şöyle

extern int a;       // declares a
extern const int c; // declares c
int f(int);         // declares f
struct S;           // declares S
typedef int Int;    // declares Int
extern X anotherX;  // declares anotherX
using N::d;         // declares d

Definition
Bazı definition örnekleri şöyle

int a;                       // defines a
extern const int c = 1;      // defines c
int f(int x) { return x+a; } // defines f and defines x
struct S { int a; int b; };  // defines S, S::a, and S::b
struct X {                   // defines X
    int x;                   // defines non-static data member x
    static int y;            // declares static data member y
    X(): x(0) { }            // defines a constructor of X
};
int X::y = 1;                // defines X::y    
enum { up, down };           // defines up and down
namespace N { int d; }       // defines N and N::d
namespace N1 = N;            // defines N1
X anX;                       // defines anX

Değişken
Değişken için bellek ayrılır.

int bar;

Değişken için bellek ayrıldığı aşağıda yazılı.

6.7/5 Semantics A declaration specifies the interpretation and attributes of a set of identifiers. A definition of an identifier is a declaration for that identifier that:

— for an object, causes storage to be reserved for that object;

...

Metod
Metod vücut bulur.

int g(int lhs, int rhs) {return lhs*rhs;}

Struct
Struct define edilse bile bir değişken yaratılmazsa bellek ayrılmaz.

struct widget2 // defines structure widget2 that *would* take up ~8 bytes
{
    int thing1;
    int thing2;
};

Diğer kullanım şekilleri şöyle

struct widget x; // defines variable x of type struct widget
                 // which must be defined somewhere prior

struct widget2; // declares structure widget2
// does nothing except tells the compiler there will be some
// structure definition named widget2 coming later

int fn(widget2 *p); // OK widget2 need only be *declared* first

// NO
// struct widget2 y; // illegal - has not be defined yet

struct widget2 // defines structure widget2 that *would* take up ~8 bytes
{
    int thing1;
    int thing2;
} y; // defines variable y of type struct widget2 that *does* take up ~8 bytes

struct widget2 z[10]; // defines global variable z that *does* take up ~80 bytes

İçinde static alan barındıran struct'lar ise şöyledir.

struct X { // defines X
    static int y; // declares static data member y
};

int X::y = 1; // defines X::y

STL Replace Algoritmaları

Giriş
STL algoritmalarını işlevlerine göre gruplamak anlamayı çok daha kolaylaştırıyor. Algoritmaları kullanmak için

#include <algorithm>

yapmak gerekir.

replace

Örnek ver

replace_if

Örnekte ' ' hariç geri kalan herşey, '_' karakterleri ile değiştiriliyor.

#include <algorithm>
#include <iostream>
#include <string>

int main()
{
  std::string str = "I like turtles";

  std::replace_if(str.begin(), str.end(), [](char ch){ return ch != ' '; }, '_');

  std::cout << str << '\n';
}

replace_copy

Örnek ver

replace_copy_if

Örnek ver

std::is_function

Giriş
Metodun içi şöyle.

template<class T>
struct is_function : std::integral_constant<
    bool,
    !std::is_const<const T>::value && !std::is_reference<T>::value
> {};

std::is_function tam 6 nokta alabilecek şekilde çok daha karmaşık kodlanabilir.

  /// is_function
  template<typename>
    struct is_function
    : public false_type { };

  template<typename _Res, typename... _ArgTypes>
    struct is_function<_Res(_ArgTypes...)>
    : public true_type { };

  template<typename _Res, typename... _ArgTypes>
    struct is_function<_Res(_ArgTypes...) &>
    : public true_type { };

  template<typename _Res, typename... _ArgTypes>
    struct is_function<_Res(_ArgTypes...) &&>
    : public true_type { };

  template<typename _Res, typename... _ArgTypes>
    struct is_function<_Res(_ArgTypes......)>
    : public true_type { };

  template<typename _Res, typename... _ArgTypes>
    struct is_function<_Res(_ArgTypes......) &>
    : public true_type { };

  template<typename _Res, typename... _ArgTypes>
    struct is_function<_Res(_ArgTypes......) &&>
    : public true_type { };