Different classes that might be passed to constructor - c++

Question

The constructor of my class can have two different classes passed to it. But there's no way I can know ahead of time what type it will be so I can declare its type as a data member to initialize it. How can I know which kind of object was passed to my constructor. Preferably I would like this to be done without Boost.
I am passing in an iterator. It can either be a const iterator (v.cbegin()) or non-const (v.begin()):
struct iterator
{
iterator(IteratorType it)
: m_it(it)
{ }
IteratorType m_it;
};
Here's how I'm calling the constructor:
iterator X::begin() { return iterator(x.begin()); }
iterator X::begin() const { return iterator(x.cbegin()); }

Answer 1

You do not actually want to know what argument-types were passed to your ctor, because by then the class is already under construction, its type cast in stone.
What you want is to decide on which class to use based on the arguments, which needs earlier intervention.
Still, the solution is simple:
Use a factory-function and a template-class (There are many examples of this pattern in <iterator> and other parts of the standard library)
template<class It>
struct myiterator
{
myiterator(It it) : m_it(it) { }
private:
typename std::iterator_traits<It>::type m_it;
// The above will choke if It is not an iterator
};
template<class... X> auto make_myiterator(X&&.. x)
-> myiterator<typename std::decay<X>::type>
// Only the first arguments type is passed on.
{
using just_making_sure_it_is_an_iterator =
std::iterator_traits<typename std::decay<X>::type>::type;
return {std::forward<X>(x)...};
}

Answer 2

I solved this by using templates as suggested in the comments:
template<typename It>
struct iterator
{
iterator(It it) : m_it(it) { }
private:
It m_it;
};

Answer 3

If your target is to determine which type you are holding in your class, by just holding a more "general" type, then you could do this:
Implement a common interface class of those two classes and use this type as your constructor argument & property. Inside your interface, set up a method contract, that returns your type (i.e. a string or enum value, etc). Then, implement this method to both classes, in different implementation.
public class Iterateable
{
public:
//Ctors/Dtors etc....
//Pure virtual method.
virtual string getType() = 0;
}
public class IteratorType1 : public Iterateable
{
public:
//Ctors/Dtors etc....
string getType {return "IteratorType1";}
}
public class IteratorType2 : public Iterateable
{
public:
//Ctors/Dtors etc....
string getType {return "IteratorType2";}
}
struct iterator
{
iterator(Iterateable it)
: m_it(it)
{ }
Iterateable m_it;
};
You can then hold objects of any type that implement the Iterateable interface.
Then, by calling getType() via the property you can determine the type, as the method implemented on the mostly derived class of the instance holded on the property will be invoked (this is a language feature called late binding).