#include <iostream>

template <class T>
void print(const T&x) {
    std::cout << x << ' ';
};

template <class T, typename... types>
void print(const T& x, types... args) {
    print(x);
    print(args...);
}

template <typename... types>
void printLn(types... args) {
    print(args...);
    std::cout << std::endl;
}

int main(int argc, char** argv) {
    printLn ( 1, 2, 3, 4, "abc" , .2, "Lol");
}

nur will ich den ned selber bauen
und es scheinte keine builds für meine linux distro zu geben

Wollen die ernsthaft dermassen die Sprache vergewaltigen? Ellipzsen waren schon immer unschoen, und jetzt soll das noch als Template Parameter eingefuehrt werden? ich weiss ja nicht...

Wie bitte? Typsichere Ellipsen sind der Traum eines jeden C++-Programmierers

Das einzige was an Ellipsen unschön ist, ist dass die Anzahl und Typen der Argumente nicht bekannt sind (wobei "das einzige" hier das Wesen der Ellipse ausmacht). Das ist bei Templateellipsen aber nicht mehr der Fall, also wo liegt das Problem?

nachdem ich angefangen habe mit gcc 4.3 rumzuspielen kommt hier ein kleiner leckerbissen

#include <iostream>

template <class T>
void print(const T&x) {
    std::cout << x << ' ';
};

template <class T, typename... types>
void print(const T& x, types... args) {
    print(x);
    print(args...);
}

template <typename... types>
void printLn(types... args) {
    print(args...);
    std::cout << std::endl;
}

int main(int argc, char** argv) {
    printLn ( 1, 2, 3, 4, "abc" , .2, "Lol");
}

Na der gibt aber ein Leerzeichen zu viel aus. Wie wärs mit:

#include <iostream>

template <class T>
void print(const T&x) {
    std::cout << x;
};

template <class T, typename... types>
void print(const T& x, types... args) {
    print(x);
    std::cout << ' ';
    print(args...);
}

template <typename... types>
void printLn(types... args) {
    print(args...);
    std::cout << std::endl;
}

int main(int argc, char** argv) {
    printLn ( 1, 2, 3, 4, "abc" , .2, "Lol");
}

[ungetestet]

Das einzige was an Ellipsen unschön ist, ist dass die Anzahl und Typen der Argumente nicht bekannt sind (wobei "das einzige" hier das Wesen der Ellipse ausmacht). Das ist bei Templateellipsen aber nicht mehr der Fall, also wo liegt das Problem?

naja, halt listen, die als (head|tail) doch wieder verfummelbar sind, scheint mir.

denke da an

//nur konzept, gar ungetestet
template <class E>
struct Len{
   const int len=1;
};
template <class H, typename... T>
struct Len{
   const int len=1+Len<T>::len;
};
...
cout<< Len<1,3,6,5,7,"hui">::len ;

integers und strings sind keine typen

Was sind sie dann? Mädchen?

ronny schrieb:

integers und strings sind keine typen

Was sind sie dann? Mädchen?

Das war oberflächlich - lies ronnys Bemerkung nochmal. Der Einwand ist ja richtig, non-type und Templateargumente werden durch typename nicht erfasst und man kann auch nicht allgemein für sie spezialisieren. Zum Glück gibt es auch dafür eine Lösung:

//1:1 aus N2242
template<typename... Types>
struct count {
  static const int value = sizeof...(Types);
};

WeaponX2007 schrieb:

ronny schrieb:

integers und strings sind keine typen

Was sind sie dann? Mädchen?

Das war oberflächlich - lies ronnys Bemerkung nochmal. Der Einwand ist ja richtig, non-type und Templateargumente werden durch typename nicht erfasst und man kann auch nicht allgemein für sie spezialisieren. Zum Glück gibt es auch dafür eine Lösung:

//1:1 aus N2242
template<typename... Types>
struct count {
  static const int value = sizeof...(Types);
};

Ok versteh. Schaut sehr gut aus. Laut Bjarne ist der Standard ja x=9 due. Sind die template ellipsen schon fix drin?