fork download 
  1. #include <cstdio>
  2. #include <cstdlib>
  3. #include <utility>
  4.  
  5.  
  6. template <typename T>
  7. struct default_delete {
  8.     void operator ()(T *ptr) {
  9.         delete ptr;
  10.     }
  11. };
  12.  
  13. template <typename T, typename Deleter = default_delete<T>>
  14. class unique_ptr {
  15. public:
  16.     unique_ptr(T* resource = nullptr, Deleter deleter = Deleter{})
  17.         : resource{resource}, deleter{deleter} {}
  18.  
  19.     unique_ptr(const unique_ptr&) = delete;
  20.     unique_ptr(unique_ptr&& other) 
  21.         : resource{std::move(other.resource)},
  22.           deleter{std::move(other.deleter)} {}
  23.  
  24.     unique_ptr& operator=(const unique_ptr&) = delete;
  25.     unique_ptr& operator=(unique_ptr&& other) {
  26.         using std::swap;
  27.         swap(other.resource, resource);
  28.         swap(other.deleter, deleter);
  29.     }
  30.  
  31.     ~unique_ptr() {
  32.         deleter(resource);
  33.     }
  34.  
  35.     T* get() { return resource; }
  36.     const T* get() const { return resource; }
  37.  
  38. private:
  39.     T* resource;
  40.     Deleter deleter;
  41. };
  42.  
  43.  
  44. /**** example starts here ****/
  45.  
  46. // partial specialization for arrays of default_delete
  47. template <typename T>
  48. struct default_delete<T[]> {
  49.     void operator()(T arr[]) {
  50.         delete[] arr;
  51.     }
  52. };
  53.  
  54. // partial specialization of uniqe_ptr for arrays
  55. // (to avoid adding another pointer layer to the array)
  56. template <typename T, typename Deleter>
  57. class unique_ptr<T[], Deleter> {
  58. public:
  59.     unique_ptr(T resource[] = nullptr, Deleter deleter = Deleter{})
  60.         : resource{resource}, deleter{deleter} {}
  61.  
  62.     unique_ptr(const unique_ptr&) = delete;
  63.     unique_ptr(unique_ptr&& other) 
  64.         : resource{std::move(other.resource)},
  65.           deleter{std::move(other.deleter)} {}
  66.  
  67.     unique_ptr& operator=(const unique_ptr&) = delete;
  68.     unique_ptr& operator=(unique_ptr&& other) {
  69.         using std::swap;
  70.         swap(other.resource, resource);
  71.         swap(other.deleter, deleter);
  72.     }
  73.  
  74.     ~unique_ptr() {
  75.         deleter(resource);
  76.     }
  77.  
  78.     T* get() { return resource; }
  79.     const T* get() const { return resource; }
  80.  
  81. private:
  82.     T* resource;
  83.     Deleter deleter;
  84. };
  85.  
  86.  
  87. int main() {
  88.     unique_ptr<int[]> arr_ptr(new int[5]); // uses the specialized version with
  89.                                            // correct deleter
  90. }
  91.  
Success #stdin #stdout 0s 4440KB
comments (?)
stdin 
Standard input is empty
stdout 
Standard output is empty
https://ideone.com/CzLHU2
language:
C++14 (gcc 8.3)
created:
7 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!