#include <algorithm>
#include <vector>

// make extensive use of generic features
template<typename T1,
         typename T2>
inline
auto
helper_1(const T1 &a,
         const T2 &it_begin,
         const T2 &it_end)
{
  T1 result{};
  std::for_each(it_begin, it_end,
    [&](const auto &value)
    {
      result+=a*value;
    });
  return result;
}

// only rely on hardcoded features
inline
double
helper_2(double a,
         const double *ptr_begin,
         const double *ptr_end)
{
  double result=0.0;
  for(const double *ptr=ptr_begin; ptr!=ptr_end; ++ptr)
  {
    result+=a*(*ptr);
  }
  return result;
}

// perform a computation with the generic helper
double
use_1(double a,
      const std::vector<double> &values)
{
  return helper_1(a, cbegin(values), cend(values));
}

// perform the same computation with the hardcoded helper
double
use_2(double a,
      const std::vector<double> &values)
{
  return helper_2(a, data(values), data(values)+size(values));
}

use_1(double, std::vector<double, std::allocator<double> > const&):
        mov     rdx, QWORD PTR [rdi+8]
        mov     rax, QWORD PTR [rdi]
        movapd  xmm2, xmm0
        pxor    xmm0, xmm0
        cmp     rax, rdx
        je      .L4
.L3:
        movsd   xmm1, QWORD PTR [rax]
        add     rax, 8
        cmp     rax, rdx
        mulsd   xmm1, xmm2
        addsd   xmm0, xmm1
        jne     .L3
        rep ret
.L4:
        rep ret

use_2(double, std::vector<double, std::allocator<double> > const&):
        mov     rax, QWORD PTR [rdi]
        mov     rdx, QWORD PTR [rdi+8]
        movapd  xmm2, xmm0
        pxor    xmm0, xmm0
        cmp     rdx, rax
        je      .L10
.L9:
        movsd   xmm1, QWORD PTR [rax]
        add     rax, 8
        cmp     rax, rdx
        mulsd   xmm1, xmm2
        addsd   xmm0, xmm1
        jne     .L9
        rep ret
.L10:
        rep ret

#include <iostream>

int
fact(int n)
{
  return n<=1 ? 1 : fact(n-1)*n;
}

#if 1 // enable unit tests

# define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
# include "doctest.h"
TEST_CASE("testing the factorial function")
{
  CHECK(fact(0) == 1);
  CHECK(fact(1) == 123); // should fail
  CHECK(fact(2) == 2);
  CHECK(fact(3) == 6);
  CHECK(fact(10) == 3628800);
}

#else  // produce a usual program

int
main()
{
  for(int i=1; i<=10; ++i)
  {
    std::cout << "fact(" << i << ")=" << fact(i) << '\n';
  }
  return 0;
}

#endif

#include <chrono>

double // seconds (1e-6 precision) since 1970/01/01 00:00:00 UTC
get_time()
{
  const auto now=std::chrono::system_clock::now().time_since_epoch();
  const auto us=std::chrono::duration_cast<std::chrono::microseconds>(now);
  return 1e-6*double(us.count());
}

const double t0=get_time();
// ... compute something ...
const double t1=get_time();
std::cout << t1-t0 << " seconds elapsed\n";

#include <random>
#include <vector>
#include <algorithm> // std::shuffle()

//-- create and seed a general purpose random generator --
std::default_random_engine rnd_gen{std::random_device{}()};

//-- create a uniform distribution of integer values in [0;255] --
std::uniform_int_distribution<int> uni_dist{0, 255};

//-- draw a random integer value --
const int guess_that_integer=uni_dist(rnd_gen);

//-- create a normal distribution of real values (mean=7.0, stddev=2.5) --
std::normal_distribution<double> normal_dist{7.0, 2.5};

//-- draw a random real value --
const double guess_that_real=normal_dist(rnd_gen);
std::cout << guess_that_integer << ' ' << guess_that_real << '\n';

//-- shuffle a sequence of values --
std::vector<int> seq={0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
std::shuffle(begin(seq), end(seq), rnd_gen);
for(const auto &elem: seq)
{
  std::cout << elem << ' ';
}
std::cout << '\n';

struct MyType
{
  int member;

  MyType(float value) : member{int(value)} { }

  explicit MyType(std::string txt) : member{std::stoi(txt)} { }

  operator float() const { return float(member); }

  explicit operator std::string() const { return std::to_string(member); }
};

const float f1=12.34f;
const std::string s1="456";

const MyType mt_f=f1; // OK, implicit float-->MyType conversion
// const MyType mt_s=s1; // error, no implicit std::string-->MyType conversion
const MyType mt_s=MyType{s1}; // OK, explicit std::string-->MyType conversion

const float f2=mt_f; // OK, implicit MyType-->float conversion
// const std::string s2=mt_s; // error, no implicit MyType-->std::string conversion
const std::string s2=std::string(mt_s); // OK, explicit MyType-->std::string conversion