Re: problem storing different iterators in a container
Lutz Altmann wrote:
Thanks,
i like this solution very much ..
the push_back in your example main() method can be further
simplified :
from:
iter.push_back( AbstractOutputIterator<int>
( std::back_inserter( il ) ) );
to:
iter.push_back(std::back_inserter(...)));
because of implicit-conversion. thats wonderful :)
exactly what i wanted..
what does it mean, that virtual methods cannot be templated.
Do you mean function-templates ? or are virtual functions (in
princible) of the not supported
by this pattern ?
I mean that you cannot do:
class X {
...
template < typname Arg >
virtual
void member_fct ( Arg arg ) { ... }
};
That really sucks.
I dont really understand, what you mean with : all types for T have to
be known in advance ..
for me, that seems not to be the case ?
i would be very thankfuk, if you could clarify this.
Suppose for a second, you could have templated virtual member functions.
Then, you could do:
class AbstractOutputIterator {
struct base {
virtual
~base ( void ) {}
virtual
base * clone ( void ) = 0;
template < typename ValueType >
virtual
base & operator= ( ValueType const & rhs ) = 0;
virtual
void inc ( void ) = 0;
};
template < typename Iterator >
struct derived : public base {
Iterator the_iter;
derived ( Iterator iter )
: the_iter ( iter )
{}
~derived ( void ) {}
derived * clone ( void ) {
return ( new derived ( the_iter ) );
}
template < typename ValueType >
derived & operator= ( ValueType const & rhs ) {
the_iter = rhs;
return ( *this );
}
void inc ( void ) {
++ the_iter;
}
};
...
};
Now, AbstractOutputIterator would be much closer to actual output iterators
in that it isn't tied to a particular ValueType in the assignment
* abstract_iter ++ = some_expression;
Since the language does not support this, you would have to need all
permitted types for some_expression in advance. In the code I posted, I
turned that into the template parameter for AbstractOutputIterator.
Oh, and please don't top-post.
On 16 Mrz., 21:28, Kai-Uwe Bux <jkherci...@gmx.net> wrote:
Lutz Altmann wrote:
On 16 Mrz., 19:56, Kai-Uwe Bux <jkherci...@gmx.net> wrote:
[something about a duck-type for output iterators]
hey thanks alot - i think i'll try to use this "duck-typing"
approach ..
Note that there are some limitations. For instance, virtual methods
cannot be templated. Therefore, you cannot make a true duck-type for
output iterators: you need to know in advance all types T for which
* iter ++ = t
will be meaningful.
the language. I have yet to find a way around that (and I doubt that such
a way exists).
[snip]
Best
Kai-Uwe Bux