Свой итератор

#include <iostream>
#include <list>
#include <vector>
#include <iterator> 
#include <algorithm>
using namespace std;
 
template<typename T>
class my_vector
{
public:
 
    my_vector(size_t size = 0):mas(nullptr), size(size)// конструктор
    {
        if (size > 0)
        {
            mas = new T[size];
        }
    }
    my_vector(initializer_list<T> lst):size(lst.size()) // инициал. с помощью init.._list
    {
        mas = new T[size];
        copy(lst.begin(), lst.end(), mas);
    }
    T& operator[](int n)// перегрузка [] для класса 
    {
        return mas[n];
    }
 
 
    ~my_vector()// деструктор
    {
        if (mas != nullptr)
        {
            delete[] mas;
        }
    }
    /////// !!! iterators here !!! ////////////
    template<bool isConst>
    struct my_common_iterator
    {
    private:
        conditional_t<isConst, const T*, T*> my_pointer;// метафункция. если isConst = true, то возвращает const T* иначе T*
    public:
        my_common_iterator(conditional_t<isConst, const T*, T*> ptr) :my_pointer(ptr) {}
        conditional_t<isConst, const T, T>& operator*()// перегрузки различных операторов для итераторов
        {
            return *my_pointer;
        }
        my_common_iterator& operator--()
        {
            my_pointer--;
            return *this;
        }
        my_common_iterator& operator--(int)
        {
            my_pointer--;
            return *this;
        }
        my_common_iterator& operator++(int)
        {
            my_pointer++;
            return *this;
        }
        my_common_iterator& operator++()
        {
            my_pointer++;
            return *this;
        }
    };
 
    using my_iterator = my_common_iterator<false>;
    using my_citerator = my_common_iterator<true>;
    my_iterator begin() const
    {
        return my_iterator(mas);
    }
    my_iterator end() const
    {
        return my_iterator(mas+size);
    }
    my_citerator begin() const
    {
        return my_citerator(mas);
    }
    my_citerator end() const
    {
        return my_citerator(mas + size);
    }
private:
    T* mas;
    size_t size;
};
int main()
{
    int* m = new int[5];
    my_vector<int> my_v = { 2,3,4,5,6 };
    my_vector<int>::my_iterator mitbn = my_v.begin();
    my_vector<int>::my_iterator miten = my_v.end();
    my_vector<int>::my_citerator mitb = my_v.begin();
    my_vector<int>::my_citerator mite = my_v.end();
    //*mitb = 1234;
    //*mite = 1234;
    cout << *mitb << " " << *(mite--) << endl;
    copy(itb, ite, m);
    for (int i = 0; i < 5; i++)
    {
        cout << m[i]<< endl;
    }
 
    return 0;
}

        my_common_iterator operator--(int)
        {
            my_common_iterator tmp(*this);
            --(*this);
            return tmp;
        }
        my_common_iterator operator++(int)
        {
            my_common_iterator tmp(*this);
            ++(*this);
            return tmp;
        }

cout << *mitb << " " << *(--mite) << endl;

int foo();
double foo(); // Ошибка! 
// То, что `int` и `double` - разные типы, ситуацию никак не спасает