Programming-Idioms.org

std::cout << "Hello World" << std::endl;

for (int i = 0; i < 10; ++i)
  cout << "Hello\n";

void finish(char* name){
    cout << "My job here is done. Goodbye " << name << "\n";
}

int square(int x){
  return x*x;
}

struct Point{
  double x;
  double y;
};

for(const auto &x : items) {
	doSomething(x);
}

std::size_t i = 0;
for(const auto & x: items) {
  std::cout << "Item " << i++ << " = " << x << std::endl;
}

for (std::size_t ix = 0; ix < items.size(); ++ix) {
  std::cout << "Item " << ix << " = " << items[ix] << std::endl;
}

for (auto const [i, x] : std::views::enumerate(items)) {
  std::cout << i << ": " << x << '\n';
}

std::map<const char*, int> x;
x["one"] = 1;
x["two"] = 2;

std::unordered_map<std::string, double> mymap = {
    {"mom", 5.4},
    {"dad", 6.1},
    {"bro", 5.9}
};

struct binary_tree
{
 int data;
 binary_tree *left = nullptr, *right = nullptr;
};

std::random_shuffle(x.begin(), x.end());

std::mt19937 gen;
std::uniform_int_distribution<size_t> uid (0, x.size () - 1);
x[uid (gen)];

std::ranges::sample(x, &result, 1, std::mt19937{std::random_device{}()});

bool Contains(const std::vector<int> &list, int x)
{
	return std::find(list.begin(), list.end(), x) != list.end();
}

auto contains(auto list, auto x) -> bool {
  return std::ranges::find(list, x) != std::ranges::end(list);
}

for (const auto& kx: mymap) {
	std::cout << "Key: " << kx.first << " Value: " << kx.second << std::endl;
}

for (const auto& [k, x]: mymap) {
	std::cout << "Key: " << k << " Value: " << x << '\n';
}

for (auto entry : mymap) {
  auto k = entry.first;
  auto x = entry.second;
  std::cout << k << ": " << x << "\n";
}

float pick(float a, float b)
{
	std::default_random_engine generator;
	std::uniform_real_distribution distribution(a, b);
	return distribution(generator);
}

std::mt19937 gen;
std::uniform_int_distribution<size_t> uid (a, b);
uid (gen);

template<typename T>
struct Node{
  T value;
  std::vector<Node<T>> children;
};

void dfs(const auto &tree, const auto &root)
{
	f(root);

	for (auto child : tree)
		dfs(tree, child);
}

std::reverse(begin(x), end(x));

template<typename T, size_t len_x, size_t len_y>
std::pair<size_t, size_t> search (const T (&m)[len_x][len_y], const T &x) {
    for(size_t pos_x = 0; pos_x < len_x; ++pos_x) {
        for(size_t pos_y = 0; pos_y < len_y; ++pos_y) {
            if(m[pos_x][pos_y] == x) {
                return std::pair<size_t, size_t>(pos_x, pos_y);
            }
        }
    }

    // return an invalid value if not found
    return std::pair<size_t, size_t>(len_x, len_y);
}

bool _search(const Matrix& _m, const float _x, size_t* const out_i, size_t* const out_j) {
  for (size_t j = 0; j < _m.rows; j++) {
    for (size_t i = 0; i < _m.cols; i++) {
      if (_m.at(i, j) == _x) {
         *out_i = i;
         *out_j = j;
         return true;
      }
    }
  }
  return false;
}

swap(a, b);

int i = std::atoi(s);

int i = std::stoi(s);

std::stringstream ss(str);
int i;
ss >> i;

std::string s("123");
int i;
std::from_chars(s.data(), s.data() + s.size(), i, 10);

std::stringstream ss;
ss << std::fixed << std::setprecision(2) << x;
s = ss.str();

std::array<char, 23> buffer;
std::string s{};
if (auto [ptr, ec] = std::to_chars(buffer.data(), buffer.data() + buffer.size(), x, std::chars_format::fixed, 2); ec == std::errc{}) {
  s = std::string(buffer.data(), ptr);
} else {
  s = std::make_error_code(ec).message();
}

