iterators in c++ template class

Question

I have a little problem and I'm working on it for several hours but can't find a solution. Hope you will help me.

Here is my class:

#include <iostream>
#include <iterator>

template <typename T> class Array{
private:
    size_t size;
    T *newArray;

public:
    class Iterator:public std::iterator<std::output_iterator_tag, T>{
        T *p;
        public:
            Iterator(T*x):p(x){}
            T& operator*() {return *p;}

    };

    Array (size_t size = 10): size(size), newArray(new T[size]){};
    Iterator begin(){return (Iterator(newArray));}

    T printBegin(typename Array<T>::Iterator it){ return *it;}

    template <typename E>
    T printBegin(typename Array<E>::Iterator it){ return (T)*it;}

};

And here is Main:

using namespace std;

int main(){

    Array<int> x;
    Array<int> y;
    cout << y.printBegin(x.begin()); // prints 0 OK

    Array<double> p;
    // cout << p.printBegin(x.begin());

    return 0;
}

The first cout works fine but the line that is commented gives this : error: no matching function for call to 'Array<double>::printBegin(Array<int>::Iterator)'

I don't understand because the last line in my Array class matches (normally) for this function call

Answer 1

The problem is that you want to deduce the E in Array<E>::Iterator from x.begin() that is an Array<int>::Iterator . But that is simply not possible.

Your best option is probably to write:

template <typename IT>
T printBegin(IT it){ return (T)*it;}

If, for any reason, you need to use the E type, then it is better to add a nested typedef:

class Iterator:public std::iterator<std::output_iterator_tag, T>{
    public:
        typename T array_member_type;
        //...
};

And then:

template <typename IT>
T printBegin(IT it){
    typedef typename IT::array_member_type E;
    return (T)*it;
}

Wait! Your iterator derives from std::iterator so the typedef already exists. No need to redefine:

template <typename IT>
T printBegin(IT it){
    typedef typename IT::value_type E;
    return (T)*it;
}

Answer 2

Your question is very similar to another question about template deduction.

The compiler cannot deduct the type E from Array<E>::Iterator . Why should it be able to? Two different types E could share the same iterator type.

What you are really saying to the compiler is:

"Is there a type "E" for which Array<E>::Iterator is this type?"