Мета-програмування шаблонів

Хтось може мені пояснити, чому перший спосіб метапрограмування шаблону збирається нескінченним циклом, а другий працює правильно.

#include <iostream>
using namespace std;

template<int N, int M>
struct commondivs {                                              
  static const int val = (N<M) ? commondivs<N,(M-N)>::val : commondivs<(N-M),M>::val;
};

template<int N>
struct commondivs<N,N> {
  static const int val = N;
};


int commondiv(int N, int M){
    if(N==M){
        return N;
    }   
    return (N<M)?commondiv(N,(M-N)):commondiv((N-M),M);     
}

int main() {

    cout << commondivs<9,6>::val << endl;
    cout << commondiv(9,6) << endl;
    return 0;
}

(N<M) ? commondivs<N,(M-N)>::val : commondivs<(N-M),M>::val

Цей рядок викликає інстанціювання обох commondivs<N,(M-N)>::valі commondivs<(N-M),M>::val, навіть якщо умова відома під час компіляції, і одна з гілок ніколи не буде взята.

Замініть ? :на std::conditional_t, що не має цього обмеження:

static const int val = std::conditional_t<N < M, commondivs<N,(M-N)>, commondivs<(N-M),M>>::val;

Проблема в тому, що всі операнди умовного оператора будуть оцінені, тому обидва commondivs<N,(M-N)>і commondivs<(N-M),M>отримують інстанціювання, і їх valоцінюють, а потім призводять до рекурсивної інстанції шаблону.

Ви можете застосувати constexpr, якщо і поставити його у функцію constexpr staticчлена.

Якщо значення є true, тоді оператор-false відкидається (якщо він присутній), інакше твердження-істина відкидається.

template<int N, int M>
struct commondivs {                                              
  constexpr static int get_val() {
    if constexpr (N<M) return commondivs<N,(M-N)>::val; // if true, the else part won't be evaluated
    else return commondivs<(N-M),M>::val;               // vice versa
  }
  static const int val = get_val();
};

ЖИВИЙ

Потрійний оператор не схожий if constexpr: коли компілятор бачить це, він повинен генерувати код для обох гілок. Іншими словами, для інстанціювання шаблона commondivs<M, N>компілятор інстанціює і шаблони, commondivs<N, M - N>і commondivs<N - M, M>.

На відміну від цього, commondiv(N, M - N)і commondiv(N - M, M)переводяться на два виклики функції. Хто з них взятий, буде вирішено, коли функція буде фактично викликана.

Доповнення.

HolyBlackCat дав рішення с std::conditional_t. Ось ще одна:

template<int N, int M>
struct commondivs {                                              
    static constexpr int min = (N < M) ? N : M;
    static constexpr int max = (N < M) ? M : N;
    static constexpr int val = commondivs<min, max - min>::val;
};

template<int N>
struct commondivs<N, N> {
    static constexpr int val = N;
};

Ви отримуєте нескінченну рекурсію через:

static const int val = (N<M) ? commondivs<N,(M-N)>::val : commondivs<(N-M),M>::val;

- це зовсім не програмування ?:метатемблоків, оскільки , як говорить @Eng, це не так constexpr.

Ви хочете подивитися на відповідь @ HolyBlackCat.