#include <iostream>

template<typename T>
class One {
public:
    One() {}
    ~One() {}
    void fn() { std::cout << "One<T>: primary" << std::endl; }
private:
    T _t;
};

template<>
class One<char> {
public:
    One() {}
    ~One() {}
    void fn() { std::cout << "One<char>: specialization" << std::endl; }
private:
    char _c;
};

template<typename T1, typename T2>
class Two {
public:
    Two() {}
    ~Two() {}
    void fn() { std::cout << "Two<T1, T2>: primary" << std::endl; }
private:
    T1 _t1;
    T2 _t2;
};

template<typename T>
class Two<T, char> {
public:
    Two() {}
    ~Two() {}
    void fn() { std::cout << "Two<T, char>: specialization" << std::endl; }
private:
    T _t;
    char _c;
};

template<typename T>
class Two<T, T*> {
public:
    Two() {}
    ~Two() {}
    void fn() { std::cout << "Two<T, T*>: specialization" << std::endl; }
private:
    T _t;
    T* _pt;
};

template<typename T>
class Two<T, T&> {
public:
    Two() {}
    ~Two() {}
    void fn() { std::cout << "Two<T, T&>: specialization" << std::endl; }
private:
    T _t;
};

template<typename T>
class Two<T, T[]> {
public:
    Two() {}
    ~Two() {}
    void fn() { std::cout << "Two<T, T[]>: specialization" << std::endl; }
private:
    T _t;
};

template<>
class Two<char, char*> {
public:
    Two() {}
    ~Two() {}
    void fn() { std::cout << "Two<char, char*>: specialization" << std::endl; }
private:
    char _c;
};

template<>
class Two<char, char&> {
public:
    Two() {}
    ~Two() {}
    void fn() { std::cout << "Two<char, char&>: specialization" << std::endl; }
private:
    char _c;
};

template<>
class Two<char, char[]> {
public:
    Two() {}
    ~Two() {}
    void fn() { std::cout << "Two<char, char[]>: specialization" << std::endl; }
private:
    char _c;
};

template<typename T1, size_t>
class TwoSz {
public:
    TwoSz() {}
    ~TwoSz() {}
    void fn() { std::cout << "TwoSz<T1, size_t>: primary" << std::endl; }
private:
    T1 _t1;
};

template<typename T>
class TwoSz<T, sizeof(int)> {
public:
    TwoSz() {}
    ~TwoSz() {}
    void fn() { std::cout << "TwoSz<T, sizeof(int)>: specialization" << std::endl; }
private:
    T _t1;
};

class Base1 {};
template<typename T1, size_t> class Base2 {};
template<typename T> class Derived : public Base1, Base2<T, sizeof(int)> {
public:
  Derived() {}
};

int main() {
    One<int> oneInt; oneInt.fn();
    One<char> oneChar; oneChar.fn();

    Two<int, int> twoIntInt;  twoIntInt.fn();
    Two<int, char> twoIntChar; twoIntChar.fn();

    Two<int, int*> twoIntIntP; twoIntIntP.fn();
    Two<int, int&> twoIntIntR; twoIntIntR.fn();
    Two<int, int[]> twoIntIntA; twoIntIntA.fn();

    Two<char, char*> twoCharCharP; twoCharCharP.fn();
    Two<char, char&> twoCharCharR; twoCharCharR.fn();
    Two<char, char[]> twoCharCharA; twoCharCharA.fn();

    TwoSz<int, 8> twoSzInt8; twoSzInt8.fn();
    TwoSz<int, sizeof(int)> twoSzIntSizeofI; twoSzIntSizeofI.fn();

    Derived<int> derived{};

    return 0;
}