Template specialization help

[Adrian]

I am trying to write a specialized version of print that will
automagically work out that the container is a pointer of containers and
does a double ref on each iterator.

It feels possible but I cannot think of a way to do it. My initial
thoughts where to use the STL contains ::value_type and ::const_pointer
typedefs

Happy to modify template params to pass enough information

Anyone done this, or got any ideas on how

Thanks

TIA

Adrian


#include <iostream>
#include <vector>

template<class T>
void print(T first, T last)
{
for(T i=first; i!=last; ++i)
std::cout << (*i) << std::endl;
}

#if 0
template<>
void print(T first, T last)
{
for(T i=first; i!=last; ++i)
std::cout << (**i) << std::endl;
}
#endif
int main(int argc, char *argv[])
{
std::vector<int> intlist;
std::vector<int*> intptrlist;

for(int i=0; i<10; ++i)
{
intlist.push_back(i);
intptrlist.push_back(new int(i));
}

print(intlist.begin(), intlist.end());
print(intptrlist.begin(), intptrlist.end());

return 0;
}

 

[Adrian]

container is a pointer of containers

Sorry. Should be
container is a container of pointers

 

[Ian Collins]

I am trying to write a specialized version of print that will
automagically work out that the container is a pointer of containers and
does a double ref on each iterator.

It feels possible but I cannot think of a way to do it. My initial
thoughts where to use the STL contains ::value_type and ::const_pointer
typedefs

Happy to modify template params to pass enough information

Anyone done this, or got any ideas on how

Um, I'm sure there's a cleaner way, but these work for ordered and
unordered containers:

template <typename T,
template <typename E,
typename A = std::allocator<E> > class Container>
void print( const Container<T>& c )
{
for( typename Container<T>::const_iterator i = c.begin(); i !=
c.end(); ++i )
std::cout << *i << std::endl;
}

template <typename T,
template <typename E,
typename L = std::less<E>,
typename A = std::allocator<E> > class Container>
void print( const Container<T>& c )
{
for( typename Container<T>::const_iterator i = c.begin(); i !=
c.end(); ++i )
std::cout << *i << std::endl;
}

template <typename T,
template <typename E,
typename A = std::allocator<E> > class Container>
void print( const Container<T*>& c )
{
for( typename Container<T*>::const_iterator i = c.begin(); i !=
c.end(); ++i )
std::cout << **i << std::endl;
}

template <typename T,
template <typename E,
typename L = std::less<E>,
typename A = std::allocator<E> > class Container>
void print( const Container<T*>& c )
{
for( typename Container<T*>::const_iterator i = c.begin(); i !=
c.end(); ++i )
std::cout << **i << std::endl;
}

The horrible template template syntax will be much cleaner in C++0x.

int main(int argc, char *argv[])
{
std::vector<int> intlist;
std::vector<int*> intptrlist;

for(int i=0; i<10; ++i)
{
intlist.push_back(i);
intptrlist.push_back(new int(i));
}

print(intlist.begin(), intlist.end());
print(intptrlist.begin(), intptrlist.end());

return 0;
}