Structured Binding

Giriş
Şu satırı dahil ederiz.

#include <utility>

Structured Binding C++17 ile geliyor. Structured Binding her zaman auto ile kullanılır.

Array
Şöyle yaparız.

const int a[2] = { 0, 1 };
auto [ x, y ] = a;

constexpr
Şöyle yaparız.

#include <utility>

constexpr int foo(std::pair<int, int> p) {
  auto [a, b] = p;
  return a;
}

int main() {
  constexpr int a = foo({1, 2});
  static_assert(a == 1);
}

Function Call
Şöyle yaparız. Burada C++17 If Statement kullanılıyor.

if (int x = func(), y = func2(); x > 0 && y > 0)
{
}

std::map
Şöyle yaparız.

std::map<int, int> m = {{ 0, 1 }, { 2, 3 }};
for(auto &[key, value]: m) {
  std::cout << key << ": " << value << std::endl;
}

std::set
Şöyle yaparız. Burada C++17 If Statement kullanılıyor.

if (auto[iter, success] = set.insert("Hello"); success)
{   }
else    
{   }

Struct
Şöyle yaparız.

struct S { int x = 0; int y = 1; };

S s{};
auto [ x, y ] = s;

Tuple
Örnek
Elimizde bir tuple olsun

std::tuple<int, std::string> t(42, "foo");

Şöyle yaparız

auto [i, s] = t;

Bu kod şununla aynıdır.

auto i = std::get<0>(t);
auto s = std::get<1>(t);

Şununla da aynıdır.

int i;
std::string s;
std::tie(i, s) = t;

Eğer referans olarak kullanmak istersek şöyle yaparız

auto& [ir, sr] = t;
const auto& [icr, scr] = t;

Örnek
const auto olarak kullanmak için şöyle yaparız.

std::tuple<int, int&> f();

auto [x, y] = f(); 
// decltype(x) is int
// decltype(y) is int&

const auto [z, w] = f();
// decltype(z) is const int
// decltype(w) is int&

Örnek
Şöyle yaparız.

int a, b;
std::tie(a, b) = std::make_tuple(2, 3);

// C++17
auto  [c, d] = std::make_tuple(4, 5);
auto  [e, f] = std::tuple(6, 7);
std::tuple t(8,9); auto& [g, h] = t; // not possible with std::tie

Örnek
Şöyle yaparız.

#include <utility>

std::pair<int, int> f()
{
  //return std::make_pair(1, 2); // also works, but more verbose
  return { 1, 2 };
}

int main()
{
  auto[one, two] = f();
}

Diğer
std::tuple için structured binding yerine std::tie kullanılabilir.

Örnek
Elimizde tuple döndüren bir metod olsun.

std::tuple<int, int, int> foo() {...}

Şöyle yapmak yerine

auto [a, b, c] = foo();

Şöyle yaparız.

int b, c;
std::tie(std::ignore, b, c) = foo();