template<class Derived>
class A
{
public:
    void method()
    {
        static_cast<Derived*>(this)->some_method();
    }
};

class B: A<B>
{
public:
    void some_method()
    {
        lala;
    }
};

class A: public vector<int>
{
public:
    A(): vector(init())
    {}

private:
    static vector<int> init()
    {
        return ...
    }
};

class A: public vector<double>
{
public:
    // Так не будет работать.
    A(double y): y_(y * y - std::sin(y)), vector({{y_, y_ + 1, y_ + 2}})
    {}

private:
    double y_;
};

class B_helper
{
public:
    B_helper(double y): y_(y * y - std::sqrt(y))
    {}

private:
    double y_;
};

class B: public B_helper, public vector<double>
{
public:
    B(double y): B_helper(y), vector({{y_, y_ + 1, y_ + 2}})
    {}
};

struct A
{
    void some_method();
    void another_method();
}

struct B: A
{
    void extra_method();
}

template<class V>
class A
{
public:
    template<class B>
    A(B x)
    { ... }
};

template<class B, V = deduce B>
A<V> make(B x)
{
    return A<V>(x);
}

template<class T>
class iterator
{
public:
    T& operator*() const
    {
        return *ptr_;
    }

private:
    T* ptr_;
};

class Lala
{
public:
    void method();
};

class Lala2: public Lala
{
public:
    void method()
    {
        // override
    }
};

class Lala3
{
public:
    void method()
    {
        // new implementation
    }
};

std::variant<Lala, Lala2, Lala3> obj = ...;
std::visit([](auto& x) { x.method(); }, obj)

test<ListType>():
    ListType l;
    l.add(44)
    CHECK(l.size() == 1)

DoubleList(List):
    add(x):
        List::add(x)
        List::add(x)

test<DoubleList>() // fail