template T::T<5>();

template <size_t N> size_t array_size(const char (&s)[N])
{
    return N;
}
...
cout << array_size("123") // 4

template <int N> struct S {};

template <int N> int f(S<N> )
{
    return N;
}

cout << f( S<5>() ); // 5 

#include <iostream>
using namespace std;

template<size_t N>
struct inst {};

struct T {
    const size_t n;
    
    template<size_t N>
    T(inst<N>) : n(N) {
        if(N >= 10) cout << ">= 10" << endl;
        else cout << "< 10" << endl;
        // ... ещё десятки вызовов if, switch/case, #pragma unroll for, func<N>() и т.д., которые отработают compile-time
        cout << func<N>() << endl;;
    }
    
    template<size_t N>
    constexpr static int func() { /* ... */ return N; }
};

int main() {
    T t(inst<5>());
//    cout << "n = " << t.n << endl;
    
    return 0;
}

#include <iostream>
using namespace std;

template<size_t N>
struct T_inst {};

struct T {
    const size_t n;
    
    template<size_t N>
    T(T_inst<N>) : n(N) {
        if(N >= 10) cout << ">= 10" << endl;
        else cout << "< 10" << endl;
        // ... ещё десятки вызовов if, switch/case, #pragma unroll for, func<N>() и т.д., которые отработают compile-time
        cout << func<N>() << endl;;
    }
    
    template<size_t N>
    constexpr static int func() { /* ... */ return N; }
};

int main() {
    T_inst<5> inst;
    T t(inst);
    cout << "n = " << t.n << endl;
    
    return 0;
}

// шаблон
template <class Iter> void sort(Iter begin, Iter end);
// специализация с выведением типов
template<> void sort(char* begin, char* end)
{
  // альтернативная реализация
}
// специализация с явным указанием типов
template<> void sort<char*>(char* begin, char* end)
{
  // альтернативная реализация
}

#include <iostream>
#include <vector>
using namespace std;

template<template<typename> class T>
T<int> func() {
    T<int> t;
    return t;
}

//template<> 
//vector<int> func(); // специализация тоже не проходит

int main() {
    vector<int> a = func<vector>();

    return 0;
}

#include <iostream>
#include <vector>
using namespace std;

template<template<typename ...> class T>
T<int> func() {
    T<int> t;
    return t;
}

//template<> 
//vector<int> func(); // специализация тоже не проходит

int main() {
    vector<int> a = func<vector>();

    return 0;
}

#include <iostream>
#include <vector>
using namespace std;

template<template<typename, typename> class T>
T<int, allocator<int>> func() {
    T<int, allocator<int>> t;
    return t;
}

//template<> 
//vector<int> func(); // специализация тоже не проходит

int main() {
    vector<int> a = func<vector>();

    return 0;
}