auto s = std::format("{.2f}", x);

std::string s = u8"ネコ";

//declaration
auto mutex = std::mutex{};
auto cv = std::condition_variable{};
auto variable = std::optional<std::string>{};
auto future = std::async([&]() {
	auto lock = std::unique_lock{mutex, std::defer_lock};
	cv.wait(lock, [&variable](){ return variable.has_value(); });
	std::cout << "Hello, " << *variable << "!" << std::endl;
});

//passing value in main thread (or it can be done in others as well)
{
	auto lock = std::unique_lock{mutex};
	variable = "Alan";
	cv.notify_all();
}

std::vector<std::vector<double>> x (m, std::vector<double>(n));

std::vector<std::vector<std::vector<double>>> x (m, std::vector<std::vector<double>> (n, std::vector<double> (p)));

std::sort(begin(items), end(items), [](const auto& a, const auto& b) { return a.p < b.p; });

struct {
    bool operator()(const Item &lhs, const Item &rhs) const { return lhs.p < rhs.p; }
} custom_sort;

std::sort(begin(items), end(items), custom_sort);

std::ranges::sort(items, {}, &Item::p);

items.erase (items.begin () + i);

auto futures = std::vector<std::future<void>>{};
for (auto i = 1; i <= 1000; ++i)
{
	futures.emplace_back(std::async(f, i));
}

unsigned int f( unsigned int i ) {
	if ( i == 0 ) return 1;
	
	return i * f( i - 1 );
}

int pow(int x, int p)
{
  if (p == 0) return 1;
  if (p == 1) return x;

  int tmp = pow(x, p/2);
  if (p%2 == 0) return tmp * tmp;
  else return x * tmp * tmp;
}

std::atomic<int> x{};

auto local_x = x.load();
while(!x.compare_exchange_strong(local_x, f(local_x))) {
	local_x = x.load();
}

//declaration
auto mutex = std::mutex{};
auto x = someValue();

//use
{
	auto lock = std::unique_lock{mutex};
	x = f(x);
}

std::unordered_set<T> x;

std::unordered_set<T, hasher, eq> x;

std::function<C (A)> compose(B (&f)(A), C (&g)(B))
{
    return [&f, &g](A a){return g(f(a));};
}

auto fn = compose(f, g);

template<typename Pred1, typename Pred2>
auto compose(Pred1 f, Pred2 g){
  return [f,g](auto x){ return g(f(x)); };	
}

// function taking many parameters
int add(int a, int b)
{
    return a + b;
}

// define a new function preseting the first parameter
std::function<int (int)> add_def(int a)
{
    return [a](int b){return add(a, b);};
}

int result = add_def(4)(6);

//function
auto add(int a, int b) -> int {
	return a + b;
}

//curry with std::bind
using namespace std::placeholders;
auto add5 = std::bind(add, _1, 5);

//curry with lambda
auto add5 = [](int x) { return add(x, 5); };

//use
auto result = add5(1);
assert(result == 6);

auto t = s.substr(i, j-i);

bool ok = s.find(word) != std::string::npos;

auto a = {1,2,3,4,5};
auto b = {3,5};

for (auto va: a){
    for (auto vb: b){
        if (va==vb) goto OUTER;
    }
    std::cout << va << '\n';
    OUTER: continue;
}

auto indices = findNegativeValue (m, 10, 20);
std::cout << m[indices.first][indices.second] << '\n';

std::pair<int, int> findNegativeValue (int **m, int rows, int columns) {
  for (int i = 0; i < rows; ++i) {
    for (int j = 0; j < columns; ++j) {
      if (m[i][j] < 0) return make_pair (i, j);
    }
  }
  throw "No negative value!";
}

s.insert (s.begin () + i, x);

using namespace std::chrono_literals;
std::this_thread::sleep_for(5s);

auto t = s.substr(0, 5);

std::string t = s.substr(s.length() - 5);

std::string s = R"( Earth is a planet.
So is the Jupiter)";

std::istringstream x(s);
std::list<std::string> chunks;
std::copy(std::istream_iterator<std::string>(x), std::istream_iterator<std::string>(), std::back_inserter(chunks));

