J'ai une idée afin de pouvoir me simplifier un peu la vie avec
Borland C++ Builder.
Pour ceux qui emploit cet outil, il y a une TList qui fait
office de list d'éléments. Le soucis est qu'elle ne possède
pas une interface qui me permettrait de l'utiliser avec les
algorithmes de la STL.
Donc en gros, comment pourrais-je rajouter les iterator à une
TList ?
Voici ce que cela me permettrait de faire.
TList *list (new TList ());
std::copy (
list->begin (),
list->end (),
std::ostream_iterator< SUPER_TYPE > (std::cout, " "));
J'ai une idée afin de pouvoir me simplifier un peu la vie avec
Borland C++ Builder.
Pour ceux qui emploit cet outil, il y a une TList qui fait
office de list d'éléments. Le soucis est qu'elle ne possède
pas une interface qui me permettrait de l'utiliser avec les
algorithmes de la STL.
Donc en gros, comment pourrais-je rajouter les iterator à une
TList ?
Voici ce que cela me permettrait de faire.
TList *list (new TList ());
std::copy (
list->begin (),
list->end (),
std::ostream_iterator< SUPER_TYPE > (std::cout, " "));
J'ai une idée afin de pouvoir me simplifier un peu la vie avec
Borland C++ Builder.
Pour ceux qui emploit cet outil, il y a une TList qui fait
office de list d'éléments. Le soucis est qu'elle ne possède
pas une interface qui me permettrait de l'utiliser avec les
algorithmes de la STL.
Donc en gros, comment pourrais-je rajouter les iterator à une
TList ?
Voici ce que cela me permettrait de faire.
TList *list (new TList ());
std::copy (
list->begin (),
list->end (),
std::ostream_iterator< SUPER_TYPE > (std::cout, " "));
Pour ceux qui emploit cet outil, il y a une TList qui fait
office de list d'éléments. Le soucis est qu'elle ne possède
pas une interface qui me permettrait de l'utiliser avec les
algorithmes de la STL.
Donc en gros, comment pourrais-je rajouter les iterator à une
TList ?
Le modèle fassade. Je ne connais pas TList, mais j'imagine qu'il
offre un itérateur classique. Je connais deux solutions
possible : une fassade sur la classe même (qui peut être utile
dans certains cas) et une fassade sur son itérateur.
Non, elle ne propose pas d'interface permettant d'utiliser directement un
Pour la fassade sur l'itérateur, boost::iterator doit aider
beaucoup. En fait, ce que je fais sur l'itérateur, ce n'est pas
une vraie fassade, parce que les itérateurs doivent avoir une
sémantique de valeur, ce qui n'est pas le cas d'une vraie
fassade. Mais il revient à peu près au même : mon itérateur STL
contient l'itératuer du TList. (Attention quand même : si
l'itérateur classique n'a pas une sémantique de valeur, il va
falloir que tu lui force une copie profonde.)Voici ce que cela me permettrait de faire.
TList *list (new TList ());
std::copy (
list->begin (),
list->end (),
std::ostream_iterator< SUPER_TYPE > (std::cout, " "));
Ça serait :
std::copy( TListIterator( list ),
TListIterator(),
std::ostream_iterator< ... >( std::cout, " " ) ) ;
Voir Boost::iterator.
Merci, je vais aller regarder tout de suite.
Pour ceux qui emploit cet outil, il y a une TList qui fait
office de list d'éléments. Le soucis est qu'elle ne possède
pas une interface qui me permettrait de l'utiliser avec les
algorithmes de la STL.
Donc en gros, comment pourrais-je rajouter les iterator à une
TList ?
Le modèle fassade. Je ne connais pas TList, mais j'imagine qu'il
offre un itérateur classique. Je connais deux solutions
possible : une fassade sur la classe même (qui peut être utile
dans certains cas) et une fassade sur son itérateur.
Non, elle ne propose pas d'interface permettant d'utiliser directement un
Pour la fassade sur l'itérateur, boost::iterator doit aider
beaucoup. En fait, ce que je fais sur l'itérateur, ce n'est pas
une vraie fassade, parce que les itérateurs doivent avoir une
sémantique de valeur, ce qui n'est pas le cas d'une vraie
fassade. Mais il revient à peu près au même : mon itérateur STL
contient l'itératuer du TList. (Attention quand même : si
l'itérateur classique n'a pas une sémantique de valeur, il va
falloir que tu lui force une copie profonde.)
Voici ce que cela me permettrait de faire.
TList *list (new TList ());
std::copy (
list->begin (),
list->end (),
std::ostream_iterator< SUPER_TYPE > (std::cout, " "));
Ça serait :
std::copy( TListIterator( list ),
TListIterator(),
std::ostream_iterator< ... >( std::cout, " " ) ) ;
Voir Boost::iterator.
Merci, je vais aller regarder tout de suite.
Pour ceux qui emploit cet outil, il y a une TList qui fait
office de list d'éléments. Le soucis est qu'elle ne possède
pas une interface qui me permettrait de l'utiliser avec les
algorithmes de la STL.
Donc en gros, comment pourrais-je rajouter les iterator à une
TList ?
Le modèle fassade. Je ne connais pas TList, mais j'imagine qu'il
offre un itérateur classique. Je connais deux solutions
possible : une fassade sur la classe même (qui peut être utile
dans certains cas) et une fassade sur son itérateur.
Non, elle ne propose pas d'interface permettant d'utiliser directement un
Pour la fassade sur l'itérateur, boost::iterator doit aider
beaucoup. En fait, ce que je fais sur l'itérateur, ce n'est pas
une vraie fassade, parce que les itérateurs doivent avoir une
sémantique de valeur, ce qui n'est pas le cas d'une vraie
fassade. Mais il revient à peu près au même : mon itérateur STL
contient l'itératuer du TList. (Attention quand même : si
l'itérateur classique n'a pas une sémantique de valeur, il va
falloir que tu lui force une copie profonde.)Voici ce que cela me permettrait de faire.
TList *list (new TList ());
std::copy (
list->begin (),
list->end (),
std::ostream_iterator< SUPER_TYPE > (std::cout, " "));
Ça serait :
std::copy( TListIterator( list ),
TListIterator(),
std::ostream_iterator< ... >( std::cout, " " ) ) ;
Voir Boost::iterator.
Merci, je vais aller regarder tout de suite.
celui-ci a constaté que
l'implémentation TList
de Borland était presque 6 fois plus lente que l'implémentation de la STL.
celui-ci a constaté que
l'implémentation TList
de Borland était presque 6 fois plus lente que l'implémentation de la STL.
celui-ci a constaté que
l'implémentation TList
de Borland était presque 6 fois plus lente que l'implémentation de la STL.
Ça serait :
std::copy( TListIterator( list ),
TListIterator(),
std::ostream_iterator< ... >( std::cout, " " ) ) ;
Ça serait :
std::copy( TListIterator( list ),
TListIterator(),
std::ostream_iterator< ... >( std::cout, " " ) ) ;
Ça serait :
std::copy( TListIterator( list ),
TListIterator(),
std::ostream_iterator< ... >( std::cout, " " ) ) ;
On Wed, 18 Jan 2006 09:16:04 +0100, Stephane Wirtel
:celui-ci a constaté que
l'implémentation TList
de Borland était presque 6 fois plus lente que l'implémentation de la STL.
Si elle offre un opérateur [], c'est normal : un [] rapide est
incompatible avec une liste chaînée.
Justement, c'est pour cela que j'aimerais régler le problème.
On Wed, 18 Jan 2006 09:16:04 +0100, Stephane Wirtel
<com.descasoft@wirtel.stephane>:
celui-ci a constaté que
l'implémentation TList
de Borland était presque 6 fois plus lente que l'implémentation de la STL.
Si elle offre un opérateur [], c'est normal : un [] rapide est
incompatible avec une liste chaînée.
Justement, c'est pour cela que j'aimerais régler le problème.
On Wed, 18 Jan 2006 09:16:04 +0100, Stephane Wirtel
:celui-ci a constaté que
l'implémentation TList
de Borland était presque 6 fois plus lente que l'implémentation de la STL.
Si elle offre un opérateur [], c'est normal : un [] rapide est
incompatible avec une liste chaînée.
Justement, c'est pour cela que j'aimerais régler le problème.
Ça serait :
std::copy( TListIterator( list ),
TListIterator(),
std::ostream_iterator< ... >( std::cout, " " ) ) ;
Tu utilises là une syntaxe proche des stream_iterator.
Une autre syntaxe me semble possible, semblable à ce qui peut
être fait pour des tableaux natifs :
std::copy( begin( list ),
end(list),
std::ostream_iterator< ... >( std::cout, " " ) ) ;
Ça serait :
std::copy( TListIterator( list ),
TListIterator(),
std::ostream_iterator< ... >( std::cout, " " ) ) ;
Tu utilises là une syntaxe proche des stream_iterator.
Une autre syntaxe me semble possible, semblable à ce qui peut
être fait pour des tableaux natifs :
std::copy( begin( list ),
end(list),
std::ostream_iterator< ... >( std::cout, " " ) ) ;
Ça serait :
std::copy( TListIterator( list ),
TListIterator(),
std::ostream_iterator< ... >( std::cout, " " ) ) ;
Tu utilises là une syntaxe proche des stream_iterator.
Une autre syntaxe me semble possible, semblable à ce qui peut
être fait pour des tableaux natifs :
std::copy( begin( list ),
end(list),
std::ostream_iterator< ... >( std::cout, " " ) ) ;
wrote:Une autre syntaxe me semble possible, semblable à ce qui peut
être fait pour des tableaux natifs :std::copy( begin( list ),
end(list),
std::ostream_iterator< ... >( std::cout, " " ) ) ;
Le problème, c'est, donné un itérateur classique, comment
implémenter le == dont la STL a besoin.
loic.actarus.joly@numericable.fr wrote:
Une autre syntaxe me semble possible, semblable à ce qui peut
être fait pour des tableaux natifs :
std::copy( begin( list ),
end(list),
std::ostream_iterator< ... >( std::cout, " " ) ) ;
Le problème, c'est, donné un itérateur classique, comment
implémenter le == dont la STL a besoin.
wrote:Une autre syntaxe me semble possible, semblable à ce qui peut
être fait pour des tableaux natifs :std::copy( begin( list ),
end(list),
std::ostream_iterator< ... >( std::cout, " " ) ) ;
Le problème, c'est, donné un itérateur classique, comment
implémenter le == dont la STL a besoin.
wrote:Une autre syntaxe me semble possible, semblable à ce qui
peut être fait pour des tableaux natifs :
std::copy( begin( list ),
end(list),
std::ostream_iterator< ... >( std::cout, " " ) ) ;
Le problème, c'est, donné un itérateur classique, comment
implémenter le == dont la STL a besoin.
Excuse moi, je ne vois pas trop de quoi tu parles. Tu peux
expliciter ?
loic.actarus.joly@numericable.fr wrote:
Une autre syntaxe me semble possible, semblable à ce qui
peut être fait pour des tableaux natifs :
std::copy( begin( list ),
end(list),
std::ostream_iterator< ... >( std::cout, " " ) ) ;
Le problème, c'est, donné un itérateur classique, comment
implémenter le == dont la STL a besoin.
Excuse moi, je ne vois pas trop de quoi tu parles. Tu peux
expliciter ?
wrote:Une autre syntaxe me semble possible, semblable à ce qui
peut être fait pour des tableaux natifs :
std::copy( begin( list ),
end(list),
std::ostream_iterator< ... >( std::cout, " " ) ) ;
Le problème, c'est, donné un itérateur classique, comment
implémenter le == dont la STL a besoin.
Excuse moi, je ne vois pas trop de quoi tu parles. Tu peux
expliciter ?
Il me sembe avoir au moins autant de définition de « itérateurs classiques »
que de religions.
Il me sembe avoir au moins autant de définition de « itérateurs classiques »
que de religions.
Il me sembe avoir au moins autant de définition de « itérateurs classiques »
que de religions.