Vorlagen-Meta-Programmierung

38

Kann mir jemand erklären, warum die erste Meta-Programmiermethode für Vorlagen in eine Endlosschleife geht, die zweite jedoch korrekt ausgeführt wird.

#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;
}
Exxul
quelle
2
Ziel war es, Template-Meta-Programmierung zu verwenden. constexprist keine Option.
Exxul
C ++ 98-Tag hinzugefügt, um deutlich zu machen, dass dies constexprkeine Option ist. (Es wurde in C ++ 11 eingeführt). Dadurch werden vorhandene Antworten ungültig. Exxul, bitte klären Sie, auf welche C ++ - Version Sie beschränkt sind.
MSalters
Entschuldigung, ich habe das Tag entfernt.
Exxul

Antworten:

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

Diese Zeile bewirkt die Instanziierung von beiden commondivs<N,(M-N)>::valund commondivs<(N-M),M>::val, selbst wenn die Bedingung zur Kompilierungszeit bekannt ist und einer der Zweige niemals genommen wird.

Ersetzen Sie ? :durch std::conditional_t, was diese Einschränkung nicht hat:

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

Das Problem ist , alle Operanden von Bedingungsoperator ausgewertet, so dass beide werden commondivs<N,(M-N)>und commondivs<(N-M),M>erhalten instanziiert und deren valget ausgewertet und dann führt zu rekursive Template - Instantiierung.

Sie können constexpr if anwenden und in eine constexpr staticMember-Funktion einfügen .

Wenn der Wert ist true, wird die Anweisung-false verworfen (falls vorhanden), andernfalls wird die Anweisung-true verworfen.

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

LEBEN

songyuanyao
quelle
Bewertet oder nur instanziiert?
Daniel McLaury
@ DanielMcLaury bewertet; nicht nur instanziiert.
Songyuanyao
Der Wert von ::valmuss in beiden Zweigen sicher generiert werden, dies ist jedoch immer noch eine Instanziierung (einer Vorlage mit einem statischen const-Element). Die Auswertung zur Laufzeit findet nicht statt ... nun, es kann offensichtlich nicht, da es nie kompiliert wird ...
Nutzlos
8

Der ternäre Operator ist nicht wie folgt if constexpr: Wenn ein Compiler ihn sieht, muss er Code für beide Zweige generieren. Mit anderen Worten, um eine Vorlage zu instanziieren, instanziiert commondivs<M, N>ein Compiler sowohl Vorlagen commondivs<N, M - N>als auch commondivs<N - M, M>.

Im Gegensatz dazu commondiv(N, M - N)und commondiv(N - M, M)werden in zwei Funktionsaufrufe übersetzt. Welche genommen wird, wird entschieden, wann die Funktion tatsächlich aufgerufen wird.

Zusatz.

HolyBlackCat gab eine Lösung mit std::conditional_t. Hier ist noch einer:

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;
};
Evg
quelle
0

Sie erhalten eine unendliche Rekursion, weil:

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

ist überhaupt keine Metatemplate-Programmierung, weil ?:, wie @Eng sagt, dies nicht der Fall ist constexpr.

Sie möchten sich die Antwort von @ HolyBlackCat ansehen.

Paul Evans
quelle
1
Es wird nicht helfen. ?:ist nicht constexpr.
Evg
Nein, ich versuche es. Die gleiche Endlosschleife.
Exxul