1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
|
// RUN: %clang_cc1 -fsyntax-only -pedantic -verify %s
// RUN: %clang_cc1 -fsyntax-only -pedantic -verify -std=c++98 %s
// RUN: %clang_cc1 -fsyntax-only -pedantic -verify -std=c++11 %s
// C++ [dcl.init.aggr]p2
struct A {
int x;
struct B {
int i;
int j;
} b;
} a1 = { 1, { 2, 3 } };
struct NonAggregate {
#if __cplusplus >= 201103L
// expected-note@-2 3 {{candidate constructor (the implicit copy constructor) not viable}}
// expected-note@-3 3 {{candidate constructor (the implicit move constructor) not viable}}
#endif
NonAggregate();
#if __cplusplus >= 201103L
// expected-note@-2 3 {{candidate constructor not viable: requires 0 arguments, but 2 were provided}}
#endif
int a, b;
};
NonAggregate non_aggregate_test = { 1, 2 };
#if __cplusplus <= 199711L
// expected-error@-2 {{non-aggregate type 'NonAggregate' cannot be initialized with an initializer list}}
#else
// expected-error@-4 {{no matching constructor for initialization of 'NonAggregate'}}
#endif
NonAggregate non_aggregate_test2[2] = { { 1, 2 }, { 3, 4 } };
#if __cplusplus <= 199711L
// expected-error@-2 2 {{non-aggregate type 'NonAggregate' cannot be initialized with an initializer list}}
#else
// expected-error@-4 2 {{no matching constructor for initialization of 'NonAggregate'}}
#endif
// C++ [dcl.init.aggr]p3
A a_init = A();
// C++ [dcl.init.aggr]p4
int x[] = { 1, 3, 5 };
int x_sizecheck[(sizeof(x) / sizeof(int)) == 3? 1 : -1];
int x2[] = { }; // expected-warning{{zero size arrays are an extension}}
// C++ [dcl.init.aggr]p5
struct StaticMemberTest {
int i;
static int s;
int *j;
} smt = { 1, &smt.i };
// C++ [dcl.init.aggr]p6
char cv[4] = { 'a', 's', 'd', 'f', 0 }; // expected-error{{excess elements in array initializer}}
// C++ [dcl.init.aggr]p7
struct TooFew { int a; char* b; int c; };
TooFew too_few = { 1, "asdf" };
#if __cplusplus <= 199711L
// expected-warning@-2 {{conversion from string literal to 'char *' is deprecated}}
#else
// expected-warning@-4 {{ISO C++11 does not allow conversion from string literal to 'char *'}}
#endif
struct NoDefaultConstructor {
#if __cplusplus <= 199711L
// expected-note@-2 3 {{candidate constructor (the implicit copy constructor)}}
// expected-note@-3 {{declared here}}
#else
// expected-note@-5 4 {{candidate constructor (the implicit copy constructor)}}
// expected-note@-6 4 {{candidate constructor (the implicit move constructor)}}
#endif
NoDefaultConstructor(int);
#if __cplusplus <= 199711L
// expected-note@-2 3 {{candidate constructor not viable: requires 1 argument, but 0 were provided}}
#else
// expected-note@-4 4 {{candidate constructor not viable: requires 1 argument, but 0 were provided}}
#endif
};
struct TooFewError {
#if __cplusplus <= 199711L
// expected-error@-2 {{implicit default constructor for}}
#endif
int a;
NoDefaultConstructor nodef;
#if __cplusplus <= 199711L
// expected-note@-2 {{member is declared here}}
// expected-note@-3 2{{in implicit initialization of field 'nodef' with omitted initializer}}
#else
// expected-note@-5 3{{in implicit initialization of field 'nodef' with omitted initializer}}
#endif
};
TooFewError too_few_okay = { 1, 1 };
TooFewError too_few_error = { 1 }; // expected-error{{no matching constructor}}
TooFewError too_few_okay2[2] = { 1, 1 };
#if __cplusplus <= 199711L
// expected-note@-2 {{implicit default constructor for 'TooFewError' first required here}}
#else
// expected-error@-4 {{no matching constructor for initialization of 'NoDefaultConstructor'}}
// expected-note@-5 {{in implicit initialization of array element 1 with omitted initializer}}
#endif
TooFewError too_few_error2[2] = { 1 }; // expected-error{{no matching constructor}}
NoDefaultConstructor too_few_error3[3] = { }; // expected-error {{no matching constructor}} expected-note {{implicit initialization of array element 0}}
// C++ [dcl.init.aggr]p8
struct Empty { };
struct EmptyTest {
Empty s;
int i;
} empty_test = { { }, 3 };
EmptyTest empty_test2 = { 3 }; // expected-error{{initializer for aggregate with no elements requires explicit braces}}
struct NonEmpty {
int a;
Empty empty;
};
struct NonEmptyTest {
NonEmpty a, b;
} non_empty_test = { { }, { } };
// C++ [dcl.init.aggr]p9
struct HasReference {
int i;
int &j; // expected-note{{uninitialized reference member is here}}
};
int global_int;
HasReference r1 = { 1, global_int };
HasReference r2 = { 1 } ; // expected-error{{reference member of type 'int &' uninitialized}}
// C++ [dcl.init.aggr]p10
// Note: the behavior here is identical to C
int xs[2][2] = { 3, 1, 4, 2 };
float y[4][3] = { { 1 }, { 2 }, { 3 }, { 4 } };
// C++ [dcl.init.aggr]p11
// Note: the behavior here is identical to C
float y2[4][3] = { { 1, 3, 5 }, { 2, 4, 6 }, { 3, 5, 7 } };
float same_as_y2[4][3] = { 1, 3, 5, 2, 4, 6, 3, 5, 7 };
// C++ [dcl.init.aggr]p12
struct A2 {
int i;
operator int *();
};
struct B2 {
A2 a1, a2;
int *z;
};
struct C2 {
operator A2();
};
struct D2 {
operator int();
};
A2 a2;
C2 c2;
D2 d2;
B2 b2 = { 4, a2, a2 };
B2 b2_2 = { 4, d2, 0 };
B2 b2_3 = { c2, a2, a2 };
// C++ [dcl.init.aggr]p15:
union u { int a; char* b; }; // expected-note{{candidate constructor (the implicit copy constructor)}}
#if __cplusplus >= 201103L
// expected-note@-2 {{candidate constructor (the implicit move constructor)}}
#endif
u u1 = { 1 };
u u2 = u1;
u u3 = 1; // expected-error{{no viable conversion}}
u u4 = { 0, "asdf" }; // expected-error{{excess elements in union initializer}}
u u5 = { "asdf" }; // expected-error{{cannot initialize a member subobject of type 'int' with an lvalue of type 'const char [5]'}}
|
