Class vector

stdlib/cpp/vector.hpp:10–302

template <typename T>
class vector {
public:
    using value_type = T;
    using size_type = size_t;

    using iterator = T*;
    using const_iterator = const T*;

private:
    T* data_;
    size_type size_;
    size_type capacity_;

    // Helper function for geometric growth
    void grow_capacity() {
        size_type new_capacity = capacity_ == 0 ? 1 : capacity_ * 2;
        reserve(new_capacity);
    }

public:
    // Constructors
    vector() noexcept : data_(nullptr), size_(0), capacity_(0) {}

    explicit vector(size_type count, const T& value = T())
        : data_(allocate(count)), size_(count), capacity_(count)
    {
        for (size_type i = 0; i < size_; ++i) {
            new (&data_[i]) T(value); // Use placement new for construction
        }
    }

    // Copy Constructor
    vector(const vector& other)
        : data_(allocate(other.size_)), size_(other.size_), capacity_(other.size_)
    {
        for (size_type i = 0; i < size_; ++i) {
            new (&data_[i]) T(other.data_[i]); // Use placement new for construction
        }
    }

    // Destructor
    ~vector() {
        clear(); // Destroy elements
        deallocate(data_); // Deallocate memory
    }

    // Copy Assignment Operator
    vector& operator=(const vector& other) {
        if (this != &other) {
            // A simple but not fully exception-safe implementation
            clear();
            deallocate(data_);

            data_ = allocate(other.capacity_);
            capacity_ = other.capacity_;
            size_ = other.size_;
            for (size_type i = 0; i < size_; ++i) {
                new (&data_[i]) T(other.data_[i]);