typunabhängige variadische Funktionsvorlagen in C++11

Ich sah ein Blogeintrag die typunabhängige variadische Vorlagen verwendet (derzeit nicht von gcc unterstützt, nur von clang).

template <class T, size_t... Dimensions>
struct MultiDimArray { /* ... */ };

Das Beispiel im Beitrag lässt sich gut kompilieren, aber ich habe es nicht geschafft, es mit Funktionsvorlagen zum Laufen zu bringen.

Kann jemand helfen, die korrekte Syntax herauszufinden (falls vorhanden)?

int max(int n) { return n; } // end condition

template <int... N> // replacing int... with typename... works
int max(int n, N... rest) // !! error: unknown type name 'N'
{
    int tmp = max(rest...);
    return n < tmp? tmp : n;
}

#include <iostream>
int main() 
{
   std::cout << max(3, 1, 4, 2, 5, 0) << std::endl;   
}

Sie verwechseln einfach Typnamen und Nichttypnamen. Was Sie wollen, funktioniert einfach nicht.

Sie kann Verwenden Sie wahrscheinlich variadische Nicht-Typ-Vorlagen in Funktionen, aber nicht als (Nicht-Vorlagen-)Argumente:

template <int N, int... Rest>
int max()
{
    int tmp = max<Rest...>();
    return N < tmp ? tmp : N;
}

std::cout << max<3, 1, 4, 2, 5, 0>() << std::endl;

… obwohl ich das nicht getestet habe und mir nicht sicher bin wie Dies sollte funktionieren, da Sie als Basisfall eine Teilspezialisierung benötigen. Sie könnten dies lösen, indem Sie an eine teilweise spezialisierte Struktur senden:

template <int N, int... Rest>
struct max_t {
    static int const value = max_t<Rest...>::value > N ? max_t<Rest...>::value : N;
};

template <int N>
struct max_t<N> {
    static int const value = N;
};


template <int... NS>
int max()
{
    return max_t<NS...>::value;
}

Das wird funktionieren.

Dadurch werden alle Elemente ausgedruckt, get max könnte ähnlich implementiert werden

template <int N>
void foo(){
  cout << N << endl;
}

template <int N, int M, int ... Rest>
void foo(){
  cout << N << endl;
  foo<M, Rest...>();
}


int main(){
  foo<1, 5, 7>();

  return 0;
}

Hier sind zwei Möglichkeiten, eine variadische Funktionsvorlage zu definieren, die nur akzeptiert int Parameter. Der erste erzeugt bei der Instanziierung einen harten Fehler, der zweite verwendet SFINAE:

template<typename... T>
struct and_: std::true_type {};

template<typename First, typename... Rest>
struct and_
: std::integral_constant<
    bool
    , First::value && and_<Rest...>::value
> {};

template<typename... T>
void
foo(T... t)
{
    static_assert(
        and_<std::is_same<T, int>...>::value
        , "Invalid parameter was passed" );
    // ...
}

template<
    typename... T
    , typename = typename std::enable_if<
        and_<std::is_same<T, int>...>::value
    >::type
>
void
foo(T... t)
{
    // ...
}

Wie Sie sehen, werden hier keine typfremden Vorlagenparameter verwendet.

Die Lösung von Luc Danton verhält sich nicht korrekt mit Parametern, die nicht vom Typ sind int, kann aber implizit in an . umgewandelt werden int. Hier ist eine, die tut:

template<typename T, typename U> struct first_type { typedef T type; };
template<typename T> int max_checked(T n) { return n; }
template<typename T1, typename T2, typename ...Ts>
int max_checked(T1 n1, T2 n2, Ts ...ns)
{
  int maxRest = max_checked(n2, ns...);
  return n1 > maxRest ? n1 : maxRest;
}
template<typename ...T> auto max(T &&...t) ->
  decltype(max_checked<typename first_type<int, T>::type...>(t...))
{
  return max_checked<typename first_type<int, T>::type...>(t...);
}

struct S { operator int() { return 3; } };
int v = max(1, 2.0, S()); // v = 3.

Hier, max leitet alle Argumente unverändert an . weiter max_checked, das die gleiche Anzahl von Argumenten vom Typ . akzeptiert int (bereitgestellt durch Durchführen einer Pack-Erweiterung auf dem first_type Schablone). Der decltype(...) Rückgabetyp wird verwendet, um SFINAE anzuwenden, wenn ein Argument nicht konvertiert werden kann in int.

So erreichen Sie variadische Argumente in Ihrem max Beispiel so, dass es eine beliebige Anzahl von arithmetischen Argumenten annehmen kann:

template<typename T, typename ... Ts>
struct are_arithmetic{
    enum {
        value = std::is_arithmetic<T>::value && are_arithmetic<Ts...>::value
    };
};

template<typename T>
struct are_arithmetic<T>{
    enum {
        value = std::is_arithmetic<T>::value
    };
};

template<typename Arg, typename = typename std::enable_if<std::is_arithmetic<Arg>::value>::type>
Arg max(Arg arg){
    return arg;
}

template<typename Arg, typename Arg1, typename ... Args, typename = typename std::enable_if<are_arithmetic<Arg, Arg1, Args...>::value>::type>
auto max(Arg arg, Arg1 arg1, Args ... args){
    auto max_rest = max(arg1, args...);
    return arg > max_rest ? arg : max_rest;
}

int main(){
    auto res = max(1.0, 2, 3.0f, 5, 7l);
}

Dies ist gut, da es jeden numerischen Typ annehmen kann und die maximale Zahl nach ihrem ursprünglichen Typ zurückgibt, anstatt nur int, auch.