Structured Exception Handling

Giriş
Structured Exception Handling yazılarda SEH olarak geçer.

Örnek
Şöyle yaparız.

__try
{
 // doing something wrong
 *nullptr = 0xbad;
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
  // exception quashed!
}

Karmaşık Tanımlamalar

Giriş
Karmaşık tanımlamalar yani Complex Declerations C++ dilinin okunması zor olabileceğini gösteriyor. Bir kaç örneği vermek istedim.

Karmaşık Array Tanımlamaları
Örnek
Şöyle yaparız

int array[5] = { 10,11,12,13,14};
...
int *pArray = new int[5];

Örnek
Şöyle yaparız

char s[5][5];
char *s[5];
char (*s)[5];

Birincisi 5x5'lik 2 boyutlu bir matrix
İkincisi 5 karakter alabilen bir pointer
Üçüncüsü 5 eleman alabilen char pointer dizisi

Pointer To Array
Pointer To Array yazısına taşıdım.

Reference To Array
Şöyle yaparız.

int a[5];
int (&ref)[5] = a;

Function Pointer Tanımlamaları
Karmaşık Tanımlamalar - Function Pointer yazısına taşıdım.

Pointer to Pointer Tanımlamaları
Örnek

Örnek
Şöyle yaparız.

class Foo { public: int f1, f2; };

testClass foo;
testClass * bar = &foo;
testClass ** baz = &bar;

(*baz)->f1 = 1;

Eğer şöyle yaparsak.

*baz->f1 = 1;//Error appears here

Şu hatayı alırız.

“expression must have pointer to class type”

std::auto_ptr Sınıfı

Copy Constructor
Sağ taraftaki kaynak kendi auto_ptr nesneme taşınır. Bu çağrıdan snra aağ tarafa erişilmemesi gerekir.
Şöyle yaparız.

auto_ptr<Shape> a(new Triangle);   // create triangle
auto_ptr<Shape> b(a);              // move a into b
double area = a->area();           // undefined behavior

Bu metodun kullanılduğı en güzel yer factory metodları. Şöyle yaparız.

auto_ptr<Shape> make_triangle()
{
  return auto_ptr<Shape>(new Triangle);
}

auto_ptr<Shape> b (make_triangle());      // move temporary into b
double area = make_triangle()->area();   // perfectly safe

STL Permuting Algoritmaları

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

Permütasyon Nedir
Permütasyon kümenin tüm elemanlarını farklı sıralarda üretir.

Kombinasyon Nedir
Kombinasyon ise kümenin tüm alt kümelerini verir. Alt kümelerde sıra önemli değildir. Elimizde 0 , 1 olsun .Kombinasyon yaparsak

0
1,
0 ,1
alırız.

is_permutation metodu
Elimizde iki tane string olsun. Bu iki string'in birbirlerini permütasyonu olduğunu anlamak için şöyle yaparız.

return std::is_permutation( str1.begin(),str1.end(), str2.begin(), str2.end() );

next_permutation metodu
Eleman sayısı faktoriyel kadar sonuç döndürür.

Elimizde 1,2 olsun. Permütasyon olarak
1,2
2,1
alırız.

Elimizde 1,2,3 olsun. Permütasyon olarak
1,2,3
1,3,2
2,1,3
2,3,1
3,1,2
3,2,1
alırız.

Elimizde 1,2,3,4 olsaydı 24 tane permütasyon olurdu. Sonuç dizisi uzun olduğu için yazmıyorum .

Bu işleme başlamadan önce

1. vector küçükten büyüğe sıralı olmalıdır.
2. Sıralanacak yapının < operatörü olmalıdır. Eğer kendi yapımız ise şöyle yaparız.

class Foo
{
public:
  int x = 0;
  int y = 0;
  
  bool operator <( const Foo& rhs )
  {
    ...
  }
};

Şöyle yaparız.

vector<int> v = ...;
do {
  ...
} while(next_permutation(v.begin(), v.end()));

Aradaki permutasyonları almak istersek şöyle yaparız.

vector<int> v = ...;
vector < vector<int>> outVal ;

sort( v.begin() , v.end() );
do
{
  outVal.push_back (v);
} while (next_permutation (v.begin() , v.end() ) );

prev_permutation metodu
Örnek ver

Direct Initialization

Giriş
Foo foo(...) şeklindeki kullanımdır. Ancak bu kullanımda

1. ya girdi direkt kullanılır
2. ya da girdinin önce bir başka tipe çevrilmesi gerekiyorsa çevirilir ve daha sonra  benim constructor metoduma parametre olarak verilir.

Örnek
Elimizde şöyle bir kod olsun.

template <typename Type>
struct Class
{
  Type data;
  Class(Type data) : data(data) { }
};

Şöyle yaparız. Burada const char*, önce std::string'e çevriliyor. Daha sonra benim constructor'ıma parametre olarak veriliyor.

Class<std::string> b("abc");

Örnek
Elimizde şöyle bir sınıf olsun.

class Foo
{
  int value;
  string str_value;

public:

  Foo(int param) { value = param; }

  Foo(string param)
  {
    str_value = param;
  }
};

Direct Initialization için şöyle yaparız.

Foo foo1 (2);
Foo foo2 ("4");

Açıklaması şöyle.

For copy initialisation the compiler searches for a (single) user defined conversion from (in case of d) char const * (this is a bit inaccurate, see end of answer) to CLS, whereas for direct initialisation all constructors are tried, where CLS(std::string) can be used​ because there's a conversion std::string(char const *) available.