Vorlage Metaprogrammierung: Multiplikation einer Reihe von Vorlagenargumenten

Question

Ich muss das Produkt einer Reihe von Zahlen zur Kompilierzeit berechnen, die an eine Vorlagenstruktur übergeben wird. Es gelang mir, eine hässlich Lösung zu machen:

template<std::size_t n1, std::size_t ...args> 
struct mul_all 
{ 
    static constexpr std::size_t value = n1 * mul_all<args...>; 
}; 
template<> 
struct mul_all<0> 
{ 
    static constexpr std::size_t value = 1; 
}; 

Das Problem ist, dass jedes Mal, wenn ich 0 bis Template args wie so zu meinem struct

int main() 
{ 
    std::cout << mul_all<1,2,5,4,5,7,0>::value << " " 
       << mul_all<4,2,0>::value; 
    return 0; 
} 

einzuspeisen Gibt es eine Problemumgehung, um von der letzten Null gelesen zu bekommen?

Hinweis: Ich bin ein Anfänger in TMP.

Answer 1

In C++ 17, mit Ausdruck Falten, können Sie direkt zu tun

template<std::size_t ...args> 
struct mul_all 
{ 
    static constexpr std::size_t value = (args * ...); 
}; 

Vorher haben Sie die Teil-Spezialisierung zu tun:

template<std::size_t n1, std::size_t ...args> 
struct mul_all 
{ 
    static constexpr std::size_t value = n1 * mul_all<args...>::value; 
}; 

template<std::size_t n> 
struct mul_all<n> 
{ 
    static constexpr std::size_t value = n; 
}; 

Answer 2

Sie benötigen eine Spezialisierung ersetzen:

template<std::size_t n1, std::size_t ...args> 
struct mul_all 
{ 
    static constexpr std::size_t value = n1 * mul_all<args...>::value; 
}; 

template<std::size_t n> 
struct mul_all<n> 
{ 
    static constexpr std::size_t value = n; 
}; 

Answer 3

Eine Möglichkeit für leere varargs spezialisiert ist. Für, dass Sie die Hauptvorlage benötigen nur variadische args zu sein:

// main template never used 
template<std::size_t ...args> struct mul_all 
{ 
}; 

// specialization for at least one arg 
template<std::size_t n1, std::size_t ...args> 
struct mul_all<n1, args...> 
{ 
    static constexpr std::size_t value = n1 * mul_all<args...>::value; 
}; 

// specialization for empty args 
template<> 
struct mul_all<> 
{ 
    static constexpr std::size_t value = 1; 
}; 

So, jetzt können Sie tun:

Answer 4

Der Ansatz 17 C++, dass schön und einfach:

template <std::size_t... A> 
constexpr std::size_t mul = (A * ... * std::size_t(1u)); 

int main() { 
    constexpr std::size_t val = mul<1, 2, 3, 4>; 
} 

Für bestehende C++ Versionen, die Sie teilweise den Fall benötigen mul<v> zu spezialisieren: für Kicks

template <std::size_t... V> struct mul; 
template <std::size_t V> struct mul { 
    statuc constexpr std::size_t value = V; 
}; 
template <std::size_t V, std::size_t... T> struct mul { 
    statuc constexpr std::size_t value = V * mul<T...>::value; 
}; 
template <std::size_t... V> 
using mul_v = mul<V...>::value; 

int main() { 
    constexpr std::size_t v = mul_v<1, 2, 3, 4>; 
}