Implementing a Custom std::vector::pop_back Function in C

When working with C and needing similar functionality to the std::vector class, one common operation is the removal of the last element in the vector, which is achieved through the pop_back function. While the std::vector class provides this functionality out-of-the-box, for educational or custom application purposes, implementing it from scratch can be insightful.

Step-by-Step Implementation

To implement a custom pop_back function for a dynamic array, you need to manage several aspects, including the memory and size of the underlying array. Follow these steps to create a basic implementation that mimics the functionality of std::vector.

Dynamic Array Management

Use a pointer to manage the dynamic array. This allows you to allocate memory dynamically and adjust its size as needed. The size of the array needs to be tracked to keep a constant reference to the number of elements currently in the array.

Memory and Size Management

Proper memory allocation and deallocation are crucial. When push_back is called and the current array is full, its capacity should be doubled to accommodate more elements. Ensure that the old array is properly deallocated to prevent memory leaks.

Example Code

Below is a basic implementation of a custom MyVector class that mimics std::vector with a pop_back function:

#include iostream #include stdexcept template typename T class MyVector { private: T *data; // Pointer to the dynamic array size_t capacity; // Total capacity of the array size_t size; // Current number of elements in the array void resize() { capacity capacity 0 ? 1 : capacity * 2; // Double the capacity T *newData new T[capacity]; // Allocate new array for (size_t i 0; i size; i) { newData[i] data[i]; // Copy old elements } delete[] data; // Free old array data newData; // Point to new array } public: MyVector() : data(nullptr), capacity(0), size(0) {} ~MyVector() { delete[] data; // Free allocated memory } void push_back(const T value) { if (size capacity) { resize(); // Resize if needed } data[size] value; // Add new element } void pop_back() { if (size 0) { throw std::out_of_range(pop back from empty vector); } --size; // Decrease size to remove last element } size_t getSize() const { return size; // Return current size } // Additional methods for demonstration T operator[](size_t index) { if (index size) { throw std::out_of_range(Array index out of bounds); } return data[index]; } }; int main() { MyVectorint myVec; myVec.push_back(1); myVec.push_back(2); myVec.push_back(3); std::cout Before pop_back: () ; myVec.pop_back(); std::cout After pop_back: () ; return 0; }

Explanation

Dynamic Memory Allocation: The class allocates memory for the array dynamically. When push_back is called and the array is full, its capacity is doubled to accommodate more elements. If the array is full, the resize function is called to reallocate memory for a larger array. Error Handling: The pop_back function checks if the vector is empty. If it is, an std::out_of_range exception is thrown, similar to how std::vector behaves. If the vector is not empty, the last element is removed by decrementing the size. Destructor: The destructor frees the allocated memory to prevent memory leaks. This ensures that all dynamically allocated memory is deallocated when the object is destroyed. Basic Operations: The example includes a push_back method to add elements and a simple index operator for accessing elements. Additional methods like resize, getSize, and operator[] provide more control over the vector.

This implementation is a basic illustration and can be expanded with more features like copy constructors, assignment operators, and more sophisticated memory management to closely resemble std::vector. For production-level code, consider using established libraries or #include vector for robust and optimized functionality.