Clang Project

clang_source_code/test/CXX/expr/expr.unary/expr.new/p20.cpp
1// RUN: %clang_cc1 -fsyntax-only -verify -fexceptions %s
2typedef __SIZE_TYPE__ size_t;
3
4// Overloaded operator delete with two arguments
5template<int I>
6struct X0 {
7  X0();
8  static void* operator new(size_t);
9  static void operator delete(void*, size_t) {
10    int *ip = I; // expected-error{{cannot initialize}}
11  }
12};
13
14void test_X0() {
15  new X0<1>; // expected-note{{instantiation}}
16}
17
18// Overloaded operator delete with one argument
19template<int I>
20struct X1 {
21  X1();
22
23  static void* operator new(size_t);
24  static void operator delete(void*) {
25    int *ip = I; // expected-error{{cannot initialize}}
26  }
27};
28
29void test_X1() {
30  new X1<1>; // expected-note{{instantiation}}
31}
32
33// Overloaded operator delete for placement new
34template<int I>
35struct X2 {
36  X2();
37
38  static void* operator new(size_t, double, double);
39  static void* operator new(size_t, int, int);
40
41  static void operator delete(void*, const int, int) {
42    int *ip = I; // expected-error{{cannot initialize}}
43  }
44
45  static void operator delete(void*, double, double);
46};
47
48void test_X2() {
49  new (0, 0) X2<1>; // expected-note{{instantiation}}
50}
51
52// Operator delete template for placement new
53struct X3 {
54  X3();
55
56  static void* operator new(size_t, double, double);
57
58  template<typename T>
59  static void operator delete(void*, T x, T) {
60    double *dp = &x;
61    int *ip = &x; // expected-error{{cannot initialize}}
62  }
63};
64
65void test_X3() {
66  new (0, 0) X3; // expected-note{{instantiation}}
67}
68
69// Operator delete template for placement new in global scope.
70struct X4 {
71  X4();
72  static void* operator new(size_t, double, double);
73};
74
75template<typename T>
76void operator delete(void*, T x, T) {
77  double *dp = &x;
78  int *ip = &x; // expected-error{{cannot initialize}}
79}
80
81void test_X4() {
82  new (0, 0) X4; // expected-note{{instantiation}}
83}
84
85// Useless operator delete hides global operator delete template.
86struct X5 {
87  X5();
88  static void* operator new(size_t, double, double);
89  void operator delete(void*, double*, double*);
90};
91
92void test_X5() {
93  new (0, 0) X5; // okay, we found X5::operator delete but didn't pick it
94}
95
96// Operator delete template for placement new
97template<int I>
98struct X6 {
99  X6();
100
101  static void* operator new(size_t) {
102    return I; // expected-error{{cannot initialize}}
103  }
104
105  static void operator delete(void*) {
106    int *ip = I; // expected-error{{cannot initialize}}
107  }
108};
109
110void test_X6() {
111  new X6<3>; // expected-note 2{{instantiation}}
112}
113
114void *operator new(size_t, double, double, double);
115
116template<typename T>
117void operator delete(void*, T x, T, T) {
118  double *dp = &x;
119  int *ip = &x; // expected-error{{cannot initialize}}
120}
121void test_int_new() {
122  new (1.0, 1.0, 1.0) int; // expected-note{{instantiation}}
123}
124
125// We don't need an operator delete if the type has a trivial
126// constructor, since we know that constructor cannot throw.
127// FIXME: Is this within the standard? Seems fishy, but both EDG+GCC do it.
128#if 0
129template<int I>
130struct X7 {
131  static void* operator new(size_t);
132  static void operator delete(void*, size_t) {
133    int *ip = I; // okay, since it isn't instantiated.
134  }
135};
136
137void test_X7() {
138  new X7<1>;
139}
140#endif
141
142
CodeThinker, Enjoy your reading code