Theory questions 2017-05-29
1. A type that is contextually convertible to bool can be used as a boolean expression such as in an if-statement. To make your own type convertible, a type converting operator has to be implemented. bool is a special case in that even if the operator is marked explicit, the compiler can call it in a situation that requires a type that is contextually convertible.

struct My_Type
{
    explicit operator bool() const { return true; }
};

...

My_Type t;
if ( t )
{
    ...
}

2. A function-try-block is the only way of catching exceptions from initialization of data members:

struct S
{
    S() try : mem_{operation_that_can_throw()}
    {
        // ctor body
    }
    catch ( ... )
    {
        // handle exception
    }
    T mem_;
};
3. In C++17: No. Before c++17 there is one case where you are required to use class and that is with template template parameters:
    template < template <...> class cls >

4. Because of function call overload rules. A template function will never have its arguments converted by the compiler to match the call. A normal function overload is often better:

// primary template
template <typename T>
void fun(T t) { ... }

// specialization for int, will not be called with types
// convertible to int such as short and long
template<>
void fun<int>(int t) { ... }

// Normal function will be matched before using a template
void fun(int t) { ... }

5. You could use a pure virtual destructor in a base class if you want it to be abstract but have valid implementations for all other virtual functions (or have no other virtual functions). You still have to add an implementation for the destructor:
u

struct A
{
    virtual ~A() = 0;
};
A::~A() = default;