Template overloading?

This is strange... VC++ gives me this error:

error C2780: 'void StrUtils::ToUpper(std::basic_string<_Elem,_Traits, _Alloc> &,const std::locale &)' : expects 2 arguments - 4 provided

if I try to overload my ToUpper() function template like this:

Code:

template <typename E>
class ToUpperFunctor	:	public std::binary_function<E, std::locale, E>
{
public:
	E operator()( E  ch, const std::locale&  loc = std::locale() ) const
	{
		return std::toupper( ch, loc );
	}
};

template <typename E,
	  typename InIt,
	  typename OutIt>
void ToUpper( InIt  start1,
	      InIt  end1,
	     OutIt  start2,
	     const std::locale&  loc = std::locale() )
{
	std::transform( start1, end1,
			start2,
			std::bind2nd( ToUpperFunctor<E>(), loc ) );
}

template <typename E,
	  typename T,
	  typename A>
void ToUpper( std::basic_string<E, T, A>&  str,
		       const std::locale&  loc = std::locale() )
{
	typedef std::basic_string<E, T, A>::iterator	iter;
	ToUpper( str.begin(), str.end(),
		 str.begin(), loc );
}

but it compiles fine if I specify the template parameters:

Code:

template <typename E>
class ToUpperFunctor	:	public std::binary_function<E, std::locale, E>
{
public:
	E operator()( E  ch, const std::locale&  loc = std::locale() ) const
	{
		return std::toupper( ch, loc );
	}
};

template <typename E,
	  typename InIt,
	  typename OutIt>
void ToUpper( InIt  start1,
	      InIt  end1,
	     OutIt  start2,
	     const std::locale&  loc = std::locale() )
{
	std::transform( start1, end1,
			start2,
			std::bind2nd( ToUpperFunctor<E>(), loc ) );
}

template <typename E,
	  typename T,
	  typename A>
void ToUpper( std::basic_string<E, T, A>&  str,
		       const std::locale&  loc = std::locale() )
{
	typedef std::basic_string<E, T, A>::iterator	iter;
	ToUpper<E, iter, iter>( str.begin(), str.end(),
				str.begin(), loc );
}

But both template functions take the same number of template parameters, so how could that possibly help, and why doesn't it know which function I'm talking about to begin with?

I think I know why I need to explicitely specify the template parameters -- because the E parameter isn't used in the function parameter list. But I'm still at a loss as to why VC++ thinks I'm talking about the 2 parameter function instead of the 4 parameter one?

If nobody has a good answer for that, then maybe this is easier -- Is there a way limit the types that can be used for template parameters? If I only want OutIt to be instantiated using an output iterator, is it possible to do that?

It seems to me that you are over-complicating things.

Here's something that should work the same with a lot less template parameters. I hope the way E is deduced (with iterator::value_type) is standard.

Code:

#include <string>
#include <algorithm>
#include <iostream>
#include <cctype>

template <typename E>
class ToUpperFunctor	:	public std::binary_function<E, std::locale, E>
{
public:
	E operator()( E  ch, const std::locale&  loc = std::locale() ) const
	{
		return std::toupper( ch, loc );
	}
};

template <typename InIt, typename OutIt>
void ToUpper( InIt  start1,
	      InIt  end1,
	     OutIt  start2,
	     const std::locale&  loc = std::locale() )
{
     typedef typename InIt::value_type E;
	std::transform( start1, end1,
			start2,
			std::bind2nd( ToUpperFunctor<E>(), loc ) );
}

template <typename StringType>
void ToUpper( StringType&  str,
		       const std::locale&  loc = std::locale() )
{
	ToUpper( str.begin(), str.end(), str.begin(), loc );
}

int main()
{
    std::string a = "Hello", b = "world";
    ToUpper(a);
    ToUpper(b.begin(), b.end(), b.begin());
    std::cout << a << " " << b << '\n'; //HELLO WORLD
}

typedef std::basic_string<E, T, A>::iterator iter;

This is missing a typename and shouldn't compile in the first place. What version of VC++ is this?

6.0?

Originally Posted by CornedBee

This is missing a typename and shouldn't compile in the first place. What version of VC++ is this?

That was VC++ 2005 express.
I thought it needed a typename too, but when it compiled I thought maybe since only part of the name before the :: was a template that maybe it wasn't required...
Thanks.