Lines Matching full:template
56 template <typename T> struct S1 {};
64 template <int N> struct S2 {};
71 template <bool B> struct S3 {};
90 template<typename T, typename U> void ft1(U u, T t) { }
92 template<typename T> void ft2(T t, void (*)(T), void (*)(T)) { }
94 template<typename T, typename U = S1<T> > struct S4 { };
95 template<typename T> void ft3(S4<T>*) { }
98 template<typename T> void ft1(T) { }
116 template<int I> struct S5 { };
118 template<int I> void ft4(S5<I>) { }
150 template<typename T> struct S6 {
154 template<typename T> void ft5(typename S6<T>::B) { }
156 template void ft5<int>(int);
158 template<typename T> class A {};
161 template<typename T> bool operator==(const A<T>&, const A<T>&) { return true; }
165 template bool NS::operator==(const ::A<char>&, const ::A<char>&);
168 template<typename T> bool operator==(const A<T>&, const A<T>&) { return true; }
172 template bool std::operator==(const ::A<char>&, const ::A<char>&);
178 template <typename T> typename T::U ft6(const T&) { return 0; }
181 template int ft6<S>(const S&);
183 template<typename> struct __is_scalar_type {
187 template<bool, typename> struct __enable_if { };
189 template<typename T> struct __enable_if<true, T> {
194 template<typename T> typename __enable_if<__is_scalar_type<T>::__value, void>::__type ft7() { }
197 template void ft7<int>();
199 template void ft7<void*>();
225 template<typename T> typename __enable_if<(__is_scalar_type<T>::__value), void>::__type ft8() { }
227 template void ft8<int>();
229 template void ft8<void*>();
233 template<typename> struct __is_scalar_type {
237 template<bool, typename> struct __enable_if {};
238 template<typename T> struct __enable_if<true, T> { typedef T __type; };
239 template<typename T>
251 template <int i> void f1(int (*)[(-i) + 2]) { };
252 template void f1<1>(int (*)[1]);
255 template <int i> void f2(int (*)[+i]) { };
256 template void f2<1>(int (*)[1]);
261 template <int i> void f3(int (*)[i+i]) { };
262 template void f3<1>(int (*)[2]);
265 template <int i> void f4(int (*)[2 + i+i]) { };
266 template void f4<1>(int (*)[4]);
270 template <bool b> void f4(int (*)[b ? 1 : 2]) { };
271 template void f4<true>(int (*)[1]);
294 template<bool> class P;
295 template<> class P<true> {};
297 template<template <bool> class, bool>
300 template<typename T, typename = Policy<P, true> > class Alloc
306 template class Alloc<char>;
327 template <class T> void f(T, char (&buffer)[sizeof(ovl(T()))]) {}
343 template <class T> void g(char (&buffer)[sizeof(T() + 5.0f)]) {}
350 template <class T> void h(char (&buffer)[sizeof(T() + 5.0)]) {}
357 template <class T> void j(char (&buffer)[sizeof(T().buffer)]) {}
365 template <class T> void k(char (&buffer)[sizeof(T() + 0.0f)]) {}
375 template<typename T> struct X { };
376 template<template<class> class Y, typename T> void f(Y<T>) { }
378 template void f(X<int>);
386 template <class T> decltype(((T*) 0)->member) read_member(T& obj) {
406 template <class T> decltype(((T*) 0)->Path1::ab) get_ab_1(T &ref) { return ref.Path1::ab; }
409 template <class T> decltype(((T*) 0)->Path2::ab) get_ab_2(T &ref) { return ref.Path2::ab; }
412 template <class T> decltype(((T*) 0)->Path1::p) get_p_1(T &ref) { return ref.Path1::p; }
415 template <class T> decltype(((T*) 0)->Path2::p) get_p_2(T &ref) { return ref.Path2::p; }
429 template <int (foo::*)>
437 template <int *>
445 template <int (foo::*)()>
453 template <int (*f)()>
460 template <int &counter> class A { void inc() { counter++; } };
462 template class A<B::value>;
466 template<class T>
473 template <class zaz, class zed>
482 template <char P1> struct S {};
483 template <char P2> void f(struct S<false ? 'a' : P2> ) {}
486 template void f<(char) 3>(struct S<3>);
504 template <unsigned short> struct A { };
510 template <template <class> class T> class A {};
511 template <class U> class B {};
513 template <template<class> class T> void foo(const A<T> &a) {}
516 template void foo(const A<B> &a);
533 template <int I> struct S {};
535 template <int I> void f(S<I + e>) {}
538 template void f<7>(S<7 + e>);
543 template <int N> struct A {};
549 template <class T> A<sizeof(T::foo())> func(void);
566 template <int (A::*)()> struct S {};
568 template <typename T> void f(S<&T::operator+>) {}
569 template void f<A>(S<&A::operator+>);
571 template <typename T> void f(S<&T::operator- >) {}
572 template void f<A>(S<&A::operator- >);
574 template <typename T> void f(S<&T::operator*>) {}
575 template void f<A>(S<&A::operator*>);
577 template <typename T> void f(S<&T::operator&>) {}
578 template void f<A>(S<&A::operator&>);
589 template <typename T> int f();
592 template <typename T> int operator-();
595 template <int (A::*)()> struct S {};
597 template <typename T> void g (S<&T::template f<int> >) {}
598 template <typename T> void g (S<&T::operator+ >) {}
599 template <typename T> void g (S<&T::operator int>) {}
600 template <typename T> void g (S<&T::template operator- <double> >) {}
603 template void g<A>(S<&A::f<int> >);
605 template void g<A>(S<&A::operator+>);
607 template void g<A>(S<&A::operator int>);
609 template void g<A>(S<&A::operator-<double> >);
613 template <class T> T *f(const T&);
614 template <class T> T *f(T*);
617 template <class T> void test0(decltype(f<T*>(0))) {}
618 template void test0<int>(decltype(f<int*>(0)));
621 template <class T> void test1(decltype(f<>(T()))) {}
622 template void test1<int>(decltype(f<>(int())));
664 template <void (*fn)()> struct A {
675 template <template <class> class T> void foo(decltype(T<float>::object) &object) {}
677 template <class T> struct holder { static T object; };
697 template <class T> void a(decltype(T::inner::object) &object) {}
698 template <class T> void b(decltype(T().Alias::meth()) &object) {}
711 template <class T> struct A {
715 template <class T> void foo(decltype(A<T>::A::bit) x);
723 // An enclosing template type parameter in an unresolved-name.
725 template <class T> struct A {
726 template <class U> static void foo(decltype(T::fn(U())) x);
736 // An enclosing template template parameter in an unresolved-name.
738 template <template <class> class T> struct A {
739 template <class U> static void foo(decltype(T<U>::fn()) x);
741 template <class T> struct B { static T fn(); };
751 template<class T> auto f1(T p)->decltype(x) { return 0; }
752 // The return type in the mangling of the template signature
754 template<class T> auto f2(T p)->decltype(p) { return 0; }
755 // The return type in the mangling of the template signature
758 template<class T> auto f3(T p)->decltype(g(p)) {}
761 template int f1(int);
763 template int f2(int);
765 template void f3(int);
770 template<typename T, int=T::value> struct A {
775 template <class T> typename A<T>::type foo() { return 0; }
783 template <class T> struct X {
787 template<typename T, int=X<T>::value> struct A {
792 template <class T> typename A<T>::type foo() { return 0; }
802 template<typename T>
806 template void f<int>(decltype(sizeof(1)));
809 template<unsigned N>
813 template void f2<4>(int (&)[4 + sizeof(int*)]);
817 template<unsigned long long N>
821 template void f3<4>(int (&)[4 + sizeof(int*)]);
824 // template arguments.
825 template<unsigned> struct A { };
827 template<typename T> void f4(::test34::A<sizeof(sizeof(decltype(T() + T())))>) { }
830 template void f4<int>(A<sizeof(sizeof(int))>);
836 template<typename U> A operator+(U) const;
839 template<typename T>
840 void f1(decltype(sizeof(&T::template operator+<int>))) {}
843 template void f1<A>(__SIZE_TYPE__);
847 template<unsigned> struct A { };
849 template<typename ...Types>
853 template A<2> f1(int, float);
865 template<typename T> void func(T) { }
886 template <typename T> void func(T) {}
895 template<typename T> void func(T) {}
916 template <int i, class T> struct foo {
917 template <class T2 = T> friend void func(foo x) {}
927 template <int i, template <class> class T> struct foo {
928 template <template <class> class T2 = T> friend void func(foo x) {}
931 template <class V> struct X {
940 template <int (foo::*)>
959 template <typename T>
961 template void f<S>(S::e *);
969 template <typename T>
971 template void f<S>(S::s *);
979 template <typename T>
981 template void f<S>(S::c *);
989 template <typename T>
991 template void f<S>(S::u *);
996 template <int>
999 template <template <int> class T>
1007 template <int>
1010 template <template <int> class T>
1018 template <typename T>
1020 template void fun<int>();
1022 template void fun<X>();
1024 template void fun<S1<int> >();
1028 template <typename T>
1033 template <typename T>
1035 template <typename U, typename T>
1037 template <typename U, typename T>
1039 template <typename T>
1041 template <typename T>
1043 template <template <typename T> class U>
1045 template <typename T>
1047 template <template <typename> class U>
1049 template void fun1<int>();
1051 template void fun2<S1<int>, int>();
1053 template void fun3<S1<int>, int>();
1055 template void fun4<int>();
1057 template void fun5<int>();
1059 template void fun6<S1>();
1061 template void fun7<E>();
1063 template void fun8<X>();
1069 template <typename... T>
