Итератор и указатель в чем разница

std::vector<int> v = { 1,2,3,4 };
std::vector<int>::iterator iter = v.begin();  // получаем итератор

std::vector<int> v = { 1,2,3,4 };
int* my_ptr = v.begin();  // получаем итератор

#include <iostream>
#include <vector>
#include <list>
using namespace std;
 
int main()
{
vector<int> v{1,2,3};
auto it_beg=v.begin();
 
int *ptrToFirstElem=&*it_beg;
cout<<*(++ptrToFirstElem)<<endl;//2
 
return 0;
}

#include <iostream>
#include <vector>
#include <list>
using namespace std;
template <typename T>
class IEnumerableInterface
{
    public:
    virtual bool MoveNext();
    virtual void Reset();
    virtual T &Current();
    virtual const T &Current()const;
    virtual ~IEnumerableInterface(){}
 
};
 
template <typename T>
class VectorIEnumerableInterface
    : public   vector<T>
    , public IEnumerableInterface<T>
    {
        public:
        VectorIEnumerableInterface(const vector<T> &v)
        :vector<T>(v)
        ,IEnumerableInterface<T>{}
        ,CurrentIterator(this->begin())
        {
        }
 
        ~VectorIEnumerableInterface()
        {
        }
 
        void Reset()
            {
                CurrentIterator=this->begin();
            }
 
        bool MoveNext()
        {
            if(++CurrentIterator == this->end())
            return false ;
            return true ;
        }
 
        T &Current()
        {
            return *CurrentIterator ;
        }
 
        const T &Current()const
        {
            return *CurrentIterator ;
        }
 
       typename vector<T>::iterator CurrentIterator ;
    };
 
template <typename T>
class ListIEnumerableInterface
    : public   list<T>
    , public IEnumerableInterface<T>
    {
        public:
        ListIEnumerableInterface(const list<T> &v)
        :list<T>(v)
        ,IEnumerableInterface<T>{}
        ,CurrentIterator(this->begin())
        {
        }
 
        ~ListIEnumerableInterface()
        {
        }
 
        void Reset()
            {
                CurrentIterator=this->begin();
            }
 
        bool MoveNext()
        {
            if(++CurrentIterator == this->end())
            return false ;
            return true ;
        }
 
        T &Current()
        {
            return *CurrentIterator ;
        }
 
        const T &Current()const
        {
            return *CurrentIterator ;
        }
 
       typename list<T>::iterator CurrentIterator ;
    };
 
int main()
{
    int a[]{1,2,3};
    vector<int> va(a, a+3);
    VectorIEnumerableInterface<int> vectorIEnumerableInterface (va);
    vectorIEnumerableInterface.push_back(123);
    cout<<endl ;
 
    vectorIEnumerableInterface.Reset();
    do
    {
        cout<<vectorIEnumerableInterface.Current()++<<' ';
    }while(vectorIEnumerableInterface.MoveNext());
    cout<<endl ;
 
    list<int> la(a, a+3);
 
    ListIEnumerableInterface<int> listIEnumerableInterface (la);
 
    IEnumerableInterface<int> *iEnumerableInterface[] {
    &vectorIEnumerableInterface, &listIEnumerableInterface
    };
 
for(auto &ptrIE : iEnumerableInterface)
{
    ptrIE->Reset();
    do
        {
            cout<<ptrIE->Current()<<' ';
        }while(ptrIE->MoveNext());
}
return 0;
}