SHARE
TWEET

Untitled

a guest Mar 19th, 2019 57 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <utility>
  2.  
  3. struct BadOptionalAccess {
  4. };
  5.  
  6. template <typename T>
  7. class Optional {
  8. private:
  9.     alignas(T) unsigned char data[sizeof(T)];
  10.     bool defined = false;
  11.  
  12. public:
  13.     Optional() = default;
  14.  
  15.     Optional(const T& elem) : defined(true) {
  16.         new (data) T(elem);
  17.     }
  18.  
  19.     Optional(T && elem) : defined(true) {
  20.         new (data) T(std::move(elem));
  21.     }
  22.  
  23.     Optional(const Optional& other) : defined(other.defined) {
  24.         if (defined) {
  25.             new (data) T(*other);
  26.         }
  27.     }
  28.  
  29.     Optional& operator=(const Optional& other) {
  30.         if (defined && other.defined) {
  31.             *(*this) = *other;
  32.         } else if (defined && !other.defined) {
  33.             (*this).reset();
  34.             defined = false;
  35.         } else if (!defined && other.defined) {
  36.             new (data) T(*other);
  37.             defined = true;
  38.         }
  39.         return *this;
  40.     }
  41.  
  42.     Optional& operator=(const T& elem) {
  43.         if (defined) {
  44.             *(*this) = elem;
  45.         } else {
  46.             new (data) T(elem);
  47.             defined = true;
  48.         }
  49.         return *this;
  50.     }
  51.  
  52.     Optional& operator=(T&& elem) {
  53.         if (defined) {
  54.             *(*this) = std::move(elem);
  55.         } else {
  56.             new (data) T(std::move(elem));
  57.             defined = true;
  58.         }
  59.         return *this;
  60.     }
  61.  
  62.     bool has_value() const {
  63.         return defined;
  64.     }
  65.  
  66.     T& operator*() {
  67.         if (defined) {
  68.             return *reinterpret_cast<T*>(data);
  69.         }
  70.     }
  71.  
  72.     const T& operator*() const {
  73.         if (defined) {
  74.             return *reinterpret_cast<const T*>(data);
  75.         }
  76.     }
  77.  
  78.     T* operator->() {
  79.         if (defined) {
  80.             return reinterpret_cast<T*>(data);
  81.         }
  82.     }
  83.  
  84.     const T* operator->() const {
  85.         if (defined) {
  86.             return reinterpret_cast<const T*>(data);
  87.         }
  88.     }
  89.  
  90.     T& value() {
  91.         if (defined) {
  92.             return *(*this);
  93.         }
  94.         throw BadOptionalAccess();
  95.     }
  96.  
  97.     const T& value() const {
  98.         if (defined) {
  99.             return *(*this);
  100.         }
  101.         throw BadOptionalAccess();
  102.     }
  103.  
  104.     void reset() {
  105.         if (defined) {
  106.             defined = false;
  107.             reinterpret_cast<T*>(data)->~T();
  108.         }
  109.     }
  110.  
  111.     ~Optional() {
  112.         (*this).reset();
  113.     }
  114. };
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top