язык без ООП даже рассматривать не стоит

#include <iostream>

#include <stdexcept>
#include <utility>
#include <iterator>  // для std::iterator

template<typename T>
class SimpleVector {
private:
    T* _data; // Тип должен быть T*, а не uint8_t*
    uint8_t _size;
    uint8_t _capacity;
    
public:
    SimpleVector() : _size(0), _capacity(10)
    {
        _data = new T[_capacity]; // Соответствует типу T
    }
    
    ~SimpleVector()
    {
        delete[] _data;
    }
    
    SimpleVector(const SimpleVector& other) : _size(other._size), _capacity(other._capacity)
    {
        _data = new T[_capacity];
        for (uint8_t i = 0; i < _size; ++i)
        {
            _data[i] = other._data[i];
        }
    }
    
    SimpleVector& operator=(const SimpleVector& other)
    {
        if (this == &other) return *this;
        
        delete[] _data;
        
        _size = other._size;
        _capacity = other._capacity;
        _data = new T[_capacity];
        
        for (uint8_t i = 0; i < _size; ++i)
        {
            _data[i] = other._data[i];
        }
        
        return *this;
    }
    
    SimpleVector(SimpleVector&& other) noexcept(std::is_nothrow_move_constructible<T>::value)
    : _data(other._data), _size(other._size), _capacity(other._capacity)
    {
        other._data = nullptr;
        other._size = 0;
        other._capacity = 0;
    }
    
    SimpleVector& operator=(SimpleVector&& other) noexcept(std::is_nothrow_move_constructible<T>::value)
    {
        if (this == &other) return *this;
        
        delete[] _data;
        
        _data = other._data;
        _size = other._size;
        _capacity = other._capacity;
        
        other._data = nullptr;
        other._size = 0;
        other._capacity = 0;
        
        return *this;
    }
    
    T& operator[](uint8_t index)
    {
        if (index >= _size) throw std::out_of_range("Index out of range");
        return _data[index];
    }
    
    void pushBack(const T& value)
    {
        if (_size == _capacity) resize();
        _data[_size++] = value;
    }
    
    uint8_t size() const
    {
        return _size;
    }
    
    uint8_t capacity() const
    {
        return _capacity;
    }
    
    // Итератор (неконстантный)
    class iterator {
    private:
        T* _ptr;
        
    public:
        using iterator_category = std::random_access_iterator_tag;
        using value_type = T;
        using difference_type = std::ptrdiff_t;
        using pointer = T*;
        using reference = T&;
        
        explicit iterator(T* ptr) : _ptr(ptr) {}
        
        T& operator*() const
        {
            return *_ptr;
        }
        
        iterator& operator++()
        {
            _ptr++;
            return *this;
        }
        
        iterator operator++(int)
        {
            iterator temp = *this;
            ++(*this);
            return temp;
        }
        
        iterator& operator--()
        {
            _ptr--;
            return *this;
        }
        
        iterator operator--(int)
        {
            iterator temp = *this;
            --(*this);
            return temp;
        }
        
        bool operator==(const iterator& other) const
        {
            return _ptr == other._ptr;
        }
        
        bool operator!=(const iterator& other) const
        {
            return _ptr != other._ptr;
        }
        
        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;
        }
    };
    
    // Константный итератор
    class const_iterator {
    private:
        const T* _ptr;
        
    public:
        using iterator_category = std::random_access_iterator_tag;
        using value_type = T;
        using difference_type = std::ptrdiff_t;
        using pointer = const T*;
        using reference = const T&;
        
        explicit const_iterator(const T* ptr) : _ptr(ptr) {}
        
        const T& operator*() const
        {
            return *_ptr;
        }
        
        const_iterator& operator++()
        {
            _ptr++;
            return *this;
        }
        
        const_iterator operator++(int)
        {
            const_iterator temp = *this;
            ++(*this);
            return temp;
        }
        
        const_iterator& operator--()
        {
            _ptr--;
            return *this;
        }
        
        const_iterator operator--(int)
        {
            const_iterator temp = *this;
            --(*this);
            return temp;
        }
        
        bool operator==(const const_iterator& other) const
        {
            return _ptr == other._ptr;
        }
        
        bool operator!=(const const_iterator& other) const
        {
            return _ptr != other._ptr;
        }
        
        const_iterator operator+(difference_type n) const
        {
            return const_iterator(_ptr + n);
        }
        
        const_iterator operator-(difference_type n) const
        {
            return const_iterator(_ptr - n);
        }
        
        difference_type operator-(const const_iterator& other) const
        {
            return _ptr - other._ptr;
        }
    };
    
    // Методы для получения итераторов
    iterator begin()
    {
        return iterator(_data);
    }
    
    iterator end()
    {
        return iterator(_data + _size);
    }
    
    const_iterator begin() const
    {
        return const_iterator(_data);
    }
    
    const_iterator end() const
    {
        return const_iterator(_data + _size);
    }
    
    const_iterator cbegin() const
    {
        return const_iterator(_data);
    }
    
    const_iterator cend() const
    {
        return const_iterator(_data + _size);
    }
    
private:
    void resize()
    {
        _capacity *= 2;
        T* newData = new T[_capacity];
        for (uint8_t i = 0; i < _size; ++i)
        {
            newData[i] = _data[i];
        }
        delete[] _data;
        _data = newData;
    }
};


int main(int argc, const char * argv[]) {
    // Создаем вектор с элементами типа int
    SimpleVector<int> vec;
    
    // Добавляем несколько элементов
    vec.pushBack(10);
    vec.pushBack(20);
    vec.pushBack(30);
    
    // Выводим элементы с помощью индекса
    std::cout << "Элементы вектора (индексация):" << std::endl;
    for (uint8_t i = 0; i < vec.size(); ++i)
    {
        std::cout << vec[i] << " ";
    }
    std::cout << std::endl;
    
    // Используем итератор для вывода элементов
    std::cout << "Элементы вектора (итератор):" << std::endl;
    for (auto it = vec.begin(); it != vec.end(); ++it)
    {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
    
    // Используем range-based for для вывода элементов
    std::cout << "Элементы вектора (range-based for):" << std::endl;
    for (const auto& elem : vec)
    {
        std::cout << elem << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

S>    void resize()
S>    {
S>        _capacity *= 2;
S>        T* newData = new T[_capacity];
S>        for (uint8_t i = 0; i < _size; ++i)
S>        {
S>            newData[i] = _data[i];
S>        }
S>        delete[] _data;
S>        _data = newData;
S>    }
S>

SimpleVector<int> first;
first.pushBack(1);
first.pushBack(2);
SimpleVector<int> second{std::move(first)};
first.pushBack(3);