Answers for theory questions 2018-01-08

a) I have found two.
    Deque
    vector<bool>

b) A function marked explicit forbids implicit conversion using that function. Is mostly used for type-converting constructors and conversion operators (functions that the compiler can use for implicit conversion).
    class Cls
    {
        explicit Cls(int);
    };
    bool operator<(Cls, Cls);

    Will forbid usage of that constructor for implicit conversion.

    if ( 4 < Cls{6} ) // requires a operator<(int, Cls) since the compiler can't implicitly transform 4 into Cls.

c) Base::foo()

d) Slicing is when we loose dynamic type information. Requires some kind of derivation and passing objects without pointer or reference.

  class Base { ... };
  class Derived : Base { ... };

  void fun(Base) { ... }

  int main()
  {
   Derived d;
   fun(d); // compiles but give slicing
  }

e) "A fold expression performs a fold of a template parameter pack over a binary operator" [expr.prim.fold, §8.1.6]

    We have a template pack and fold over some kind of operator (inject the operator between each element in the pack). Simple example to sum all values in a list:

    template <typename ... Args>
    int sum(Args ...args)
    {
        return ( args + ... );
    }

    sum(1,3,3.3,6);  // expands to (1 + (3 + (3.3 + (6))))