/* RULE OF THREE
if you define a custome destructor, copy constructor or copy = operator,
then you should define all three, and define them consistently.

Rule of Five: both custom copy and move semantics, define all five.

Ruel of Zero: Use smart pointers, leave to defaults.  Separate copying
from cloning.
*/
#include<iostream>
#include<vector>
#include<memory>
#include<cstring>
using namespace std;

template<typename T>    // a structure implementing the rule of five
struct myvector {
private:
  T* ptr;
  unsigned int length{0};
  unsigned int capacity;
public:
  myvector(unsigned int cap) {
    ptr = new T[cap];
    capacity = cap;
  }

  myvector(std::initializer_list<T> m) {
    ptr = new T[m.size()];
    capacity = m.size();
    for(auto x:m) ptr[length++] = x;
  }

  T& operator [](unsigned int i) { return ptr[i]; }

  ~myvector() { if (ptr) delete[] ptr; }

  void resize() {  // double capacity
    T* ptr2 = new T[capacity*2];
    capacity *= 2;
    for(int i=0;i<length;i++) ptr2[i] = ptr[i];
    if (ptr) delete[] ptr;
    ptr = ptr2;
  }

  void push_back(T x) {
    if (length >= capacity) resize();
    ptr[length++] = x;
  }

  T pop_back() {
    return ptr[--length];
  }

  // copy constructor
  myvector(const myvector<T>& other) {
    capacity = other.capacity;
    length = other.length;
    ptr = new T[capacity];
    for(int i=0;i<length;i++) ptr[i] = other.ptr[i];
  }

  const myvector<T>& operator =(const myvector<T>& other) {
    capacity = other.capacity;
    length = other.length;
    if (ptr) delete[] ptr;
    ptr = new T[capacity];
    for(int i=0;i<length;i++) ptr[i] = other.ptr[i];
    return other;
    }

  // C++ 11 and later
  // define move semantics:

  // move constructor and a move = operator

  myvector(myvector<T>&& other) {  // move constructor
    capacity = other.capacity;
    length = other.length;
    ptr = other.ptr;
    other.ptr = nullptr;
    other.capacity = 0;
    other.length = 0;
  }

  void operator =(myvector<T>&& other) {
    capacity = other.capacity;
    length = other.length;
    
    if (ptr) delete[] ptr;   // unique_ptr
    ptr = other.ptr;
    other.ptr = nullptr;
    // transfer of ownership
    
    other.capacity = 0;
    other.length = 0;    
  }
  
};

// Modern version, using the RULE OF ZERO
template<typename T>
struct vec {
private:
  unique_ptr<T[]> ptr;
  unsigned int length{0};
  unsigned int capacity;
public:
  vec(unsigned int cap) {
    ptr = make_unique<T[]>(cap);
    capacity = cap;
  }

  vec(std::initializer_list<T> m) {
    ptr = make_unique<T[]>(m.size());
    capacity = m.size();
    for(auto x:m) ptr[length++] = x;
  }  

  void resize() {
    capacity *= 2;
    unique_ptr<T[]> ptr2 = make_unique<T[]>(capacity);
    for(int i=0;i<length;i++) ptr2[i] = move(ptr[i]);
    ptr = move(ptr2);
  }

  void push_back(T x) {
    if (length>=capacity) resize();
    ptr[length++] = move(x);
  }

  T pop_back() {
    return ptr[--length];
  }

  // separate cloning from copying.
  vec<T> clone() {
    vec<T> theclone(capacity);
    theclone.length = length;
    for(int i=0;i<length;i++) theclone.ptr[i] = ptr[i];
    return theclone;
  }
};

int main() {
  myvector<int> v{3,4,5,6};
  myvector<int> w{1,2,3,4,5};
  cout << v[1] << endl;
  v.push_back(99);
  v[2] = 88;
  cout << v[4] << endl;

  myvector<int> z = w;  // call move constructor

  v = move(w);  // call move = operator
  cout << v[0] << endl;
  //cout << w[0] << endl;

  unique_ptr<int> a = make_unique<int>(5); // int* a = new int(5);
  unique_ptr<int[]> b = make_unique<int[]>(5); // int *b = new int[5];

  unique_ptr<int> c = make_unique<int>(6);

  c = move(a);
  // if c is pointing to something, delete it
  // c = a
  // a = nullptr;

  // don't mix raw pointers with unique pointers:
  //memcpy(&a,&c,sizeof(unique_ptr<int>));

  int x = 2;
  int y = 3;
  x = move(y); // x=y

  cout << *c << endl;
  //cout << *a << endl;
  vec<int> p{3,4,5,6};
  vec<int> q{1,23,4,5,7};
  p = move(q);
  return 0;  
}//main