for (;;) {
	/// Do something
}

while (true) {
	// Do something
}

bool key_exists = m.find(k) != m.end();

bool key_exists = m.count(k) != 0;

bool key_exists = m.contains(k);

std::find_if(m.begin(), m.end(), [v](const auto& mo) {return mo.second == v; }) != m.end();

std::vector<std::string> x;
std::string y;
const char* const delim = ", ";

switch (x.size())
{
	case 0: y = "";   break;
	case 1: y = x[0]; break;
	default:
		std::ostringstream os;
		std::copy(x.begin(), x.end() - 1,
			std::ostream_iterator<std::string>(os, delim));
		os << *x.rbegin();
		y = os.str();
}

y = x | views::join_with(',') | to<std::string>();

int s = std::accumulate(x.begin(), x.end(), 0, std::plus<int>());

auto s = std::ranges::fold_left(x, 0, std::plus<int>{});

auto s = std::to_string(i);

size_t taskCount = 1000;
auto remainingTasks = std::latch(static_cast<std::ptrdiff_t>(taskCount));
auto f = [&remainingTasks](int i) {
  // do work
  remainingTasks.count_down();
};

std::vector<std::jthread> threads{ 10 };
for (auto i = 0; i < taskCount; i++) {
  auto& workerThread = threads[i % 10];
  if (workerThread.joinable()) {
    workerThread.join();
  }
  workerThread = std::jthread(f, i);
}

remainingTasks.wait();
std::cout << "Finished";

std::copy_if (x.begin (), x.end (), std::back_inserter(y), p);

auto y = x | std::views::filter(p);

std::string fromFile(std::string _f)
{
    std::ifstream t(_f);
    t.seekg(0, std::ios::end);
    size_t size = t.tellg();
    std::string buffer(size, ' ');
    t.seekg(0);
    t.read(&buffer[0], size); 
}

std::cerr << x << " is negative\n";

int main(){
	int x = -2;
	std::cerr << x <<" is negative\n";
}

int main(int argc, char *argv[])
{
 vector<string> args(1 + argv, argc + argv);

 string x = args.at(0);
}

std::time_t d = std::time(nullptr);

int i = x.find(y);

std::stringstream s;
std::regex_replace(std::ostreambuf_iterator<char>(s), x.begin(), x.end(), y, z);
auto x2 = s.str()

constexpr std::string ReplaceAllCopy(const std::string& x, const std::string& y, const std::string& z) {
	auto x2 = x;
	size_t i = 0;

	while (true) {
		i = x2.find(y, i);
		if (i == std::string::npos) break;
		x2.replace(i, y.length(), z);
	}
	return x2;
}

auto s = std::format("{.1f}%", x * 100);

std::vector<bool> x(n, 0);

std::bitset<n> x;

srand(s);

int main(int argc, char * argv[])
{
	for(int i = 1; i < argc; ++i)
	{
		std::cout <<(1==i ? "" : " ") << argv[i];
	}
        std::cout <<std::endl;
}

template <typename T,
          std::enable_if_t<
            std::is_base_of_v<Parent, T>, bool> = true>
T fact(const std::string& str) {
  return T(str);
}

unsigned long long int GCD(unsigned long long int a, unsigned long long int b)
{
    unsigned long long int c=a%b;
    if(c==0)
        return b;
    return GCD(b, c);
}

auto x = std::gcd(a, b);

auto x = std::lcm(a, b);

std::bitset<sizeof(x)*8> y(x);
auto s = y.to_string();

std::string ToBinary(int x) {
  std::array<char, 64> buf;
  auto[ptr, ec] = std::to_chars(buf.data(), buf.data() + buf.size(), x, 2);
  auto s = std::string(buf.data(), ptr);
  return s;
}

using namespace std::complex_literals;
	
auto x = 3i - 2.;
x *= 1i;

do {
  someThing();
  someOtherThing();
} while(c);

float y = static_cast<float>(x);

int y = static_cast<int>(x);

int y = static_cast<int>(std::floor(x + 0.5f));

 auto r = regex("htt+p");

