#include <iostream>
#include <string>

template <typename T>

 T  func(T val, T deg){
  T sh;
  T res=1;
  T num=0;
  T degree=deg;
   __asm__ __volatile__ ( 
    "pushq %%rbx \t\n"
    "bsrq %1, %%rbx \t\n"
    "movq %%rbx, %0 \t\n"
    "popq %%rbx \t\n"
    : "=m" (num)
    : "m" (degree)
    : 
    );

  T tmp=1<<num;
   while(tmp>0)
    {
     sh=degree&tmp;
     tmp>>=1;
     res=(sh>0) ? res*res*val : res*res;
    };
 return res;
 };

int main(int c, char** s){
  unsigned long a=std::stoi(s[1]), b=std::stoi(s[2]);
  
  std::cout<<"Res=" <<func(a,b)<<"\n";
 };
  
............................

[g@localhost ~]$ ./x 2 63
Res=0

template <typename T>

 T  func(T val, T deg){
  T sh;
  T res=1;
  T num=0;
  T degree=deg;
   __asm__ __volatile__ ( 
    "pushq %%rbx \t\n"
    "bsrq %1, %%rbx \t\n"
    "movq %%rbx, %0 \t\n"
    "popq %%rbx \t\n"
    : "=m" (num)
    : "m" (degree)
    : 
    );

  T tmp=1<<num;
   while(tmp>0)
    {
     sh=degree&tmp;
     tmp>>=1;
     res=(sh>0) ? res*res*val : res*res;
    };
  std::cout<<"Yob\n"; /* добавка */
 return res;
 };

[g@localhost ~]$ ./x 2 63
Yob
Res=9223372036854775808

template<int X>
void func(...) {
   // делаем что-нибудь такое, что может
   // работать быстрее, если Х известно во 
   // время компиляции
}

template<unsigned Mask, typename UnsignedT>
UnsignedT SetBitsByMask(const UnsignedT var, const UnsignedT shiftedValue)
{
    return (~Mask & var) | (Mask & shiftedValue);
}

CG>template<int X>
CG>void func(...) {
CG>   // делаем что-нибудь такое, что может
CG>   // работать быстрее, если Х известно во 
CG>   // время компиляции
CG>}
CG>

template<int X>
int func() {
    return X;
}

CG>template<int X>
CG>void func(...) {
CG>   // делаем что-нибудь такое, что может
CG>   // работать быстрее, если Х известно во 
CG>   // время компиляции
CG>}
CG>

template<int X>
void func(...) {
   if (X>500) ...
   else if (X>50) ...
   else if (X>5) ...
   else if (X>0) ...
   else ...
}

int pow(int x, int y) {
    for (int i = 0; i < y; i++) {
        x *= x;
    }
}
pow(var, 3);

template<typename I, typename P>
I partition_point(I first, I last, P p)
{
    while(first != last)
    {
        I middle = next(first, distance(first, last)/2);
        if( p(*middle) )
            last = middle;
        else
            first = next(middle);
    }
    return first;
}

CG>Пока что местные программисты не смогли меня убедить в обратном

template<int N>
void calcuate_things(array<N> const& m)

void calculate_things(Value* m, size_t sz);

const size_t sz = ...;
calculate_things(pvalue, sz);

CG>template<int N>
CG>void calcuate_things(array<N> const& m)
CG>

template<int N>
Things calcuate(const Sequence<Vector<N>> &)
{
    // ...
    Vector<N> x = ... ;
    unordered_map<int, Vector<N>> y;
    // ...
}

