#include <iostream>
#include <iterator> // For iterator_traits, random_access_iterator_tag
#include <algorithm>

using namespace std ;

template <typename T>
class MyVector {
private:
    T* data_;
    size_t size_;
    size_t capacity_;

public:
    // MyVector constructor, destructor, push_back, etc. (simplified for brevity)
    MyVector() : data_(nullptr), size_(0), capacity_(0) {}
    ~MyVector() { delete[] data_; }

    void push_back(const T& value) {
        if (size_ == capacity_) {
            // Reallocate and copy data
            size_t new_capacity = (capacity_ == 0) ? 1 : capacity_ * 2;
            T* new_data = new T[new_capacity];
            for (size_t i = 0; i < size_; ++i) {
                new_data[i] = data_[i];
            }
            delete[] data_;
            data_ = new_data;
            capacity_ = new_capacity;
        }
        data_[size_++] = value;
    }

    T& operator[](size_t index) { return data_[index]; }
    const T& operator[](size_t index) const { return data_[index]; }
    size_t size() const { return size_; }

    // Custom iterator nested class
    class Iterator {
    public:
        using iterator_category = random_access_iterator_tag;
        using value_type = T;
        using difference_type = ptrdiff_t;
        using pointer = T*;
        using reference = T&;

        Iterator(T* ptr) : ptr_(ptr) {}

        // Dereference operators
        reference operator*() const { return *ptr_; }
        pointer operator->() const { return ptr_; }

        // Increment operators
        Iterator& operator++() { // Pre-increment
            ++ptr_;
            return *this;
        }
        Iterator operator++(int) { // Post-increment
            Iterator temp = *this;
            ++ptr_;
            return temp;
        }

        // Decrement operators
        Iterator& operator--() { // Pre-decrement
            --ptr_;
            return *this;
        }
        Iterator operator--(int) { // Post-decrement
            Iterator temp = *this;
            --ptr_;
            return temp;
        }

        // Arithmetic operators
        Iterator operator+(difference_type n) const { return Iterator(ptr_ + n); }
        Iterator operator-(difference_type n) const { return Iterator(ptr_ - n); }
        difference_type operator-(const Iterator& other) const { return ptr_ - other.ptr_; }

        Iterator& operator+=(difference_type n) { ptr_ += n; return *this; }
        Iterator& operator-=(difference_type n) { ptr_ -= n; return *this; }

        // Comparison operators
        bool operator==(const Iterator& other) const { return ptr_ == other.ptr_; }
        bool operator!=(const Iterator& other) const { return ptr_ != other.ptr_; }
        bool operator<(const Iterator& other) const { return ptr_ < other.ptr_; }
        bool operator>(const Iterator& other) const { return ptr_ > other.ptr_; }
        bool operator<=(const Iterator& other) const { return ptr_ <= other.ptr_; }
        bool operator>=(const Iterator& other) const { return ptr_ >= other.ptr_; }

    private:
        T* ptr_;
    };

    // begin() and end() methods returning the custom iterator
    Iterator begin() { return Iterator(data_); }
    Iterator end() { return Iterator(data_ + size_); }
    const Iterator cbegin() const { return Iterator(data_); }
    const Iterator cend() const { return Iterator(data_ + size_); }
};

int main()
{
    MyVector<int> vec;
    vec.push_back(10);
    vec.push_back(30);
    vec.push_back(20);

    // Using the custom iterator with a range-based for loop
    //MyVector needs to implement begin() and end() methods
    for (int x1 : vec) {
        cout << x1 << " ";
    }
    cout << endl;

    // Using the custom iterator with explicit begin/end
    for (MyVector<int>::Iterator it = vec.begin(); it != vec.end(); ++it) {
        cout << *it << " ";
    }
    cout << endl;

    sort( vec.begin() ,   vec.end()  )  ;

    for (MyVector<int>::Iterator it = vec.begin(); it != vec.end(); ++it) {
        cout << *it << " ";
    }
    cout << endl;

    return 0;
}