uint32_t c = 0;
for (; i; i &= i - 1, ++c);

bool addingWillOverflow(int x, int y) {
  return ((x > 0) && (y > std::numeric_limits<int>::max() - x)) ||
         ((x < 0) && (y < std::numeric_limits<int>::min() - x));
}

exit(1);

vector<byte> _buf(1'000'000);

throw domain_error("oops!");

class Foo final {
  int mX = 0;

public:
  const auto& X() const { return mX; }
};

void control(invocable auto&& f)
{
 f();
}

std::cout<<typeid(x).name();

std::ifstream f(path, std::ios::in | std::ios::binary);
f.seekg(0, std::ios::end);
size_t x = f.tellg();

bool b = s.starts_with(prefix);

std::string prefix = "something";
bool b = s.compare(0, prefix.size(), prefix) == 0;

return suffix.size() == s.size() - s.rfind(suffix);

bool b = s.ends_with(suffix);

std::time_t d = std::chrono::system_clock::to_time_t(ts);

int main()
{
	char x[32]{};
	time_t a = time(nullptr);
	struct tm d;
	if (localtime_s(&d, &a) == 0) {
		strftime(x, sizeof(x), "%F", &d);
		std::cout << x << std::endl;
	}

	return 0;

}

struct is_less {
    bool operator () (int a, int b){
        return a < b;
    }
};

int main(){
    std::vector<int> items = {1337, 666, -666, 0, 0, 666, -666};
    std::sort(items.begin(), items.end(), is_less());

    std::vector<int> expected = {-666, -666, 0, 0, 666, 666, 1337};
    assert(items.size() == expected.size());
    for (size_t i = 0; i < items.size(); i++){
        assert(items[i] == expected[i]);
    }
    return 0;
}

std::ranges::sort(items, c);

int main(int argc, char* argv[])
{
    std::cout << std::filesystem::path(argv[0]).filename() << '\n';
}

dir = std::filesystem::current_path();

std::size_t n = sizeof(t);

bool blank = false;
if (s.empty() || std::all_of(s.begin(), s.end(), [](char c){return std::isspace(c);})) {
      blank = true;
}

std::map< K, V > _mymap;
for (const auto& pair : _mymap) {
    std::cout << pair.first << ": " << pair.second << "\n";
}

auto print(auto&... args) {
  // c++17 fold expression
  (std::cout << ... << args) << std::endl;
}

auto print_map_contents(auto mymap) {
  // c++17 structured binding
  for (auto [k, x] : mymap) {
    print("mymap[", k, "] = ", x);
  }
}

auto main() -> int {
  // map is ordered map, iteration is ascending by key value
  auto map = std::map<std::string, int> {
    {"first entry", 12},
    {"second entry", 42},
    {"third entry", 3},
  };

  print_map_contents(map);
}

for_each(begin(mymap), end(mymap),
    [&s](const auto& kv) { s.insert(kv.second); });

size_t n = x.size();

std::unordered_set<T> y (x.begin (), x.end ());

std::set<T> y (x.begin (), x.end ());

std::sort(x.begin(), x.end());
auto last = std::unique(x.begin(), x.end());
x.erase(last, x.end());

std::vector<std::string> x = {"one", "two", "two", "one", "three"};
std::unordered_set<std::string> t;
for (auto e : x)
    t.insert(e);

std::cin >> n;

enum class Suit {
    SPADES, HEARTS, DIAMONDS, CLUBS
};

enum class Color : char{
	Red, Black, Green
};

assert(isConsistent());

template<typename T>
int binarySearch(const std::vector<T> &a, const T &x)
{
    if(a.size() == 0) return -1;

    size_t lower = 0;
    size_t upper = a.size() - 1;

    while(lower <= upper)
    {
        auto mid = lower + (upper-lower) / 2;

        if(x == a[mid])
        {
            return (int)mid;
        }
        else if(x > a[mid])
        {
            lower = mid + 1;
        }
        else
        {
            upper = mid - 1;
        }
    }

    return -1;
}

