Re: Iterators and ints get confused in template parameter
On Jul 20, 7:08 pm, Juha Nieminen <nos...@thanks.invalid> wrote:
Juha Nieminen wrote:
I have looked at the std::list source code in the gcc C++
libraries, and I don't see any fancy trick being used to
differentiate between the two assign() functions.
Actually I was wrong. The assign() functions themselves don't
use any trick, but the internal functions they call seem to
use some kind of obscure template magic to differentiate
between the two cases.
The code in question is filled with names starting with _ and
__, for example:
typedef typename std::__is_integer<_InputIterator>::__type _Integral;
This seems to be telling me that this is not standard library code,
Why? It's part of the implementation, so it's bound to use
funny names. But it's part of the implementation of the
standard library.
but code specific to gcc (or whatever STL library it's using).
Thus it wouldn't probably be very portable to try to copy this
implementation verbatim.
Maybe, maybe not. It's possible that the g++ library uses some
special g++ extensions here, but somehow I doubt it. And it
certainly can be done in standard C++. (The standard requires
it be done somehow, of course.)
Any suggestions how I could solve this problem with standard
STL code only, and preferably without having to reimplement
enormous libraries? (Also I wouldn't want to make
specializations for assign() for each possible integral type.)
You only have to specialize some discriminator template for each
possible integral type. That descrimator type has a typedef,
you call a function using an argument based on that typedef, and
operator overloading does the rest. Something along the lines
(untested):
class True {} ;
class False {} ;
template< typename T >
struct IntegerDiscriminator
{
typedef False Type ;
} ;
template<>
struct IntegerDiscriminator< int >
{
typdef True Type ;
}
// ...
And then:
template< typename T >
class MyClass
{
public:
void assign( size_t count, T const& value ) ;
template< typename ForwardIterator >
void assign( ForwardIterator begin,
ForwardIterator end )
{
doAssign( begin, end, IntegerDiscriminator< T
::type() ) ;
}
private:
void doAssign( size_t count, T value, True )
{
assign( count, value ) ;
}
template< typename ForwardIterator >
void doAssign( ForwardIterator begin,
ForwardIterator end,
False )
{
while ( begin != end ) ...
}
} ;
Or something like that. For all the details, see the
Vandevoorde and Josuttis.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34