clang/test/CXX/expr/expr.unary/expr.new/p20.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -verify -fexceptions %s
   2 typedef __SIZE_TYPE__ size_t;
   3
   4 // Overloaded operator delete with two arguments
   5 template<int I>
   6 struct 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
  14 void test_X0() {
  15   new X0<1>; // expected-note{{instantiation}}
  16 }
  17
  18 // Overloaded operator delete with one argument
  19 template<int I>
  20 struct 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
  29 void test_X1() {
  30   new X1<1>; // expected-note{{instantiation}}
  31 }
  32
  33 // Overloaded operator delete for placement new
  34 template<int I>
  35 struct 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
  48 void test_X2() {
  49   new (0, 0) X2<1>; // expected-note{{instantiation}}
  50 }
  51
  52 // Operator delete template for placement new
  53 struct 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
  65 void test_X3() {
  66   new (0, 0) X3; // expected-note{{instantiation}}
  67 }
  68
  69 // Operator delete template for placement new in global scope.
  70 struct X4 {
  71   X4();
  72   static void* operator new(size_t, double, double);
  73 };
  74
  75 template<typename T>
  76 void operator delete(void*, T x, T) {
  77   double *dp = &x;
  78   int *ip = &x; // expected-error{{cannot initialize}}
  79 }
  80
  81 void test_X4() {
  82   new (0, 0) X4; // expected-note{{instantiation}}
  83 }
  84
  85 // Useless operator delete hides global operator delete template.
  86 struct X5 {
  87   X5();
  88   static void* operator new(size_t, double, double);
  89   void operator delete(void*, double*, double*);
  90 };
  91
  92 void 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
  97 template<int I>
  98 struct 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
 110 void test_X6() {
 111   new X6<3>; // expected-note 2{{instantiation}}
 112 }
 113
 114 void *operator new(size_t, double, double, double);
 115
 116 template<typename T>
 117 void operator delete(void*, T x, T, T) {
 118   double *dp = &x;
 119   int *ip = &x; // expected-error{{cannot initialize}}
 120 }
 121 void 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
 129 template<int I>
 130 struct 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
 137 void test_X7() {
 138   new X7<1>;
 139 }
 140 #endif
 141