auto start = std::chrono::steady_clock::now();
foo();
auto end = std::chrono::steady_clock::now();
auto t = std::chrono::duration_cast<std::chrono::nanoseconds>(end-start).count();

std::tuple<std::string, bool> foo() {
  return std::make_tuple("someString", true);
}

auto foo()
{
    return std::make_tuple("Hello", true);
}

void _foo() {
#include "foobody.txt"
}

void bfs(Node& root, std::function<void(Node*)> f) {
  std::deque<Node*> node_queue;
  node_queue.push_back(&root);
  while (!node_queue.empty()) {
    Node* const node = node_queue.front();
    node_queue.pop_front();
    f(node);
    for (Node* const child : node->children) {
      node_queue.push_back(child);
    }
  }
}

void dfs(Node& root, std::function<void(Node*)> f) {
  std::stack<Node*> queue;
  queue.push(&root);
  std::unordered_set<const Node*> visited;
  while (!queue.empty()) {
    Node* const node = queue.top();
    queue.pop();
    f(node);
    visited.insert(node);
    for (Node* const neighbor : node->neighbors) {
      if (visited.find(neighbor) == visited.end()) {
        queue.push(neighbor);
      }
    }
  }
}

if (c1)
    f1();
else if (c2)
    f2();
else if (c3)
    f3();

if (c1)
{
    f1();
}
else if (c2)
{
    f2();
}
else if (c3)
{
    f3();
}

(c1 && (f1(), true))
 || (c2 && (f2(), true))
 || (c3 && (f3(), true));

std::clock_t start = std::clock();
f();
double duration = (std::clock() - start) / (double) CLOCKS_PER_SEC;

#include <chrono>

double measure() {
    using namespace std::chrono;
    const auto start{ high_resolution_clock::now() };
    f();
    const auto elapsed{ high_resolution_clock::now() - start };
    const double seconds{ duration_cast<duration<double>>(elapsed).count() };
    return seconds;
}

auto ok = std::search(std::begin(s), std::end(s), std::begin(word), std::end(word),
    [](auto c, auto d){
        return std::tolower(c) == std::tolower(d);
    }
) != std::end(s);

std::vector<T> items = {a, b, c};

list items { a, b, c };

erase(items, x);

items.remove(x);

bool b = false;
if (! s.empty() && std::all_of(s.begin(), s.end(), [](char c){return std::isdigit(c);})) {
    b = true;
}

m.erase(k);

void print_seq(const auto& ...xs)
{
 (std::for_each(std::begin(xs), std::end(xs), 
           [](const auto& x) { std::cout << x; }), ...);
}

 std::list xs { "hi", "there", "world" }, ys { "lo" "thar" };

 print_seq(xs, ys);

template <typename I>
std::string n2hexstr(I w, size_t hex_len = sizeof(I)<<1) {
    static const char* digits = "0123456789ABCDEF";
	std::string str(hex_len, '-');
    for (size_t i=0, j=(hex_len-1)*4 ; i<hex_len; ++i,j-=4)
       str[i] = digits[(w>>j) & 0x0f];
	return str;
}

std::ostringstream stream;
stream << std::hex << x;
s = stream.str();

bool b = std::filesystem::exists(fp);

float f = std::stof(s);

 copy_if(begin(src), end(src), back_inserter(dest),
         [](const auto c) { return static_cast<unsigned char>(c) <= 0x7F; });

vector<int> v;
for(int t;;){
	cin >> t;
	if(cin.eof())
		break;
	v.push_back(t);
}

 if('/' == s.back())
  s.pop_back();

string s { 'c' };

auto t = s + std::to_string (i);

auto r = std::filesystem::remove(filepath);

// using char*
constexpr char planet[] = "Earth";

// using string
const std::string planet{"Earth"};

#ifdef __x86_64
f64();
#else
#ifdef _M_AMD64
f64();
#else
f32();
#endif
#endif

if constexpr(sizeof(nullptr) == 8) {
  f64();
} else {
  f32();
}

for (auto &it : elements)
	it *= c;

std::transform(std::begin(elements), std::end(elements), std::begin(elements), [c](auto i){
        return i*c;
    });

