Clang Project

clang_source_code/test/SemaCXX/constructor-initializer.cpp
1// RUN: %clang_cc1 -Wreorder -fsyntax-only -verify %s
2// RUN: %clang_cc1 -Wreorder -fsyntax-only -verify -std=c++98 %s
3// RUN: %clang_cc1 -Wreorder -fsyntax-only -verify -std=c++11 %s
4
5class A { 
6  int m;
7public:
8   A() : A::m(17) { } // expected-error {{member initializer 'm' does not name a non-static data member or base class}}
9   A(int);
10};
11
12class B : public A { 
13public:
14  B() : A(), m(1), n(3.14) { }
15
16private:
17  int m;
18  float n;  
19};
20
21
22class C : public virtual B { 
23public:
24  C() : B() { }
25};
26
27class D : public C { 
28public:
29  D() : B(), C() { }
30};
31
32class E : public D, public B {  // expected-warning{{direct base 'B' is inaccessible due to ambiguity:\n    class E -> class D -> class C -> class B\n    class E -> class B}}
33public:
34  E() : B(), D() { } // expected-error{{base class initializer 'B' names both a direct base class and an inherited virtual base class}}
35};
36
37
38typedef int INT;
39
40class F : public B { 
41public:
42  int B;
43
44  F() : B(17),
45        m(17), // expected-error{{member initializer 'm' does not name a non-static data member or base class}}
46        INT(17) // expected-error{{constructor initializer 'INT' (aka 'int') does not name a class}}
47  { 
48  }
49};
50
51class G : A {
52  G() : A(10); // expected-error{{expected '{'}}
53};
54
55void f() : a(242) { } // expected-error{{only constructors take base initializers}}
56
57class H : A {
58  H();
59};
60
61H::H() : A(10) { }
62
63
64class  X {};
65class Y {};
66
67struct S : Y, virtual X {
68  S (); 
69};
70
71struct Z : S { 
72  Z() : X(), S(), E()  {} // expected-error {{type 'E' is not a direct or virtual base of 'Z'}}
73};
74
75class U { 
76  union { int a; char* p; };
77  union { int b; double d; };
78
79  U() :  a(1), // expected-note {{previous initialization is here}}
80         p(0), // expected-error {{initializing multiple members of union}}
81         d(1.0)  {}
82};
83
84struct V {};
85struct Base {};
86struct Base1 {};
87
88struct Derived : Base, Base1, virtual V {
89  Derived ();
90};
91
92struct Current : Derived {
93  int Derived;
94  Current() : Derived(1), ::Derived(), // expected-warning {{field 'Derived' will be initialized after base '::Derived'}} \
95                                       // expected-warning {{base class '::Derived' will be initialized after base 'Derived::V'}}
96                          ::Derived::Base(), // expected-error {{type '::Derived::Base' is not a direct or virtual base of 'Current'}}
97                           Derived::Base1(), // expected-error {{type 'Derived::Base1' is not a direct or virtual base of 'Current'}}
98                           Derived::V(),
99                           ::NonExisting(), // expected-error {{member initializer 'NonExisting' does not name a non-static data member or}}
100                           INT::NonExisting()  {} // expected-error {{'INT' (aka 'int') is not a class, namespace, or enumeration}} \
101                                                  // expected-error {{member initializer 'NonExisting' does not name a non-static data member or}}
102};
103
104struct M {              // expected-note 2 {{candidate constructor (the implicit copy constructor)}}
105#if __cplusplus >= 201103L // C++11 or later
106// expected-note@-2 2 {{candidate constructor (the implicit move constructor) not viable}}
107#endif
108// expected-note@-4 2 {{'M' declared here}}
109  M(int i, int j);      // expected-note 2 {{candidate constructor}}
110};
111
112struct N : M  {
113  N() : M(1),        // expected-error {{no matching constructor for initialization of 'M'}}
114        m1(100) {  } // expected-error {{no matching constructor for initialization of 'M'}}
115  M m1;
116};
117
118struct P : M  {
119  P()  {  } // expected-error {{constructor for 'P' must explicitly initialize the base class 'M' which does not have a default constructor}} \
120            // expected-error {{member 'm'}}
121  M m; // expected-note {{member is declared here}}
122};
123
124struct Q {
125  Q() : f1(1,2),       // expected-error {{excess elements in scalar initializer}}
126        pf(0.0)  { }   // expected-error {{cannot initialize a member subobject of type 'float *' with an rvalue of type 'double'}}
127  float f1;
128
129  float *pf;
130};
131
132// A silly class used to demonstrate field-is-uninitialized in constructors with
133// multiple params.
134int IntParam(int i) { return 0; };
135class TwoInOne { public: TwoInOne(TwoInOne a, TwoInOne b) {} };
136class InitializeUsingSelfTest {
137  bool A;
138  char* B;
139  int C;
140  TwoInOne D;
141  int E;
142  InitializeUsingSelfTest(int F)
143      : A(A),  // expected-warning {{field 'A' is uninitialized when used here}}
144        B((((B)))),  // expected-warning {{field 'B' is uninitialized when used here}}
145        C(A && InitializeUsingSelfTest::C),  // expected-warning {{field 'C' is uninitialized when used here}}
146        D(D,  // expected-warning {{field 'D' is uninitialized when used here}}
147          D), // expected-warning {{field 'D' is uninitialized when used here}}
148        E(IntParam(E)) {} // expected-warning {{field 'E' is uninitialized when used here}}
149};
150
151int IntWrapper(int &i) { return 0; };
152class InitializeUsingSelfExceptions {
153  int A;
154  int B;
155  int C;
156  void *P;
157  InitializeUsingSelfExceptions(int B)
158      : A(IntWrapper(A)),  // Due to a conservative implementation, we do not report warnings inside function/ctor calls even though it is possible to do so.
159        B(B),  // Not a warning; B is a local variable.
160        C(sizeof(C)),  // sizeof doesn't reference contents, do not warn
161        P(&P) {} // address-of doesn't reference contents (the pointer may be dereferenced in the same expression but it would be rare; and weird)
162};
163
164class CopyConstructorTest {
165  bool A, B, C;
166  CopyConstructorTest(const CopyConstructorTest& rhs)
167      : A(rhs.A),
168        B(B),  // expected-warning {{field 'B' is uninitialized when used here}}
169        C(rhs.C || C) { }  // expected-warning {{field 'C' is uninitialized when used here}}
170};
171
172// Make sure we aren't marking default constructors when we shouldn't be.
173template<typename T>
174struct NDC {
175  T &ref;
176  
177  NDC() { }
178  NDC(T &ref) : ref(ref) { }
179};
180  
181struct X0 : NDC<int> {
182  X0(int &ref) : NDC<int>(ref), ndc(ref) { }
183  
184  NDC<int> ndc;
185};
186
187namespace Test0 {
188
189struct A { A(); };
190
191struct B {
192  B() { } 
193  const A a;
194};
195
196}
197
198namespace Test1 {
199  struct A {
200    enum Kind { Foo } Kind;
201    A() : Kind(Foo) {}
202  };
203}
204
205namespace Test2 {
206
207struct A { 
208  A(const A&);
209};
210
211struct B : virtual A { };
212
213  struct C : A, B { }; // expected-warning{{direct base 'Test2::A' is inaccessible due to ambiguity:\n    struct Test2::C -> struct Test2::A\n    struct Test2::C -> struct Test2::B -> struct Test2::A}}
214
215C f(C c) {
216  return c;
217}
218
219}
220
221// Don't build implicit initializers for anonymous union fields when we already
222// have an explicit initializer for another field in the union.
223namespace PR7402 {
224  struct S {
225    union {
226      void* ptr_;
227      struct { int i_; };
228    };
229
230    template <typename T> S(T) : ptr_(0) { }
231  };
232
233  void f() {
234    S s(3);
235  }
236}
237
238// <rdar://problem/8308215>: don't crash.
239// Lots of questionable recovery here;  errors can change.
240namespace test3 {
241  class A : public std::exception {}; // expected-error {{undeclared identifier}} expected-error {{expected class name}}
242  // expected-note@-1 {{candidate constructor (the implicit copy constructor) not viable}}
243#if __cplusplus >= 201103L // C++11 or later
244  // expected-note@-3 {{candidate constructor (the implicit move constructor) not viable}}
245#endif
246  // expected-note@-5 {{candidate constructor (the implicit default constructor) not viable}}
247
248  class B : public A {
249  public:
250    B(const String& s, int e=0) // expected-error {{unknown type name}} 
251      : A(e), m_String(s) , m_ErrorStr(__null) {} // expected-error {{no matching constructor}} expected-error {{does not name}}
252    B(const B& e)
253      : A(e), m_String(e.m_String), m_ErrorStr(__null) { // expected-error {{does not name}} \
254      // expected-error {{no member named 'm_String' in 'test3::B'}}
255    }
256  };
257}
258
259// PR8075
260namespace PR8075 {
261
262struct S1 {
263  enum { FOO = 42 };
264  static const int bar = 42;
265  static int baz();
266  S1(int);
267};
268
269const int S1::bar;
270
271struct S2 {
272  S1 s1;
273  S2() : s1(s1.FOO) {}
274};
275
276struct S3 {
277  S1 s1;
278  S3() : s1(s1.bar) {}
279};
280
281struct S4 {
282  S1 s1;
283  S4() : s1(s1.baz()) {}
284};
285
286}
287
288namespace PR12049 {
289  int function();
290
291  class Class
292  {
293  public:
294      Class() : member(function() {} // expected-note {{to match this '('}}
295
296      int member; // expected-error {{expected ')'}}
297  };
298}
299
300namespace PR14073 {
301  struct S1 { union { int n; }; S1() : n(n) {} };  // expected-warning {{field 'n' is uninitialized when used here}}
302  struct S2 { union { union { int n; }; char c; }; S2() : n(n) {} };  // expected-warning {{field 'n' is uninitialized when used here}}
303  struct S3 { struct { int n; }; S3() : n(n) {} };  // expected-warning {{field 'n' is uninitialized when used here}}
304}
305
306namespace PR10758 {
307struct A;
308struct B {
309  B (A const &); // expected-note 2 {{candidate constructor not viable: no known conversion from 'const PR10758::B' to 'const PR10758::A &' for 1st argument}}
310  B (B &); // expected-note 2 {{candidate constructor not viable: 1st argument ('const PR10758::B') would lose const qualifier}}
311};
312struct A {
313  A (B); // expected-note 2 {{passing argument to parameter here}}
314};
315
316B f(B const &b) {
317  return b; // expected-error {{no matching constructor for initialization of 'PR10758::B'}}
318}
319
320A f2(const B &b) {
321  return b; // expected-error {{no matching constructor for initialization of 'PR10758::B'}}
322}
323}
324
CodeThinker, Enjoy your reading code