web-dev-qa-db-fra.com

Modèle de méta-programmation

Quelqu'un peut-il m'expliquer pourquoi la première méthode de méta-programmation de modèle va en boucle infinie, mais la seconde fonctionne correctement.

#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;
}
c++templatestemplate-meta-programming
38
Exxul
(N<M) ? commondivs<N,(M-N)>::val : commondivs<(N-M),M>::val

Cette ligne provoque l'instanciation de commondivs<N,(M-N)>::val et commondivs<(N-M),M>::val, même si la condition est connue au moment de la compilation et qu'une des branches ne sera jamais prise.

Remplacez ? : Par std::conditional_t, Qui n'a pas cette limitation:

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

Le problème est que tous les opérandes de l'opérateur conditionnel seront évalués, donc commondivs<N,(M-N)> et commondivs<(N-M),M> seront instanciés et leurs val seront évalués puis conduira à l'instanciation récursive du modèle.

Vous pouvez appliquer constexpr if et le placer dans une fonction membre constexprstatic.

Si la valeur est true, alors false-instruction est ignorée (si elle est présente), sinon, true-instruction est ignorée.

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();
};

EN DIRECT

15
songyuanyao

L'opérateur ternaire n'est pas comme if constexpr: Quand un compilateur le voit, il doit générer du code pour les deux branches. En d'autres termes, pour instancier un modèle commondivs<M, N>, Un compilateur instancie les deux modèles commondivs<N, M - N> Et commondivs<N - M, M>.

Contrairement à cela, commondiv(N, M - N) et commondiv(N - M, M) sont traduits en deux appels de fonction. Laquelle est prise sera décidée lorsque la fonction sera effectivement appelée.

Ajout.

HolyBlackCat a donné une solution avec std::conditional_t. En voici un autre:

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;
};
8
Evg

Vous obtenez une récursion infinie car:

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

n'est pas du tout un méta-modèle car ?:, comme le dit @Eng, n'est pas constexpr.

Vous voulez regarder la réponse de @ HolyBlackCat.

0
Paul Evans