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 { };

std::ref

std::ref bir reference_wrapper döner
std::reference_wrapper nesnesini oluşturmak için genellikle std::ref kullanırız

#include <functional>
int a = 5;
auto b = ref(a);
b.get() = 3;
cout<<a<<endl;
pair <reference_wrapper<int>, int> test(b, 0);
a = 1000;
cout<<test.first<<endl;

Özellikle std::bind ile kullanımı çok yaygındır.

void print(int i) {
    std::cout << i << '\n';
}

int main() {
    int i = 10;

    auto f1 = std::bind(print, i);
    auto f2 = std::bind(print, std::ref(i));

    i = 20;

    f1();
    f2();
}

Çıktı olarak şunu alırız.

10
20

Stream ile Menü Yöntemleri

Giriş
Konsol uygulamalarında kullanıcıya metin gösterip, girdi okumak her zaman başa bela işler. Aşağıda kodlamayı kolaylaştırdığını düşündüğüm şeyler var.

Satır satır okumak
Öncelikle girdi tek satır olmalı ve satırın sonuna kadar okunmalı

template <typename T>
T get( std::istream& is = std::cin )
{
    T value{};
    is >> value;
    is.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );
    return value;
}

std::equal_to

Giriş
std::equal_to verilen iki parametrenin denk olup olmadıpını == ile test eder.
Örnek

// compare two sequences and produce a third one
// having true for positions where both sequences
// have equal elements
std::transform(seq1.begin(), seq1.end(),
               seq2.begin(), std::inserter(resul), std::equal_to<>()); 

Lambda kullanıldıktan sonra bence artık gerek kalmadı
[](auto& x, auto& y) { return x == y; }