std::vector<int> items;
int last = items.back();

auto x = *std::crbegin(items);

auto ab = a;
ab.insert (ab.end (), b.begin (), b.end ());

std::string t = s.starts_with(p) ? s.substr(p.size()) : s;

auto utf8len(std::string_view const& s) -> size_t
{
	std::setlocale(LC_ALL, "en_US.utf8");

	auto n = size_t{};
	auto size = size_t{};
	auto mb = std::mbstate_t{};

	while(size < s.length())
	{
		size += mbrlen(s.data() + size, s.length() - size, &mb);
		n += 1;
	}

	return n;
}

auto n = mymap.size();

s.emplace_back(x);

s.push_back(x);

m[k] = v;

template <typename T> struct Point {
  T x = {};
  T y = {};
};
template <typename T> struct Rectangle {
  Point<T> upper_left;
  Point<T> lower_right;
};
template <typename T>
Point<T> get_center(const Rectangle<T>& rect) {
  return {
    .x = (rect.upper_left.x + rect.lower_right.x) / 2,
    .y = (rect.upper_left.y + rect.lower_right.y) / 2,
  };
}

auto directory_contents(auto path) {
  auto iterator = std::filesystem::directory_iterator(path);
  return std::vector<std::filesystem::path>(
    std::ranges::begin(iterator),
    std::ranges::end(iterator)
  );
}

auto main(int argc, char** argv) -> int {
  auto path = argc >= 2
    ? std::filesystem::path(argv[1])
    : std::filesystem::current_path();

  for (auto entry : directory_contents(path)) {
    std::cout << entry.string() << std::endl;
  }
}

template <typename SeqT>
auto transform_copy_if(const SeqT i, auto p, auto f)
{
 using namespace std;

 SeqT o;

 for_each(begin(i), end(i),
          [&](const auto& x) {
              if(p(x))
               o.push_back(f(x));
          }
         );

 return o;
}

constexpr auto transform_matches(const auto& x, auto p, auto t) {
    auto result = x 
	| std::views::filter(p)
        | std::views::transform(t);

    std::vector<std::ranges::range_value_t<decltype(result)>> y;
    std::copy(result.begin(), result.end(), std::back_inserter(y));
    return y;
}

extern "C" void foo(double *a, int n);

if (std::any_of(a.begin(), a.end(), [x](auto y) { return y > x; }))
    f();

std::ifstream file (path);
for (std::string line; std::getline(file, line); lines.push_back(line)) {}

auto h = std::hypot(x, y);

const char* tmp = std::getenv("FOO");
std::string foo = tmp ? std::string(tmp) : "none";

#include <string>
using namespace std::string_literals;
#include <vector>
#include <memory>

struct t {
    std::string s;
    std::vector<int> n;
};

auto v = std::make_unique<t>(
    "Hello, world!"s,
    decltype(t::n){1, 4, 9, 16, 25}
);
v.reset();

// Automatically:
void fn(){
    auto v = std::make_unique<t>(
        "Hello, world!"s,
        decltype(t::n){1, 4, 9, 16, 25}
    );
}

namespace fs = std::filesystem;
fs::create_directory(path);

auto b = std::filesystem::is_directory(path);

std::tuple<float, std::string, bool> t(2.5f, "foo", false);

auto t = std::make_tuple(2.5f, std::string("foo"), false);

auto it = std::find(items.begin(), items.end(), x);
i = it == items.end() ? std::distance(items.begin(), it) : -1;

bool found = false;
for (const auto item : items) {
  if (item == "baz") {
    baz();
    found = true;
    break;
  }
}
if (!found) {
  DoSomethingElse();
}

if (std::any_of(items.begin(), items.end(), condition))
    baz();
else
    DoSomethingElse();

items.emplace_front(x);

items.push_front(x);

void f(std::optional<int> x = {}) {
  std::cout << (x ? "Present" + std::to_string(x.value()) : "Not Present");
}

void f(std::optional<int> x = {}) {
  if (x) {
    std::cout << "Present" << x.value();
  } else {
    std::cout << "Not present";
  }
}

items.pop_back();

