Lines Matching full:template
56 template <typename T> struct S1 {};
64 template <int N> struct S2 {};
71 template <bool B> struct S3 {};
93 template<typename T, typename U> void ft1(U u, T t) { }
95 template<typename T> void ft2(T t, void (*)(T), void (*)(T)) { }
97 template<typename T, typename U = S1<T> > struct S4 { };
98 template<typename T> void ft3(S4<T>*) { }
101 template<typename T> void ft1(T) { }
119 template<int I> struct S5 { };
121 template<int I> void ft4(S5<I>) { }
153 template<typename T> struct S6 {
157 template<typename T> void ft5(typename S6<T>::B) { }
159 template void ft5<int>(int);
161 template<typename T> class A {};
164 template<typename T> bool operator==(const A<T>&, const A<T>&) { return true; }
168 template bool NS::operator==(const ::A<char>&, const ::A<char>&);
171 template<typename T> bool operator==(const A<T>&, const A<T>&) { return true; }
175 template bool std::operator==(const ::A<char>&, const ::A<char>&);
181 template <typename T> typename T::U ft6(const T&) { return 0; }
184 template int ft6<S>(const S&);
186 template<typename> struct __is_scalar_type {
190 template<bool, typename> struct __enable_if { };
192 template<typename T> struct __enable_if<true, T> {
197 template<typename T> typename __enable_if<__is_scalar_type<T>::__value, void>::__type ft7() { }
200 template void ft7<int>();
202 template void ft7<void*>();
228 template<typename T> typename __enable_if<(__is_scalar_type<T>::__value), void>::__type ft8() { }
230 template void ft8<int>();
232 template void ft8<void*>();
236 template<typename> struct __is_scalar_type {
240 template<bool, typename> struct __enable_if {};
241 template<typename T> struct __enable_if<true, T> { typedef T __type; };
242 template<typename T>
254 template <int i> void f1(int (*)[(-i) + 2]) { };
255 template void f1<1>(int (*)[1]);
258 template <int i> void f2(int (*)[+i]) { };
259 template void f2<1>(int (*)[1]);
264 template <int i> void f3(int (*)[i+i]) { };
265 template void f3<1>(int (*)[2]);
268 template <int i> void f4(int (*)[2 + i+i]) { };
269 template void f4<1>(int (*)[4]);
273 template <bool b> void f4(int (*)[b ? 1 : 2]) { };
274 template void f4<true>(int (*)[1]);
297 template<bool> class P;
298 template<> class P<true> {};
300 template<template <bool> class, bool>
303 template<typename T, typename = Policy<P, true> > class Alloc
309 template class Alloc<char>;
330 template <class T> void f(T, char (&buffer)[sizeof(ovl(T()))]) {}
346 template <class T> void g(char (&buffer)[sizeof(T() + 5.0f)]) {}
353 template <class T> void h(char (&buffer)[sizeof(T() + 5.0)]) {}
360 template <class T> void j(char (&buffer)[sizeof(T().buffer)]) {}
370 template<typename T> struct X { };
371 template<template<class> class Y, typename T> void f(Y<T>) { }
373 template void f(X<int>);
381 template <class T> decltype(((T*) 0)->member) read_member(T& obj) {
401 template <class T> decltype(((T*) 0)->Path1::ab) get_ab_1(T &ref) { return ref.Path1::ab; }
404 template <class T> decltype(((T*) 0)->Path2::ab) get_ab_2(T &ref) { return ref.Path2::ab; }
407 template <class T> decltype(((T*) 0)->Path1::p) get_p_1(T &ref) { return ref.Path1::p; }
410 template <class T> decltype(((T*) 0)->Path2::p) get_p_2(T &ref) { return ref.Path2::p; }
424 template <int (foo::*)>
432 template <int *>
440 template <int (foo::*)()>
448 template <int (*f)()>
455 template <int &counter> class A { void inc() { counter++; } };
457 template class A<B::value>;
461 template<class T>
468 template <class zaz, class zed>
477 template <char P1> struct S {};
478 template <char P2> void f(struct S<false ? 'a' : P2> ) {}
481 template void f<(char) 3>(struct S<3>);
499 template <unsigned short> struct A { };
505 template <template <class> class T> class A {};
506 template <class U> class B {};
508 template <template<class> class T> void foo(const A<T> &a) {}
511 template void foo(const A<B> &a);
528 template <int I> struct S {};
530 template <int I> void f(S<I + e>) {}
533 template void f<7>(S<7 + e>);
538 template <int N> struct A {};
544 template <class T> A<sizeof(T::foo())> func(void);
561 template <int (A::*)()> struct S {};
563 template <typename T> void f(S<&T::operator+>) {}
564 template void f<A>(S<&A::operator+>);
566 template <typename T> void f(S<&T::operator- >) {}
567 template void f<A>(S<&A::operator- >);
569 template <typename T> void f(S<&T::operator*>) {}
570 template void f<A>(S<&A::operator*>);
572 template <typename T> void f(S<&T::operator&>) {}
573 template void f<A>(S<&A::operator&>);
584 template <typename T> int f();
587 template <typename T> int operator-();
590 template <int (A::*)()> struct S {};
592 template <typename T> void g (S<&T::template f<int> >) {}
593 template <typename T> void g (S<&T::operator+ >) {}
594 template <typename T> void g (S<&T::operator int>) {}
595 template <typename T> void g (S<&T::template operator- <double> >) {}
598 template void g<A>(S<&A::f<int> >);
600 template void g<A>(S<&A::operator+>);
602 template void g<A>(S<&A::operator int>);
604 template void g<A>(S<&A::operator-<double> >);
608 template <class T> T *f(const T&);
609 template <class T> T *f(T*);
612 template <class T> void test0(decltype(f<T*>(0))) {}
613 template void test0<int>(decltype(f<int*>(0)));
616 template <class T> void test1(decltype(f<>(T()))) {}
617 template void test1<int>(decltype(f<>(int())));
659 template <void (*fn)()> struct A {
670 template <template <class> class T> void foo(decltype(T<float>::object) &object) {}
672 template <class T> struct holder { static T object; };
692 template <class T> void a(decltype(T::inner::object) &object) {}
693 template <class T> void b(decltype(T().Alias::meth()) &object) {}
706 template <class T> struct A {
710 template <class T> void foo(decltype(A<T>::A::bit) x);
718 // An enclosing template type parameter in an unresolved-name.
720 template <class T> struct A {
721 template <class U> static void foo(decltype(T::fn(U())) x);
731 // An enclosing template template parameter in an unresolved-name.
733 template <template <class> class T> struct A {
734 template <class U> static void foo(decltype(T<U>::fn()) x);
736 template <class T> struct B { static T fn(); };
746 template<class T> auto f1(T p)->decltype(x) { return 0; }
747 // The return type in the mangling of the template signature
749 template<class T> auto f2(T p)->decltype(p) { return 0; }
750 // The return type in the mangling of the template signature
753 template<class T> auto f3(T p)->decltype(g(p)) {}
756 template int f1(int);
758 template int f2(int);
760 template void f3(int);
765 template<typename T, int=T::value> struct A {
770 template <class T> typename A<T>::type foo() { return 0; }
778 template <class T> struct X {
782 template<typename T, int=X<T>::value> struct A {
787 template <class T> typename A<T>::type foo() { return 0; }
797 template<typename T>
801 template void f<int>(decltype(sizeof(1)));
804 template<unsigned N>
808 template void f2<4>(int (&)[4 + sizeof(int*)]);
812 template<unsigned long long N>
816 template void f3<4>(int (&)[4 + sizeof(int*)]);
819 // template arguments.
820 template<unsigned> struct A { };
822 template<typename T> void f4(::test34::A<sizeof(sizeof(decltype(T() + T())))>) { }
825 template void f4<int>(A<sizeof(sizeof(int))>);
831 template<typename U> A operator+(U) const;
834 template<typename T>
835 void f1(decltype(sizeof(&T::template operator+<int>))) {}
838 template void f1<A>(__SIZE_TYPE__);
842 template<unsigned> struct A { };
844 template<typename ...Types>
848 template A<2> f1(int, float);
