Clang Project

clang_source_code/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.call/p3.cpp
1// RUN: %clang_cc1 -fsyntax-only -verify %s
2
3template<typename T> struct A { };
4
5// Top-level cv-qualifiers of P's type are ignored for type deduction.
6template<typename T> A<T> f0(const T);
7
8void test_f0(int i, const int ci) {
9  A<int> a0 = f0(i);
10  A<int> a1 = f0(ci);
11}
12
13// If P is a reference type, the type referred to by P is used for type 
14// deduction.
15template<typename T> A<T> f1(T&);
16
17void test_f1(int i, const int ci, volatile int vi) {
18  A<int> a0 = f1(i);
19  A<const int> a1 = f1(ci);
20  A<volatile int> a2 = f1(vi);
21}
22
23template<typename T, unsigned N> struct B { };
24template<typename T, unsigned N> B<T, N> g0(T (&array)[N]);
25template<typename T, unsigned N> B<T, N> g0b(const T (&array)[N]);
26
27void test_g0() {
28  int array0[5];
29  B<int, 5> b0 = g0(array0);
30  const int array1[] = { 1, 2, 3};
31  B<const int, 3> b1 = g0(array1);
32  B<int, 3> b2 = g0b(array1);
33}
34
35template<typename T> B<T, 0> g1(const A<T>&);
36
37void test_g1(A<float> af) {
38  B<float, 0> b0 = g1(af);
39  B<int, 0> b1 = g1(A<int>());
40}
41
42//   - If the original P is a reference type, the deduced A (i.e., the type
43//     referred to by the reference) can be more cv-qualified than the 
44//     transformed A.
45template<typename T> A<T> f2(const T&);
46
47void test_f2(int i, const int ci, volatile int vi) {
48  A<int> a0 = f2(i);
49  A<int> a1 = f2(ci);
50  A<volatile int> a2 = f2(vi);
51}
52
53// PR5913
54template <typename T, int N>
55void Foo(const T (&a)[N]) {
56  T x;
57  x = 0;
58}
59
60const int a[1] = { 0 };
61
62void Test() {
63  Foo(a);
64}
65
66//   - The transformed A can be another pointer or pointer to member type that 
67//     can be converted to the deduced A via a qualification conversion (4.4).
68template<typename T> A<T> f3(T * * const * const);
69
70void test_f3(int ***ip, volatile int ***vip) {
71  A<int> a0 = f3(ip);
72  A<volatile int> a1 = f3(vip);
73}
74
75// Also accept conversions for pointer types which require removing
76// [[noreturn]].
77namespace noreturn_stripping {
78  template <class R>
79  void f(R (*function)());
80
81  void g() __attribute__ ((__noreturn__));
82  void h();
83  void test() {
84    f(g);
85    f(h);
86  }
87}
88
89//   - If P is a class, and P has the form template-id, then A can be a 
90//     derived class of the deduced A. Likewise, if P is a pointer to a class
91//     of the form template-id, A can be a pointer to a derived class pointed 
92//     to by the deduced A.
93template<typename T, int I> struct C { };
94
95struct D : public C<int, 1> { };
96struct E : public D { };
97struct F : A<float> { };
98struct G : A<float>, C<int, 1> { };
99
100template<typename T, int I>
101  C<T, I> *f4a(const C<T, I>&);
102template<typename T, int I>
103  C<T, I> *f4b(C<T, I>);
104template<typename T, int I>
105  C<T, I> *f4c(C<T, I>*);
106int *f4c(...);
107
108void test_f4(D d, E e, F f, G g) {
109  C<int, 1> *ci1a = f4a(d);
110  C<int, 1> *ci2a = f4a(e);
111  C<int, 1> *ci1b = f4b(d);
112  C<int, 1> *ci2b = f4b(e);
113  C<int, 1> *ci1c = f4c(&d);
114  C<int, 1> *ci2c = f4c(&e);
115  C<int, 1> *ci3c = f4c(&g);
116  int       *ip1 = f4c(&f);
117}
118
119// PR8462
120namespace N {
121  struct T0;
122  struct T1;
123
124  template<typename X, typename Y> struct B {};
125
126  struct J : B<T0,T0> {};
127  struct K : B<T1,T1> {};
128
129  struct D : J, K {};
130
131  template<typename X, typename Y> void F(B<Y,X>);
132
133  void test()
134  {
135    D d; 
136    N::F<T0>(d); // Fails
137    N::F<T1>(d); // OK
138  }
139}
140
141namespace PR9233 {
142  template<typename T> void f(const T **q); // expected-note{{candidate template ignored: deduced type 'const int **' of 1st parameter does not match adjusted type 'int **' of argument [with T = int]}}
143
144  void g(int **p) {
145    f(p); // expected-error{{no matching function for call to 'f'}}
146  }
147
148}
149
150namespace PR27155 {
151
152struct B {};
153
154template<class T, int i> struct D : T {};
155template<class T> void Foo(D<T, 1>);
156
157int fn() {
158  D<D<B, 1>, 0> f;
159  Foo(f);
160}
161
162}
163
164namespace PR28195 {
165
166template<int N> struct B {};
167struct D : B<0>, B<1> {};
168
169template<int N> int callee(B<N>); // expected-note{{failed template argument deduction}}
170
171int caller() {
172  callee(D()); // expected-error{{no matching function}}
173}
174
175}
176
CodeThinker, Enjoy your reading code