std::plus

Giriş
Metodun içi şöyle.

struct plus {
    template <typename A, typename B>
    auto operator()(const A& a, const B& b) const { return a + b; }
};

Direkt olarak şöyle kullanırız.

#include <functional>
#include <iostream>

int main()
{
   int a = 5;
   int b = 1;
   std::cout << std::plus<int>{}(a, b) << '\n';
}

Functor olarak şöyle kullanırız.

std::transform (v.begin(), v.end(), v1.begin(), foo.begin(), std::plus<int>());

Tabi lambda ile bence bütün bu functor'ların pabucu dama atıldı.

Vector İle Yapılan Hatalar

Vector'ün Kendisi Üzerinde Dolaşırken Ekleme Yapmak - 1
Her ekleme end() iteratorünü invalid hale getirir. Aşağıdaki kod hatalı. Zaten Visual Studio assert hatası veriyor.

#include <iostream>
#include <vector>

using namespace std;

int main()
{
  vector<int> v{3, 1, 4};

  v.reserve(6);

  for (auto e: v)
    v.push_back(e*e);

  for (auto e: v)
    cout << e << " ";

  return 0;
}

Benzer bir hata da şöyle.

int main() {
    // your code goes here
    vector<int> v;
    v.push_back(1);
    int count = 0;

    for(int elem: v){
        if(count<100)
        v.push_back(count);
        count++;
    }

    for(int elem: v)
    cout << elem << endl;

    return 0;
}

Vector'ün Kendisi Üzerinde Dolaşırken Ekleme Yapmak - 3

emplace_back iterator'leri invalid hale getirebilir. Bu da tanımsız davranışa sebep olabilir.

void use(std::string & s)
{...}

std::vector<std::string> v{"foo", "bar"};
auto & v_ref = v[0];
v.emplace_back("baz");
use2(v_ref); // Undefined Behavior




Son Eleman Hariç Dolaşmak
Vector nenesini, en son eleman hariç dolaşmak isteriz. Ancak vector boştur. Klasik bir unsigned int hatasıdır.

void fun (const std::vector<int> &vec) {
    for (std::size_t i = 0; i < vec.size() - 1; ++i)
        do_something(vec[i]);
}




std::ispunct

Giriş
Belirtilen locale nesnesine göre karakterin noktalama işareti olup olmadığını döndürür.

C Locale ile Kullanım
Eğer locale vermezsek belirtilen karakterin unsigned char (0-255) ile temsil ediliyor olması gerekir.
Aşağıdaki kodda C locale kullanılıyor ancak unsigned char ile temsil edilemeyen bir karakter kullanılıyor. Dolayısıyla kod assertion veriyor.

int main() {
    ispunct('ø');
    cin.get();
    return 0;
}

Locale ile Kullanım
Aşağıdaki kodda UTF-8 ile kullanılıyor.

#include <iostream>
#include <locale>

int main()
{
    const wchar_t c = L'ø';

    std::locale loc("en_US.UTF-8");

    std::ispunct(c, loc);
}

std::current_exception

Giriş
Tam olarak nerede ve nasıl kullanıldığını anlamadım. Thread içinde atılan exception'ı ana thread'e taşımak için şöyle yapılır.

void thread_function(std::exception_ptr* exception)
try {
    throw std::runtime_error("test exception");
}
catch(std::exception& e) {
    *exception = std::current_exception();
}

int main() {
    // Thread creation.
    std::exception_ptr other_thread_exception;
    std::thread t{thread_function, &other_thread_exception};

    // Thread termination.
    t.join();
    if(other_thread_exception)
        std::rethrow_exception(other_thread_exception);
}

Coroutine

Giriş
Corutine desteği C++ dilinin bir parçası haline geldi. Dolayısıyla dışarıdan bir kütüphane veya header dosyası kullanmaya gerek kalmadı.

C++20 ile Coroutine Nedir? 
Açıklaması şöyle

One of the most important new features in the C++20 is coroutines. A coroutine is a function that has the ability to be suspended and resumed. A function becomes a coroutine if it uses any of the following:

- the co_await operator to suspend execution until resumed

- the co_return keyword to complete execution and optionally return a value

- the co_yield keyword to suspend execution and return a value

Stack

Coroutine stack kullanmayacak yani stackless olacak. Stack olmaması her şeyin heap üzerinde olması anlamına gelmez.

Event Loop

C++ ile Coroutine kullanırken bir event loop'tan bahsedilmiyor.