Home | History | Annotate | Download | only in specialized.destroy
      1 //===----------------------------------------------------------------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is dual licensed under the MIT and the University of Illinois Open
      6 // Source Licenses. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 
     10 // UNSUPPORTED: c++98, c++03, c++11, c++14
     11 
     12 // <memory>
     13 
     14 // template <class _Tp>
     15 // void destroy_at(_Tp*);
     16 
     17 #include <memory>
     18 #include <cstdlib>
     19 #include <cassert>
     20 
     21 struct Counted {
     22   static int count;
     23   static void reset() { count = 0; }
     24   Counted() { ++count; }
     25   Counted(Counted const&) { ++count; }
     26   ~Counted() { --count; }
     27   friend void operator&(Counted) = delete;
     28 };
     29 int Counted::count = 0;
     30 
     31 struct VCounted {
     32   static int count;
     33   static void reset() { count = 0; }
     34   VCounted() { ++count; }
     35   VCounted(VCounted const&) { ++count; }
     36   virtual ~VCounted() { --count; }
     37   friend void operator&(VCounted) = delete;
     38 };
     39 int VCounted::count = 0;
     40 
     41 struct DCounted : VCounted {
     42     friend void operator&(DCounted) = delete;
     43 };
     44 
     45 int main()
     46 {
     47     {
     48     void* mem1 = std::malloc(sizeof(Counted));
     49     void* mem2 = std::malloc(sizeof(Counted));
     50     assert(mem1 && mem2);
     51     assert(Counted::count == 0);
     52     Counted* ptr1 = ::new(mem1) Counted();
     53     Counted* ptr2 = ::new(mem2) Counted();
     54     assert(Counted::count == 2);
     55     std::destroy_at(ptr1);
     56     assert(Counted::count == 1);
     57     std::destroy_at(ptr2);
     58     assert(Counted::count == 0);
     59     std::free(mem1);
     60     std::free(mem2);
     61     }
     62     {
     63     void* mem1 = std::malloc(sizeof(DCounted));
     64     void* mem2 = std::malloc(sizeof(DCounted));
     65     assert(mem1 && mem2);
     66     assert(DCounted::count == 0);
     67     DCounted* ptr1 = ::new(mem1) DCounted();
     68     DCounted* ptr2 = ::new(mem2) DCounted();
     69     assert(DCounted::count == 2);
     70     assert(VCounted::count == 2);
     71     std::destroy_at(ptr1);
     72     assert(VCounted::count == 1);
     73     std::destroy_at(ptr2);
     74     assert(VCounted::count == 0);
     75     std::free(mem1);
     76     std::free(mem2);
     77     }
     78 }
     79