最后一个函数未显示正确的输出

我没有获得我编码的程序的预期输出，我知道最后一个函数的实现不正确。我不知道如何实现这一点，以便它返回数组中的最后一个条目，并且不会删除它。我的第二个问题是关于pop_back函数，它应该删除推送到向量中的最后一个条目并将其减少一个，如果它是空的，则什么都不做。现在的方式只是将向量减少了一个。提前感谢您的帮助。

司机

#include <iostream>
#include "vectorHeader.h"
using namespace std;
int main()
{
const char START = 'A';
const int MAX = 12;
// create a vector of doubles
myVector<char> vectD;
// push some values into the vector
for (int i = 0; i < MAX; i++)
{
    vectD.push_back(START + i);
}
// remove the last element
vectD.pop_back();
// add another value
vectD.push_back('Z');
// test memory management
myVector<char> vectD2 = vectD;
// display the contents
cout << "n[";
for (int i = 0; i < vectD2.size() - 1; i++)
{
    cout << vectD2[i] << ", ";
}
cout << "..., " << vectD2.last() << "]n";

system("PAUSE");
return 0;
}

页眉

#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <fstream>
#include <stdexcept>
#include <array>

//Declaring constant
const int VECTOR_CAP = 2;
template <class T>
class myVector
{
private:
    //Setting data members
    T* vectorData;
    int cap;
    int numElements;
public:
    //Default constructor
    //Purpose: Creates a vector
    //Parameters: None
    //Returns: None
    myVector();
    //Parameterized constructor
    //Purpose: Creates a vector capacity of n
    //Parameters: None
    //Returns: None
    myVector(const T&);
//Copy Constructor
//Purpose: Copy data into vector
//Parameters: myVector object
//Returns: None
myVector(const myVector& copy)
{
    numElements = copy.numElements;
    vectorData = new T [numElements];
    for (int i = 0; i < numElements; i++)
    {
        this->vectorData[i] = copy.vectorData[i];
    }
}
//Destructor
//Purpose:Deletes any dynamically allocated storage
//Parameters: None
//Returns: None
~myVector();
//Size function
//Purpose: returns the size of your vector
//Parameters: None
//Returns: The size of your vector as an integer
int size() const;
//Capacity function
//Purpose: Returns the capacity of the vector
//Parameters: None
//Returns: Maximum value that your vector can hold
int capacity() const;
//Clear function
//Purpose: Deletes all of the elements from the vector and resets its size to
// zero and its capacity to two; thus becoming empty
//Parameters: None
//Returns: None
void clear();
//push_back function
//Purpose: Adds the integer value n to the end of the vector
//Parameters: Takes a integer to be placed in the vector
//Returns: None
void push_back(const T& n)
{
    //If statement to handle if array is full 
    if (numElements == cap)
    {
        //Doubling the capacity 
        cap = cap * VECTOR_CAP;
        //Allocating new array 
        T* newVectorData = new T[cap];
        //Copying data
        for (int i = 0; i < numElements; i++) newVectorData[i] = vectorData[i];
        //Deleting previous data
        delete[] vectorData;
        //Pointing to new data
        vectorData = newVectorData;
    }
    //Storing data
    vectorData[numElements++] = n;
}
//at function
//Purpose: Returns the value of the element at position n in the vector
//Parameters: None
//Returns: Returns your current place with the vector
T& at(std::size_t);
//assignment
//Purpose: Overload the = operator
//Parameters: The two myVector objects we want to assign
    //Returns: The assignment
    myVector operator=(const myVector&);
    void pop_back();
    int last();
    T& operator[](std::size_t);
};
//Independant Functions
template <typename T>
myVector<T>::myVector()
{
    //Setting the cap
    cap = VECTOR_CAP;
    //Creating the array
    vectorData = new T[cap];
    //Initializing the value
    numElements = 0;
}
template <typename T>
myVector<T>::~myVector()
{
    cap = 0;
    //Delete array elements
    delete[] vectorData;
    //Allocate vectorData
    vectorData = NULL;
}
template <typename T>
int myVector<T>::size() const
{
    return numElements;
}
template <typename T>
void myVector<T>::pop_back() 
{
    numElements--;
}
template <typename T>
int myVector<T>::last() 
{
    return cap;
}

template <typename T>
int myVector<T>::capacity() const
{
    return cap;
}
template <typename T>
T& myVector<T>::at(std::size_t n)
{
    return vectorData[n];
}
template <typename T>
T& myVector<T>::operator[](std::size_t n)
{
    return vectorData[n];
}
template <typename T>
myVector<T> myVector<T>::operator=(const myVector& rho)
{
    //Test for assingment
    if (this == &rho)
    {
        return *this;
    }
    //Delete lho
    delete[] this->vectorData;
    //Creating new array to fit rho data
    cap = rho.cap;
    this->vectorData = new int[cap];
    //Copying data
    for (int i = 0; i < numElements; i++)
    {
        this->vectorData[i] = rho.vectorData[i];
    }
    //Returning myVector object
    return *this;
}    

template <typename T>
std::ostream& operator<<(std::ostream& out, const myVector<T>& rho)
{
    for (int n = 0; n < rho.size(); n++)
    {
        out << rho.at(n);
    }
    return out;
}