C++ dynamic objects

outer_queue = new Queue //allocates memory at location X, constructs a queue object on top
newQueue(outer_queue)

void (newQueue* inner_queue)
{
  delete inner_queue; //delete destructs the object at location X and allows the memory at
                       // X to be reused. inner_queue and outer_queue both still point at X
  inner_queue = new Queue(capacitiy) //allocates memory at location X (because it was
                                     // the most recently free'd block of memory) and
                                     // constructs the new queue
}

Queue* q = new Queue();
q = newQueue(q);

Queue* newQueue(Queue* q)
{
  /*
    ...snip...
  */
  cin >> c;
  delete q;
  q = 0;
  q = new Queue(c);
  return q;
}

Queue* q = new Queue();
newQueue(&q);

void newQueue(Queue** q)
{
  /*
    ...snip...
  */
  Queue * ptr = (*q); // More readable
  cin >> c;
  delete ptr;
  ptr = new Queue(c);
}

Queue* q = new Queue();
newQueue(q);

void newQueue(Queue&* q)
{
  /*
    ...snip...
  */
  cin >> c;
  delete q;
  q = new Queue(c);
}

cin << cap;
Queue* q = new Queue(cap);

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

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

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;