C / C++ Code Portfolio

void pop(); // Remove front element from queue
T &front(); // Return ref to front element in queue
const T &front() const; // Return const ref to front element in queue
bool empty() const; // Return whether queue is empty
size_t size() const; // vused_ accessor

private:
T* v_; // Elements in queue
size_t vsize_; // Max number of elements in queue
size_t vused_; // Number of elements in queue
};


template<typename T>
Queue::Queue() : v_(static_cast(operator new(sizeof(T) * initialSize))), vsize_(initialSize), vused_(0)
{ }

template<typename T>
Queue::~Queue()
{
destroy(v_, v_ + vused_);
operator delete(v_);
}

// Helper function for the copy constructor, performs the copy

template<typename T>
T* newCopy(const T *src, size_t srcsize, size_t destsize)
{
// Ensure enough memory will be allocated in the destination
assert(destsize >= srcsize);
// Allocate memory for the destination copy
T* dest = new T[destsize];
try
{
// Perform the copy
copy(src, src + srcsize, dest);
}
catch (...)
{
// If there was a problem, free destination memory
delete[] dest;
throw;
}
return dest;
}

// Copy constructor

template<typename T>
Queue::Queue(const Queue &other)
: v_(newCopy(other.v_, other.vsize_, other.vsize_)), vsize_(other.vsize_), vused_(other.vused_)
{ }

// Copy assignment operator

template<typename T>
Queue& Queue::operator=(const Queue &other)
{
// if the two variables of the assignment aren't already equal, perform the assignment
if (this != &other)
{
// Create a new copy of the RHS variable
T* v_new = newCopy(other.v_, other.vsize_, other.vsize_);
// Clear the LHS variable buffer
delete[] v_;
// Make the LHS variable data members equal to the RHS variable data members
v_ = v_new;
vsize_ = other.vsize_;
vused_ = other.vused_;
}