template<class FwdIter>
class Foo {
....
void reset(FwdIter begin, FwdIter end) {
    std::vector<int> tmp(begin, end);
    std::swap(m_values, tmp);
    ...
}

void Foo::reset(std::vector<int> newvals) {
    std::swap(newvals, m_values);
}

EP>Ты как-то слишком ловко от частного "для non-type template parameters, в некоторых частных случаях, аналог без шаблонов даст иногда даст такой же результат, а в общем случае не лучше" переходишь к общему "очень часто компилятор может оптимизировать код без шаблонов не хуже"

CG>Ну это все сейчас умеют, даже студия

EP>>Я наоборот предпочёл бы использовать header-only библиотеку, так это многое упрощает — и так будет до тех пор, пока не появятся модули

CG>Ключевое слово "библиотеку" Если смотреть на это как application developer a не как library developer, то получается грусно.

EP>>Чем по твоей классификации отличаются простые алгоритмы от сложных? И почему по-твоему простые на шаблонах получается проще, а сложные — нет?

CG>В том то и дело что это не частные случаи. Ты можешь использовать шаблон для генерации более быстрого кода тогда, когда на этапе компиляции есть какая-нибудь информация и ты можешь развернуть какой-нибудь цикл или зафиксировать какой-нибудь параметр или избавиться от косвенного вызова через vtable, но то же самое компилятор делает постоянно и без твоей помощи, когда у него эта информация есть.

#include <functional>
using namespace std;

void foo(function<int(int, int)> x)
{
    volatile auto y = x(111, 222) + 555;
    (void)y;
}

void test_foo()
{
    foo([](int x, int y){ return x+y; });
}
/*********************************************/
template<typename F>
void bar(F x)
{
    volatile auto y = x(111, 222) + 555;
    (void)y;
}

void test_bar()
{
    bar([](int x, int y){ return x+y; });
}

_Z8test_foov:
.LFB1245:
    .cfi_startproc
    .cfi_personality 0x3,__gxx_personality_v0
    .cfi_lsda 0x3,.LLSDA1245
    pushq    %rbx
    .cfi_def_cfa_offset 16
    .cfi_offset 3, -16
    movl    $1, %edi
    subq    $48, %rsp
    .cfi_def_cfa_offset 64
    movq    $0, 32(%rsp)
.LEHB0:
    call    _Znwm
.LEHE0:
    leaq    16(%rsp), %rdi
    movl    $222, %edx
    movl    $111, %esi
    movq    %rax, 16(%rsp)
    movq    $_ZNSt17_Function_handlerIFiiiEZ8test_foovEUliiE_E9_M_invokeERKSt9_Any_dataii, 40(%rsp)
    movq    $_ZNSt14_Function_base13_Base_managerIZ8test_foovEUliiE_E10_M_managerERSt9_Any_dataRKS3_St18_Manager_operation, 32(%rsp)
    call    _ZNSt17_Function_handlerIFiiiEZ8test_foovEUliiE_E9_M_invokeERKSt9_Any_dataii
    leaq    16(%rsp), %rsi
    addl    $555, %eax
    movl    $3, %edx
    movl    %eax, 12(%rsp)
    movl    12(%rsp), %eax
    movq    %rsi, %rdi
    call    _ZNSt14_Function_base13_Base_managerIZ8test_foovEUliiE_E10_M_managerERSt9_Any_dataRKS3_St18_Manager_operation
    addq    $48, %rsp
    .cfi_remember_state
    .cfi_def_cfa_offset 16
    popq    %rbx
    .cfi_def_cfa_offset 8
    ret
.L20:
    .cfi_restore_state
    movq    32(%rsp), %rcx
    movq    %rax, %rbx
    testq    %rcx, %rcx
    je    .L19
    leaq    16(%rsp), %rsi
    movl    $3, %edx
    movq    %rsi, %rdi
    call    *%rcx
.L19:
    movq    %rbx, %rdi
.LEHB1:
    call    _Unwind_Resume
.LEHE1:
    .cfi_endproc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
_Z8test_barv:
.LFB1253:
    .cfi_startproc
    movl    $888, -4(%rsp)
    movl    -4(%rsp), %eax
    ret
    .cfi_endproc

CG>Я там в той теме отписывался, честно попытался воспроизвести кейс с помощью клэнга 3.6 но ничего не получилось, он генерит здоровую ф-ю, которая проверяет нет ли алиасинга и потом если его нет — использует быстрый векторизованый цикл иначе — более сложную и медленную реализацию. В месте вызова оно вообще инлайнилось и векторизировалось. Я не смог заставить clang сгенирировать плохой код с включенными оптимизациями (-O2)

int pow(int val, int y) {
    int res = 1;
    for (int i = 0; i < y; i++) {
        res *= val;
    }
    return res;
}

template<typename F, typename Result, typename ...Params>
Result concrete_wrapper(const void *f, Params... params)
{
    return (*static_cast<const F*>(f))(params...);
}

template<typename Signature>
class function_non_owning;

template<typename Result, typename ...Params>
class function_non_owning<Result(Params...)>
{
    const void *f = nullptr;
    Result (*wrapper)(const void *, Params...) = nullptr;
public:
    function_non_owning() = default;

    template<typename F>
    function_non_owning(const F &f)
        : f(&f), wrapper(&concrete_wrapper<F, Result, Params...>)
    {}

    Result operator()(Params... params) const
    {
        return wrapper(f, params...);
    }
};

// Example of usage:

void baz(function_non_owning<int(int, int)> x)
{
    volatile auto y = x(111, 222) + 555;
    (void)y;
}

void test_baz()
{
    baz([](int x, int y){ return x+y; });
}

_Z8test_bazv:
.LFB4:
    .cfi_startproc
    movl    $888, -4(%rsp)
    movl    -4(%rsp), %eax
    ret
    .cfi_endproc

CG>Пожалуй это можно признать примером действительно практичной оптимизации с использованием шаблонов, исключением из правила

int main()
{
    delete [] new char[0x555];
}

0000000000400510 <main>:
  400510:    48 83 ec 08              sub    $0x8,%rsp
  400514:    bf 55 05 00 00           mov    $0x555,%edi
  400519:    e8 c2 ff ff ff           callq  4004e0 <_Znam@plt>
  40051e:    48 89 c7                 mov    %rax,%rdi
  400521:    e8 da ff ff ff           callq  400500 <_ZdaPv@plt>
  400526:    31 c0                    xor    %eax,%eax
  400528:    48 83 c4 08              add    $0x8,%rsp
  40052c:    c3                       retq