Re: template specialization problem
On Jul 9, 5:32 pm, Victor Bazarov <v.Abaza...@comAcast.net> wrote:
abir wrote:
On Jul 8, 5:14 pm, Victor Bazarov <v.Abaza...@comAcast.net> wrote:
abir wrote:
i have a template as shown
template<typename S> class Indexer{};
i want to have a specialization for std::vector both const & non const
version.
template<typename T,typename A> class Indexer<std::vector<T,A> > {}
matches only with nonconst version. anyway to match it for both? and
get if it is const or nonconst?
Const and non-const variation of what? Of a vector? How would you use
it? Give an example that would cause an instantiation of your template.
[..]
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask
What i want is to have multiple pattern matching for same
specialization.
I have
template<typename S> class Indexer{};
i have specialization
template<typename T,typename A> class Indexer< std::vector<T,A> > {};
and
template<typename T,typename A> class Indexer < const std::vector<T,A>
{};
Empty classes? I am guessing not, but my crystal ball is malfunctioning
at this time, I can't see into your mind to understand what their
differences or commonalities are.
as both the specialization are nearly same,
Actually as you wrote here, they *are* the same.
> i don't want code
duplication, so i want a single specialization to match both, so that
the client can write,
[..]
(a) "Nearly the same" is not the same as "the same", is it? If there is
a lot in common between two types, extract the common part into the
third class and make it the base class for both.
(b) You didn't answer the question how your class is to be *used*.
Instantiation of a type is not its *use*, you need to show what
*behaviour* your type has to show what exactly you're after.
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask
I am not getting instant updates about my posts,due to some reason.
So the delay in replying, sorry for that.
The blank classes are ok, as i may have any implementation for them. I
only want to match them in template in some way. However as it is not
makes sense, so i am trying to elaborate on that.
I can only say what i want to write. As i don't know how to write the
one which i need, so it is little difficult to explain. I am trying my
best with code & example
I have a class template which looks like this (a lot of members are
not shown, however its behavior is more like an random access
iterator, but with some differences).
template<typename S>
class VectorIndexer{
public:
typedef VectorIndexer<S> self_type;
typedef VectorIndexer<typename
std::tr1::remove_const<S>::type> nonconst_self;
friend class VectorIndexer<const S>;
public:
VectorIndexer(S& seq,typename S::size_type idx = 0) :
seq_(&seq),index_(idx){}
VectorIndexer(nonconst_self& other) :
seq_(other.seq_),index_(other.index_){}
private:
S* seq_;
typename S::size_type index_;
};
Now in client code i can have, (commented lines are not allowed,
hadn't shown assignment ops also)
typedef std::vector<int> VI;
VI v;
v+=1,2,3,4,5,6,7,8,9;
const VI& cv = v;
VectorIndexer<VI> i(v);
VectorIndexer<const VI> i1(v);
//VectorIndexer<VI> i2(cv);
VectorIndexer<const VI> i3(cv);
//VectorIndexer<VI> i4 = i1;
VectorIndexer<const VI> i5 = i;
So far it is ok for me as i allowed const and non const matching and
allowed one way conversion.
However i hadn't disallowed other classes & containers so far.
Thus this works
typedef std::deque<int> QI;
QI q; q+=1,2,3,4,5;
VectorIndexer<QI> qi(q);
However, i want a different implementation for deque based on class
name (not based on any trait). And if it is not specialized for that
class then
VectorIndexer<QI> qi(q); should fail.
So the way i have it currently is a separate name DequeIndexer along
with separate implementation.
and access is
DequeIndexer<QI> qi(q);
I don't want that.
I want (1)
Indexer<QI> qi(q); Indexer<const QI> cqi(q);
Indexer<VI> vi(v); Indexer<const VI> cvi(v); and so on where
implementation for const & non const are in same specialization as
shown above in VectorIndexer. I don't have any problem adding /
removing any additional template args, as long as i can call them in
this way.
Also i don't want any aux typedef like iterators which are tied up
with container (or from outside) like
indexer_types<QI>::indexer qi(q);
indexer_types<QI>::const_indexer cqi(q);//or indexer_types<const
QI>::indexer cqi(q);
so what i want is to match all for those i specialized Indexer, eg
{QI ,const QI},{VI,const VI} and not for any other. And these pairs
should have same specialization as given in VectorIndexer.
I hope i made my aim & intension clearer. If any addition things are
necessary i will be able to provide.
and thanks for answering ...
Thanks
abir