Последняя функция не отображает правильный вывод

Question

Я не получаю ожидаемый результат для программы, которую я закодировал, я знаю, что реализация для последней функции неверна. Я не знаю, как реализовать это, чтобы он возвращал последнюю запись в массив и не удалял ее. Второй вопрос, который у меня есть, - это функция pop_back, которая должна удалить последнюю запись, вдвинутую в вектор, и уменьшить ее на единицу, а если она пустая, ничего не делать. Теперь он просто уменьшает вектор на единицу. Заранее благодарны за Вашу помощь.

Driver

#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; 
} 

Answer 1

last функция должна выглядеть следующим образом:

template <typename T> 
T myVector<T>::last() 
{ 
    return vectorData[numElements - 1]; 
} 

Функция, которая возвращает элемент из вектора должен иметь обратный введите тип векторных элементов, т. е. T в вашем ca как таковые.

cout имеет различные перегрузки для char и int. Для char он печатает символ ASCII предоставленного кода, для int он возвращает сам код. Поэтому, если ваш последний элемент равен Z, и вы вернете int, он распечатает код ASCII Z, то есть 90.

попробовать это, чтобы получить ощущение того, что я говорю:

cout << 'Z' << endl; 
cout << (char) 'Z' << endl; // tautological cast as 'Z' is char 
cout << (int) 'Z' << endl; 
cout << 90 << endl; 
cout << (int) 90 << endl; // tautological cast as 90 is int 
cout << (char) 90 << endl; 

---

Что касается pop_back все, что вы должны сделать, это:

if (numElements > 0) 
    numElements--; 

Причина: нет такого понятия, как удаление памяти. Ячейка памяти всегда имеет значение (будь то то, которое вы установили, 0, 1 или мусор). Все, что вам нужно сделать, это отметить его как доступный (или не используемый). Это то, что вы делаете, когда сокращаетесь numElements.

Если вы хотите сделать шаг дальше, вы можете сделать противоположное от push_back, т. Е. Переместить весь вектор в меньший выделенный буфер. Но это не рекомендуется, так как эти операции (выделение, копирование) стоят дорого, и вы можете обойтись без них (в отличие от pus_back, где вы должны получить больший размер)