template <typename T>
using dyn_arr = std::vector<T>;
dyn_arr<int> nums; // эквивалентно std::vector<int>

using func_ptr = int (*)(int);

using ull = unsigned long long;

constexpr ull operator"" _KB(ull no)
{
    return no * 1024;
}

constexpr ull operator"" _MB(ull no)
{
    return no * (1024_KB);
}

cout<<1_KB<<endl;
cout<<5_MB<<endl;

std::pair<int, int> p = {1, 2};
std::tuple<int, int> t = {1, 2};
std::vector<int> v = {1, 2, 3, 4, 5};
std::set<int> s = {1, 2, 3, 4, 5};
std::list<int> l = {1, 2, 3, 4, 5};
std::deque<int> d = {1, 2, 3, 4, 5};

std::array<int, 5> a = {1, 2, 3, 4, 5};

auto a = 3.14; // double
auto b = 1; // int
auto& c = b; // int&
auto g = new auto(123); // int*
auto x; // error -- `x` requires initializer

std::array<int, 5> a {1, 2, 3, 4, 5};
for (int& x : a) x *= 2;
// a == { 2, 4, 6, 8, 10 }

struct demo
{
    int m_var;
    demo(int var) : m_var(var) {}
    demo() : demo(0) {}
};

demo d;

void f(int* num, int& num2)
{
  if(num != nullptr) // if nullptr ignored algorithm
  {
  }
  // can't check num2 on need to use or not
}

#include <iostream>
int main()
{
   std::cout << "Hello, world!\n";

   const int v = 10;
   //int& const r = v; // Ошибка
   const int& r = v;

   enum
   {
       is_const = std::is_const<decltype(r)>::value
   };

   if(!is_const)
       std::cout << "const int& r is not const\n";
   else
       std::cout << "const int& r is const\n";
}

int main() 
{
    return 0;
}