C++ dynamic objects - Page 2

Queue *queue = new Queue; //default capacity 10
newQueue(queue);

void newQueue(Queue *queue){
...
cin >> capacity;
delete queue;
queue = new Queue(capacity);
}

Queue createQueue()
{
   ...
   std::cin >> capacity;
   return Queue(capacity);
}

Queue queue;  // default capacity 10
...
queue = createQueue();

class Queue
{
  private:
      std::size_t m_capacity;   // basically an unsigned int
      int* m_data;

  public:
      Queue(std::size_t capacity)
         // an initialisation list (google it if you don't know it)
        : m_capacity(capacity), m_data( new int[capacity]() )
      { 
      }
      
      // Copy constructor
      Queue(const Queue& rhs)  // must take rhs param by const ref
         // Allocates its own memory area large enough to hold rhs's data ...
         : m_capacity(rhs.m_capacity), m_data( new int[rhs.m_capacity] )
      {
         // ... and then copies rhs's data into it
         std::copy( rhs.m_data, rhs.m_data + m_capacity, m_data );   

         // include <algorithm> for std::copy
      }
   
      // Assignment operator
      // Take rhs param by value, it invokes the copy constructor above
      Queue& operator=(Queue rhs)
      {
        swap(*this, rhs);  // swap our contents with rhs (a cheap operation)
        return *this;

        // rhs goes out of scope, invoking its destructor
        // (it will free the memory we used to own)
      }

      // Swap our members
      friend void swap(Queue& a, Queue& b)
      {
         using std::swap;  // include <utility> for std::swap
         swap(a.m_capacity, b.m_capacity);
         swap(a.m_data, b.m_data);
      }

      // Free the memory we own
      ~Queue()
      {
         delete [] m_data;
      }

      ... enqueue functions, etc. 
      ... I'm unconcerned with that, as this is just about managing resources
      ... tried to keep this example as simple as possible
}

Queue q1;
Queue q2(q1);  // Invokes copy constructor
Queue q3 = q1; // Invokes copy constructor (exactly the same as above)
q1 = q2;       // Invokes assignment operator (not an initialisation)

      // Assignment operator
      Queue& operator=(Queue rhs)   // take param by value, it invokes the copy constructor above
      {
        swap(*this, rhs);  // swap our contents with the rhs (a cheap operation)
        return *this;
        // rhs goes out of scope, invoking its destructor (it will free the memory we used to own)
      }

  private:
      int* m_data;
      std::size_t m_capacity;   // basically an unsigned int

  public:
      Queue(std::size_t capacity)
         // an initialisation list (google it if you don't know it)
        : m_capacity(capacity), m_data( new int[capacity]() )
      { 
      }

  private:
      std::size_t m_capacity;   // basically an unsigned int
      int* m_data;