#include <algorithm>
#include <cstddef>
#include <iostream>

using namespace std;
class Holder {
private:
  int *m_data;
  size_t m_size;

public:
  // constructor
  Holder(int size) {
    m_data = new int[size];
    m_size = size;
  }

  // destructor
  ~Holder() {
    delete[] m_data;
  }

  // copy constructor: initialize [this] from already-existing object
  // (other is read-only reference)
  Holder(const Holder &other) {
    m_data = new int[other.m_size];
    std::copy(other.m_data, other.m_data + other.m_size, m_data);
    m_size = other.m_size;
  }

  // copy assignment constructor: nuke [this] and re-initizlize from
  // already-existing object
  Holder &operator=(const Holder &other) {
    if (this == &other) {
      return *this;
    }
    // first nuke existing data
    delete[] m_data;
    // same as copy constructor
    m_data = new int[other.m_size];
    std::copy(other.m_data, other.m_data + other.m_size, m_data);
    m_size = other.m_size;
    return *this;
  }

  // move constructor : reuse resource from other, no need to copy
  Holder(Holder &&other) {
    m_data = other.m_data;
    m_size = other.m_size;
    // prevent the data from being freed when other goes out of scope
    other.m_data = nullptr;
    other.m_size = 0;
  }

  // move assignment operator
  Holder &operator=(Holder &&other) {
    // same as first step of assignment oplerator
    if (this == &other)
      return *this;
    delete[] m_data;
    // same as copy constructor
    m_data = other.m_data;
    m_size = other.m_size;
    other.m_data = nullptr;
    other.m_size = 0;
    return *this;
  }
};

// if you simply return Holder h(size) the compiler may inline this function
// even with -fno-elide-constructors
Holder createHolder(size_t size) {
  Holder h(size);
  return h;
}

int main() {
  // default constructor
  Holder h0(0x1);
  Holder g1(0x2);
  Holder g2(0x2);
  Holder g3(0x2);

  // copy constructor:
  // h0 is a lvalue, therefore it's not safe to move
  Holder h1(h0);

  // default constructor in createHolder() to create the temporary RVALUE
  // then move constructor to create h2;
  // when move-constructor is not defined, this falls back to copy;
  // finally destructor on the temporary value (out-of-scope).
  Holder h2(createHolder(0x2));

  // copy assignment because h1 is LVALUE thus unsafe to move
  g1 = h1;

  // move assignment because functurn returns RVALUE (safe to move)
  // however with -fno-elide-copy there is an extra move-constructor
  // in-between. WHY?
  g2 = createHolder(500);

  // move assignment with lvalue because we explicitly do so.
  // std::move() also falls back to copy if move methods are not present
  g3 = std::move(h1);       // move assignment with lvalue
  Holder g4(std::move(g3)); // move constructor with lvalue

  return 0;
}