#include <iostream>
#include <random>
#include <algorithm>

using namespace std;

using pointed_to = int;

class Pointer_Counter
{
public:
  Pointer_Counter(pointed_to* p = nullptr) : pointer(p), counter(new int(1)) {}
  ~Pointer_Counter();
  
  Pointer_Counter(Pointer_Counter const& pc);
  Pointer_Counter& operator=(Pointer_Counter const& pc);

  pointed_to& operator*() { return *pointer; }
  
private:
  pointed_to* pointer;
  int* counter;
};

Pointer_Counter::~Pointer_Counter()
{
  if ( --*counter == 0 )
  {
    delete pointer;
    delete counter;
  }
}
  
Pointer_Counter::Pointer_Counter(Pointer_Counter const& pc)
{
  pointer = pc.pointer;
  counter = pc.counter;
  ++*counter;
}

Pointer_Counter& Pointer_Counter::operator=(Pointer_Counter const& pc)
{
  if ( this != &pc )
  {
    Pointer_Counter copy(pc);
    swap(pointer, copy.pointer);
    swap(counter, copy.counter);
  }
  return *this;
}

int main()
{
  random_device generator;
  uniform_int_distribution<int> r(1,50);
  uniform_int_distribution<int> s(1,4);

  vector<Pointer_Counter> a;
  vector<Pointer_Counter> b;
  vector<Pointer_Counter> c;
  
  for (int i = 0; i < 20; ++i)
  {
    int* n = new int(r(generator));

    switch ( s(generator) )
    {
      case 1:
        a.push_back(Pointer_Counter(n));
        break;
      case 2:
        a.push_back(Pointer_Counter(n));
        b.push_back(Pointer_Counter(nullptr));
        b.back() = a.back();
        break;
      case 3:
        b.push_back(Pointer_Counter(n));
        c.push_back(Pointer_Counter(nullptr));
        c.back() = a.back();
        break;
      case 4:
        c.push_back(Pointer_Counter(n));
        break;
    }
  }

  cout << "a = ";
  for (unsigned int i = 0; i < a.size(); ++i)
    cout << *a.at(i) << " ";
  cout << endl;
  
  cout << "b = ";
  for (unsigned int i = 0; i < b.size(); ++i)
    cout << *b.at(i) << " ";
  cout << endl;
  
  cout << "c = ";
  for (unsigned int i = 0; i < c.size(); ++i)
    cout << *c.at(i) << " ";
  cout << endl;
  
  return 0;
}