blob: 9b92340fa457d456f0550bb64ca61b8872dee981 (
plain)
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
|
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++0x %s
// An aggregate is an array or a class...
struct Aggr {
private:
static const int n;
void f();
protected:
struct Inner { int m; };
public:
bool &br;
};
bool b;
Aggr ag = { b };
// with no user-provided constructors, ...
struct NonAggr1a {
NonAggr1a(int, int);
int k;
};
// In C++03, this is {{non-aggregate type 'NonAggr1a'}}.
// In C++0x, 'user-provided' is only defined for special member functions, so
// this type is considered to be an aggregate. This is probably a langauge
// defect.
NonAggr1a na1a = { 42 };
struct NonAggr1b {
NonAggr1b(const NonAggr1b &);
int k;
};
NonAggr1b na1b = { 42 }; // expected-error {{non-aggregate type 'NonAggr1b'}}
// no brace-or-equal-initializers for non-static data members, ...
struct NonAggr2 {
int m = { 123 };
};
NonAggr2 na2 = { 42 }; // expected-error {{non-aggregate type 'NonAggr2'}}
// no private...
struct NonAggr3 {
private:
int n;
};
NonAggr3 na3 = { 42 }; // expected-error {{non-aggregate type 'NonAggr3'}}
// or protected non-static data members, ...
struct NonAggr4 {
protected:
int n;
};
NonAggr4 na4 = { 42 }; // expected-error {{non-aggregate type 'NonAggr4'}}
// no base classes, ...
struct NonAggr5 : Aggr {
};
NonAggr5 na5 = { b }; // expected-error {{non-aggregate type 'NonAggr5'}}
// and no virtual functions.
struct NonAggr6 {
virtual void f();
int n;
};
NonAggr6 na6 = { 42 }; // expected-error {{non-aggregate type 'NonAggr6'}}
|
