Clang Project

clang_source_code/test/SemaCXX/member-pointer.cpp
1// RUN: %clang_cc1 -fsyntax-only -verify %s
2// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
3// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
4
5struct A {};
6enum B { Dummy };
7namespace C {}
8struct D : A {};
9struct E : A {};
10struct F : D, E {};
11struct G : virtual D {};
12class H : A {}; // expected-note 2{{implicitly declared private here}}
13
14int A::*pdi1;
15int (::A::*pdi2);
16int (A::*pfi)(int);
17void (*A::*ppfie)() throw(); // expected-error {{exception specifications are not allowed beyond a single level of indirection}}
18
19int B::*pbi;
20#if __cplusplus <= 199711L // C++03 or earlier modes
21// expected-warning@-2 {{use of enumeration in a nested name specifier is a C++11 extension}}
22#endif
23// expected-error@-4 {{'pbi' does not point into a class}}
24int C::*pci; // expected-error {{'pci' does not point into a class}}
25void A::*pdv; // expected-error {{'pdv' declared as a member pointer to void}}
26int& A::*pdr; // expected-error {{'pdr' declared as a member pointer to a reference}}
27
28void f() {
29  // This requires tentative parsing.
30  int (A::*pf)(int, int);
31
32  // Implicit conversion to bool.
33  bool b = pdi1;
34  b = pfi;
35
36  // Conversion from null pointer constant.
37  pf = 0;
38  pf = __null;
39
40  // Conversion to member of derived.
41  int D::*pdid = pdi1;
42  pdid = pdi2;
43
44  // Fail conversion due to ambiguity and virtuality.
45  int F::*pdif = pdi1; // expected-error {{ambiguous conversion from pointer to member of base class 'A' to pointer to member of derived class 'F':}}
46  int G::*pdig = pdi1; // expected-error {{conversion from pointer to member of class 'A' to pointer to member of class 'G' via virtual base 'D' is not allowed}}
47
48  // Conversion to member of base.
49  pdi1 = pdid; // expected-error {{assigning to 'int A::*' from incompatible type 'int D::*'}}
50  
51  // Comparisons
52  int (A::*pf2)(int, int);
53  int (D::*pf3)(int, int) = 0;
54  bool b1 = (pf == pf2); (void)b1;
55  bool b2 = (pf != pf2); (void)b2;
56  bool b3 = (pf == pf3); (void)b3;
57  bool b4 = (pf != 0); (void)b4;
58}
59
60struct TheBase
61{
62  void d();
63};
64
65struct HasMembers : TheBase
66{
67  int i;
68  void f();
69
70  void g();
71  void g(int);
72  static void g(double);
73};
74
75namespace Fake
76{
77  int i;
78  void f();
79}
80
81void g() {
82  HasMembers hm;
83
84  int HasMembers::*pmi = &HasMembers::i;
85  int *pni = &Fake::i;
86  int *pmii = &hm.i;
87
88  void (HasMembers::*pmf)() = &HasMembers::f;
89  void (*pnf)() = &Fake::f;
90  &hm.f; // expected-error {{cannot create a non-constant pointer to member function}}
91
92  void (HasMembers::*pmgv)() = &HasMembers::g;
93  void (HasMembers::*pmgi)(int) = &HasMembers::g;
94  void (*pmgd)(double) = &HasMembers::g;
95
96  void (HasMembers::*pmd)() = &HasMembers::d;
97}
98
99struct Incomplete;
100
101void h() {
102  HasMembers hm, *phm = &hm;
103
104  int HasMembers::*pi = &HasMembers::i;
105  hm.*pi = 0;
106  int i = phm->*pi;
107  (void)&(hm.*pi);
108  (void)&(phm->*pi);
109  (void)&((&hm)->*pi); 
110
111  void (HasMembers::*pf)() = &HasMembers::f;
112  (hm.*pf)();
113  (phm->*pf)();
114
115  (void)(hm->*pi); // expected-error {{left hand operand to ->* must be a pointer to class compatible with the right hand operand, but is 'HasMembers'}}
116  (void)(phm.*pi); // expected-error {{left hand operand to .* must be a class compatible with the right hand operand, but is 'HasMembers *'}}
117  (void)(i.*pi); // expected-error {{left hand operand to .* must be a class compatible with the right hand operand, but is 'int'}}
118  int *ptr;
119  (void)(ptr->*pi); // expected-error {{left hand operand to ->* must be a pointer to class compatible with the right hand operand, but is 'int *'}}
120
121  int A::*pai = 0;
122  D d, *pd = &d;
123  (void)(d.*pai);
124  (void)(pd->*pai);
125  F f, *ptrf = &f;
126  (void)(f.*pai); // expected-error {{ambiguous conversion from derived class 'F' to base class 'A'}}
127  (void)(ptrf->*pai); // expected-error {{ambiguous conversion from derived class 'F' to base class 'A'}}
128  H h, *ptrh = &h;
129  (void)(h.*pai); // expected-error {{cannot cast 'H' to its private base class 'A'}}
130  (void)(ptrh->*pai); // expected-error {{cannot cast 'H' to its private base class 'A'}}
131
132  (void)(hm.*i); // expected-error {{pointer-to-member}}
133  (void)(phm->*i); // expected-error {{pointer-to-member}}
134
135  // Okay
136  Incomplete *inc;
137  int Incomplete::*pii = 0;
138  (void)(inc->*pii);
139}
140
141struct OverloadsPtrMem
142{
143  int operator ->*(const char *);
144};
145
146void i() {
147  OverloadsPtrMem m;
148  int foo = m->*"Awesome!";
149}
150
151namespace pr5985 {
152  struct c {
153    void h();
154    void f() {
155      void (c::*p)();
156      p = &h; // expected-error {{must explicitly qualify}}
157      p = &this->h; // expected-error {{cannot create a non-constant pointer to member function}}
158      p = &(*this).h; // expected-error {{cannot create a non-constant pointer to member function}}
159    }
160  };
161}
162
163namespace pr6783 {
164  struct Base {};
165  struct X; // expected-note {{forward declaration}}
166
167  int test1(int Base::* p2m, X* object)
168  {
169    return object->*p2m; // expected-error {{left hand operand to ->*}}
170  }
171}
172
173namespace PR7176 {
174  namespace base
175  {
176    struct Process
177    { };
178    struct Continuous : Process
179    {
180      bool cond();
181    };
182  }
183
184  typedef bool( base::Process::*Condition )();
185
186  void m()
187  { (void)(Condition) &base::Continuous::cond; }
188}
189
190namespace rdar8358512 {
191  // We can't call this with an overload set because we're not allowed
192  // to look into overload sets unless the parameter has some kind of
193  // function type.
194  template <class F> void bind(F f); // expected-note 12 {{candidate template ignored}}
195  template <class F, class T> void bindmem(F (T::*f)()); // expected-note 4 {{candidate template ignored}}
196  template <class F> void bindfn(F (*f)()); // expected-note 4 {{candidate template ignored}}
197
198  struct A {
199    void nonstat();
200    void nonstat(int);
201
202    void mixed();
203    static void mixed(int);
204
205    static void stat();
206    static void stat(int);
207    
208    template <typename T> struct Test0 {
209      void test() {
210        bind(&nonstat); // expected-error {{no matching function for call}}
211        bind(&A::nonstat); // expected-error {{no matching function for call}}
212
213        bind(&mixed); // expected-error {{no matching function for call}}
214        bind(&A::mixed); // expected-error {{no matching function for call}}
215
216        bind(&stat); // expected-error {{no matching function for call}}
217        bind(&A::stat); // expected-error {{no matching function for call}}
218      }
219    };
220
221    template <typename T> struct Test1 {
222      void test() {
223        bindmem(&nonstat); // expected-error {{no matching function for call}}
224        bindmem(&A::nonstat);
225
226        bindmem(&mixed); // expected-error {{no matching function for call}}
227        bindmem(&A::mixed);
228
229        bindmem(&stat); // expected-error {{no matching function for call}}
230        bindmem(&A::stat); // expected-error {{no matching function for call}}
231      }
232    };
233
234    template <typename T> struct Test2 {
235      void test() {
236        bindfn(&nonstat); // expected-error {{no matching function for call}}
237        bindfn(&A::nonstat); // expected-error {{no matching function for call}}
238
239        bindfn(&mixed); // expected-error {{no matching function for call}}
240        bindfn(&A::mixed); // expected-error {{no matching function for call}}
241
242        bindfn(&stat);
243        bindfn(&A::stat);
244      }
245    };
246  };
247
248  template <class T> class B {
249    void nonstat();
250    void nonstat(int);
251
252    void mixed();
253    static void mixed(int);
254
255    static void stat();
256    static void stat(int);
257
258    // None of these can be diagnosed yet, because the arguments are
259    // still dependent.
260    void test0a() {
261      bind(&nonstat);
262      bind(&B::nonstat);
263
264      bind(&mixed);
265      bind(&B::mixed);
266
267      bind(&stat);
268      bind(&B::stat);
269    }
270
271    void test0b() {
272      bind(&nonstat); // expected-error {{no matching function for call}}
273      bind(&B::nonstat); // expected-error {{no matching function for call}}
274
275      bind(&mixed); // expected-error {{no matching function for call}}
276      bind(&B::mixed); // expected-error {{no matching function for call}}
277
278      bind(&stat); // expected-error {{no matching function for call}}
279      bind(&B::stat); // expected-error {{no matching function for call}}
280    }
281  };
282
283  template void B<int>::test0b(); // expected-note {{in instantiation}}
284}
285
286namespace PR9973 {
287  template<class R, class T> struct dm
288  {
289    typedef R T::*F;
290    F f_;
291    template<class U> int & call(U u)
292    { return u->*f_; } // expected-error{{reference to non-static member function must be called; did you mean to call it with no arguments?}} expected-error {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
293
294    template<class U> int operator()(U u)
295    { call(u); } // expected-note{{in instantiation of}}
296  };
297
298  template<class R, class T> 
299  dm<R, T> mem_fn(R T::*) ;
300
301  struct test
302  { int nullary_v(); };
303
304  void f()
305  {
306    test* t;
307    mem_fn(&test::nullary_v)(t); // expected-note{{in instantiation of}}
308  }
309}
310
311namespace test8 {
312  struct A { int foo; };
313  int test1() {
314    // Verify that we perform (and check) an lvalue conversion on the operands here.
315    return (*((A**) 0)) // expected-warning {{indirection of non-volatile null pointer will be deleted}} expected-note {{consider}}
316             ->**(int A::**) 0; // expected-warning {{indirection of non-volatile null pointer will be deleted}} expected-note {{consider}}
317  }
318
319  int test2() {
320    // Verify that we perform (and check) an lvalue conversion on the operands here.
321    // TODO: the .* should itself warn about being a dereference of null.
322    return (*((A*) 0))
323             .**(int A::**) 0; // expected-warning {{indirection of non-volatile null pointer will be deleted}} expected-note {{consider}}
324  }
325}
326
CodeThinker, Enjoy your reading code