int c = a ^ b;

std::array<std::byte, a.size()> c;
for (auto ia = a.begin(), ib = b.begin(); auto & rc : c) {
  rc = *ia++ ^ *ib++;
}

std::regex re("\\b\\d{3}\\b");
auto it = std::sregex_iterator(s.begin(), s.end(), re);
std::string x = it == std::sregex_iterator() ? "" : it->str();

std::for_each(x.begin(), x.end(), f);

for (auto e : x)
    f(e);

std::copy(a.begin(), a.end(), std::ostream_iterator<int>(std::cout, "\n"));

for (auto entry : m) {
	std::cout << entry.first << ": " << entry.second << "\n";
}

std::cout << x;

std::list<Foo> x;
x.remove_if(std::not_fn(p));

std::erase_if(x, std::not_fn(p));

int i = std::stoi(s, nullptr, 2);

x = condition() ? "a" : "b";

std::replace(x.begin(), x.end(), "foo", "bar");

for (int i = 5; i >= 0; --i) {
	std::cout << i;
}

std::vector<std::string> items;

s.reserve(v.size() * n);
for (size_t i = 0; i < n; ++i)
  s.append(v);

template<typename T>
void tst(T)
{
    using namespace std;

    // Strip away any references and pointer
    typedef remove_const<remove_pointer<decay<T>::type>::type>::type D;

    if(is_same<D, foo>::value)
    {
        cout << "same type" << endl;
    }
    else if(is_base_of<foo, D>::value)
    {
        cout << "extends type" << endl;
    }
    else
    {
        cout << "not related" << endl;
    }
}

for(int i = 1; i <= 100; i++)
{
    if((i % 15) == 0) std::cout << "FizzBuzz" << std::endl;
    else if((i % 5) == 0) std::cout << "Buzz" << std::endl;
    else if((i % 3) == 0) std::cout << "Fizz" << std::endl;
    else std::cout << i << std::endl;
}

for (int n=1; n<=100; n++) {
        string out="";
        if (n%3==0) {
            out=out+"Fizz";
        }
        if (n%5==0) {
            out=out+"Buzz";
        }
        if (out=="") {
            out=out+std::to_string(n);
        }
        cout << out << "\n";
    }

const size_t n = s.length() / 8;

vector<uint8_t> a(n);

for(size_t block = 0; block < n; block++)
{
    uint8_t acc = 0;
    const size_t start = block * 8;
    for(size_t offset = start; offset < start + 8; offset++)
    {
        acc = (acc << 1) + (s[offset] - '0');
    }

    a[block] = acc;
}

x.insert(e);

x.erase(e);

int main() {
    for (std::string line; std::getline(std::cin, line);) {
        std::cout << line << std::endl;
    }
    return 0;
}

for (auto it = m.begin(); it != m.end();) {
  if (!p(it->second)) {
    it = m.erase(it);
  } else {
    ++it;
  }
}

std::vector<int> a(n, 0);

a = std::numeric_limits<float>::quiet_NaN();
b = std::numeric_limits<float>::signaling_NaN();

b = x.find(e) != x.end();

std::string a{"Hello"};
std::string b{"world"};
auto s = a + b;

std::array a{1, 12, 42};

{
  std::stringstream _ss;
  auto iter = a.begin();
  _ss << *iter++;
  for (; iter != a.cend(); _ss << std::string_view(", ") << *iter++);
  std::cout << _ss.view();
}

using namespace std::literals;

enum T {
  case_0,
  case_1,
  case_2,
  case_4 = 4
};

std::optional<T> TryStrToEnum(std::string_view s) {
  if (str == "case_0"sv) return case_0;
  if (str == "case_1"sv) return case_1;
  if (str == "case_2"sv) return case_2;
  if (str == "case_4"sv) return case_4;
  return std::nullopt;
}

// This is a comment.

s = std::format("Our sun has {} planets", x);

b = m == n;

x.fill(v);

b = s.empty();

std::exchange(x, v);

auto t = std::chrono::milliseconds(std::chrono::system_clock::now().time_since_epoch()).count();

std::filesystem::rename(path1, path2);