Lines Matching full:template
20 template<class T, class U = typename T::type> class A : public T {}; // expected-error {{protected}} expected-error 2{{private}}
43 template<class T, class U = typename T::type> class A : public T {};
52 // to not treat the default template argument as a SFINAE context in C++98.
53 template<class T, class U = typename T::type> void f(T) {}
68 template<typename T> struct X {};
74 // template-id as we can make it.
141 template<int N> void g() { int arr[N != 1 ? 1 : -1]; }
142 template<> void g<2>() { }
144 template<typename T> struct S {
148 template<typename T> int S<T>::i[] = { 1 };
150 template<typename T> void S<T>::f() {
153 template<> int S<int>::i[] = { 1, 2 };
154 template void S<int>::f(); // uses g<2>(), not g<1>().
157 template<typename T> struct R {
161 template<typename T> int R<T>::arr[1];
162 template<typename T> void R<T>::f() {
165 template<> int R<int>::arr[2];
166 template void R<int>::f();
170 template<typename T> struct A {
180 template<class T> void f(T);
183 template<class T> void h(T);
184 template<class T> void i(T);
189 template<class T> void i(T);
195 template<> void h(int) { A::z(); }
198 template<> void i(int) { A::z(); }
200 template<> void f(int) { M::A::z(); }
234 template<typename T> void f(T, ...) { T::error; }
276 template<typename T> struct ptr {
280 template<typename T, typename P> void test(P p) {
287 template void test<int>(int*);
288 template void test<int>(ptr<int>);
289 template void test<X>(X*);
290 template void test<X>(ptr<X>);
292 template<typename T>
294 p->template Y<int>::~Y<int>();
298 p->template ~Y<int>(); // expected-error 2{{no member named '~typename Y<int>'}}
300 template<typename T> struct Y {};
301 template void test2(Y<int>*); // expected-note {{instantiation}}
302 template void test2(ptr<Y<int> >); // expected-note {{instantiation}}
313 template<typename T> using id = T;
314 struct A { template<typename T> using id = T; };
320 p->template id<int>::~id<int>(); // expected-error {{expected unqualified-id}}
321 q->template id<int>::~id<int>(); // expected-error {{expected unqualified-id}}
322 p->A::template id<int>::~id<int>();
323 q->A::template id<int>::~id<int>();
335 template<typename T, typename U> void f() {
339 template void f<int, int>();
340 template void f<int, char>(); // expected-note {{instantiation}}
344 template<typename T> struct X { operator T&(); };
373 struct A { template<typename T> operator T() const; } a;
376 template<typename T> struct is_float;
377 template<> struct is_float<float> { typedef void type; };
380 template<typename T, typename U = typename is_float<T>::type> operator T() const; // expected-error 0-1{{extension}}
399 template<typename T> T make();
443 template<typename T> T *get();
444 template<typename T> struct B {
445 template<typename U> U *get();
449 template<typename T> void f(A a) {
452 ->get<T>(); // expected-error {{use 'template'}}
453 a.get<T>()->template get<T>();
459 b->A::B<T>::get<int>(); // expected-error {{use 'template'}}
460 b->A::B<T>::template get<int>();
461 b->A::B<T>::get<T>(); // expected-error {{use 'template'}}
462 b->A::B<T>::template get<T>();
464 c->get<int>(); // expected-error {{use 'template'}}
465 c->template get<int>();
470 template<typename T> struct A {};
471 template<typename T> struct B : A<B> {}; // expected-error {{requires template arguments}} expected-note {{declared}}
472 template<typename T> struct C : A<C<T> > {};
474 template<typename T> struct D : decltype(A<D>()) {}; // expected-error {{requires template arguments}} expected-note {{declared}}
479 template<class T> struct S {
483 template<class T> void S<T>::f(union U*) {}
508 template<typename U> struct T : U {};
567 template<int> struct U {
569 template<typename V> static void h();
571 template<typename T> U<sizeof(T)> g(T);
572 template<typename T, int N> void f(int n) {
588 template<typename T = int> void f(int); // expected-error 0-1{{extension}} expected-note {{no known conversion}}
589 template<typename T> void g(T t) {
590 f<T>(t); // expected-error {{neither visible in the template definition nor found by argument-dependent lookup}}
593 template<typename T> void f(T); // expected-note {{should be declared prior to the call site}}
595 template void g(int); // ok
596 template void g(HideFromADL::X); // expected-note {{instantiation of}}
670 template<typename> int g();
673 template<typename> struct B : A {
675 template<typename> int g();
676 template<typename> int h();
682 template<typename T>
684 return T; // FIXME: this is invalid, it finds the template parameter
687 template<typename T>
691 template<typename T> template<typename U>
695 template<typename U> template<typename T>
697 return T; // FIXME: this is invalid, it finds the template parameter
768 template<typename> struct A {
769 template<typename> struct B {
773 int k = dr468::template A<int>::template B<char>::C;
775 // expected-error@-2 2{{'template' keyword outside of a template}}
781 // deduce 'const T' from a function or reference type in a class template...
782 template<typename T> struct X; // expected-note 2{{here}}
783 template<typename T> struct X<const T> {};
787 // ... but we do in a function template. GCC and EDG fail deduction of 'f'
789 template<typename T> void f(const T *);
790 template<typename T> void g(T *, const T * = 0);
791 template<typename T> void h(T *) { T::error; }
792 template<typename T> void h(const T *);
801 template<typename T> struct A {
804 template<typename T> struct C {
807 template struct A<int>; // expected-note {{previous}}
808 template struct A<int>::B; // expected-error {{duplicate explicit instantiation}}
811 template struct A<char>;
812 template struct C<char>;
922 template<class T, T U> class A { T *x; };
925 template<class T *U> class B { T *x; };
929 template<class T> void f(class D *p);
933 template<typename A = C, typename C = A> struct E {
939 template struct E<>; // ok
940 template struct E<int>; // expected-note {{instantiation of}}
942 template<template<typename U_no_typo_correction> class A,
949 template<template<class H *> class> struct G {
955 template<N X, typename N, template<N Y> class T> struct I;
956 template<char*> struct J;
1051 template<typename T> int f(S);
1053 template<typename T> int f();
1061 template<typename T> T f(T *); // expected-note 2{{substitution failure}}
1082 template <typename T> void f(T);
1086 // allowing local types as template arguments. In C++98, we should either
1087 // allow local types as template arguments or treat this as a SFINAE
1100 template<typename T> struct X {};
1112 template<typename T> T k();
1148 template <class T> operator const T &() const;
1170 template<typename T>
1173 template<typename U> operator U();
1178 template<typename T>
1180 template<typename U> operator U();
