At an interview I was asked how to by a given vector of integers build resulting vector containing the products of all the elements except current. Below I provided my solution in C++:

#include <vector>
#include <iostream>

using V = std::vector<int>;

V func(const V& v)
{
    V result;
    result.resize(v.size());

    int product = 1;

    for (size_t pos = 0; pos != v.size(); ++pos)
    {
        result[pos] = product;

        int a = v[pos];
        product *= a;
    }

(more…)

It is possible to iterate over std::vector with &&:

#include <vector>

class A {};

int main()
{
    std::vector<A> vec;
    for (auto&& v : vec)
    {
        static_cast<void>(v);
    }

    return 0;
}

Links:

• What is the advantage of using forwarding references in range-based for loops?
• What does `auto && e` do in range-based for-loops?

I was recently asked during a C++ job interview what are the types of riN variables in the code below:

int val = 25;

int foo() { return val; }
int& foo1() { return val; }
//warning: type qualifiers ignored on function return type
/*const*/ int foo2() { return val; }
const int& foo3() { return val; }

int main()
{
  auto ri = foo(); 
  auto ri1 = foo1();
  auto ri2 = foo2();
  auto ri3 = foo3();

  //cannot bind non-const lvalue reference of type 'int&' to an rvalue of type 'int'
  //auto& ri4 = foo();
  auto& ri5 = foo1();
  //cannot bind non-const lvalue reference of type 'int&' to an rvalue of type 'int'
  //auto& ri6 = foo2();
  auto& ri7 = foo3();

  auto&& ri8 = foo();
  auto&& ri9 = foo1();
  auto&& ri10 = foo2();
  auto&& ri11 = foo3();
    
  return 0;
}

auto ignores the type qualifiers and references, so looks like the types are simply int, int& and int&&.

The code below compiles with a warning:

#include <iostream>
#include <limits>
#include <cstdint>

int main()
{  
    int64_t m1 = -std::numeric_limits<int64_t>::min();
    int64_t m2 = -m1;
    
    std::cout << m1 << std::endl << m2 << std::endl << std::numeric_limits<int64_t>::max() << std::endl;
    
    return 0;
}

(more…)

#include <iostream>

template <typename T>
void PrintValue(T val)
{
    if constexpr (std::is_signed_v<T>)
    {
        std::cout << "signed";
    }
    else
    {
        std::cout << "unsigned";
    }

    std::cout << std::endl << val << std::endl;
}

(more…)

At 10/20/2020:

And std::vector is not constexpr yet:

And there is no text formatting also.

Coroutines:

std::chrono::days:

See C++20 library features compiler support.

Consider the declaration of a class that contains a lambda function or a reference to it:

#include <utility>

template <class Func>
struct Holder
{
    Holder(Func && func) : m_func(std::forward<Func>(func))
    {
    }

    Func m_func;
};

template <class Func>
auto MakeHolder(Func && func)
{
    return Holder<Func>(std::forward<Func>(func));
}

(more…)