gratifiant > comp.lang.* > comp.lang.cpp

mderie (15/12/2009, 15h46)
#include <...>

typedef int* iter; // Que declarer ici ?

void bubbleSort(iter begin, iter end) { //... }

int main()
{
std::vector<int> vi;
std::list<int> li;

vi.push_back(3);
vi.push_back(1);
li.resize(vi.size());
std::copy(vi.begin(), vi.end(), li.begin()); // Copy accepte tout les
iterateurs possibles de tout les types...
bubbleSort(vi.begin(), vi.end()); // Mais quid pour une fonction
perso ?

return 0;
}
Michael Doubez (15/12/2009, 16h26)
On 15 déc, 14:46, mderie <mde> wrote:

> typedef int* iter;  // Que declarer ici ?
> void bubbleSort(iter begin, iter end) { //... } [snip]


bubbleSort() doit être une fonction template:

template<class BidirectionnalIterator>
void bubbleSort(BidirectionnalIterator begin, BidirectionnalIterator
ned)
{
// ...
}

>         std::copy(vi.begin(), vi.end(), li.begin()); // Copy accepte tout les
> iterateurs possibles de tout les types...


En entrée, oui mais en sortie (le 3ème paramètre) doit être au minimum
un OutputIterator.

>         bubbleSort(vi.begin(), vi.end()); // Mais quid pour une fonction
> perso ? [snip]


Le template correspondant au type des paramètres d'entrée est
instancié.
James Kanze (15/12/2009, 18h48)
On Dec 15, 2:26 pm, Michael Doubez <michaeldou> wrote:
> On 15 déc, 14:46, mderie <mde> wrote:


> > typedef int* iter; // Que declarer ici ?


> > void bubbleSort(iter begin, iter end) { //... }


> [snip]


> bubbleSort() doit être une fonction template:


> template<class BidirectionnalIterator>
> void bubbleSort(BidirectionnalIterator begin, BidirectionnalIterator
> ned)
> {


Elle pourra avoir besoin d'autres types en plus :

typename std::iterator_traits< BidirectionnalIterator
>::value_type tmp;


, etc. Une bonne partie de la génie de la STL, c'est de normaliser
tous
ces typedef, dans les collections, pour les itérateurs, etc., afin de
rendre ces informations disponibles dans les algorithmes.

> // ...


> }


> > std::copy(vi.begin(), vi.end(), li.begin()); // Copy accepte tout les
> > iterateurs possibles de tout les types...


> En entrée, oui mais en sortie (le 3ème paramètre) doit être au minimum
> un OutputIterator.


Et en entrée, un OutputIterator ne fonctionnera pas très bien.

> > bubbleSort(vi.begin(), vi.end()); // Mais quid pour une fonction
> > perso ?


> [snip]


> Le template correspondant au type des paramètres d'entrée est
> instancié.


Et à partir des types des paramètres en entrée, il faut pouvoir
trouver
tous les autres types dont on a besoin.
Alp Mestan (17/12/2009, 02h22)
On Dec 15, 5:48 pm, James Kanze <jameska> wrote:
> Et à partir des types des paramètres en entrée, il faut pouvoir
> trouver
> tous les autres types dont on a besoin.


Pour le PO, le mot-clé pour tes recherches pour ce genre de choses
c'est "classes de traits" ('trait classes' en anglais).
Ca permet d'associer des types, constantes et fonctions statiques à
(généralement) un type, passé en paramètre à ce 'trait' justement.. Ca
marche aussi pour plusieurs types ainsi que des constantes, mais le
plus souvent cela ne travaille que sur un type.

Exemples dans la STL : iterator_traits, char_traits, numeric_limits.
James Kanze (17/12/2009, 10h32)
On Dec 17, 12:22 am, Alp Mestan <alpmes> wrote:
> On Dec 15, 5:48 pm, James Kanze <jameska> wrote:


> > Et à partir des types des paramètres en entrée, il faut pouvoir
> > trouver tous les autres types dont on a besoin.


> Pour le PO, le mot-clé pour tes recherches pour ce genre de choses
> c'est "classes de traits" ('trait classes' en anglais). Ca permet
> d'associer des types, constantes et fonctions statiques à
> (généralement) un type, passé en paramètre à ce 'trait' justement. Ca
> marche aussi pour plusieurs types ainsi que des constantes, mais le
> plus souvent cela ne travaille que sur un type.


> Exemples dans la STL : iterator_traits, char_traits, numeric_limits.


Oui et non. Dans les contextes où le type n'est pas obligatoirement un
type de classe, les traits permettent à obtenir les typedef
nécessaires,
mais dans les contextes où on a obligatoirement une classe (une
collection, un objet fonctionnel), on peut (et la norme le fait) aussi
bien exiger que ces types soient définis comme membre. De l'autre
côté,
les traits peuvent servir à bien d'autres choses que simplement des
typedef ; la frontière entre traits et stratégie est en fait assez
floue. Le template std::numeric_limits, par exemple, est une classe
de
traits.
Mickaël Wolff (17/12/2009, 17h18)
James Kanze a écrit :

> les traits peuvent servir à bien d'autres choses que simplement des
> typedef ; la frontière entre traits et stratégie est en fait assez
> floue. Le template std::numeric_limits, par exemple, est une classe
> de
> traits.


Tant qu'on parle des classes de trait, comment faut-il comprendre le
mot « trait » ? Le meme sens que dans « chevaux de trait » ou dans «
trait de caractère » ?
Jean-Marc Bourguet (17/12/2009, 17h19)
Mickaël Wolff <mickael.wolff> writes:

> James Kanze a écrit :
> Tant qu'on parle des classes de trait, comment faut-il comprendre le mot
> « trait » ? Le meme sens que dans « chevaux de trait » ou dans « trait de
> caractère » ?


trait de caractere.

A+
James Kanze (17/12/2009, 20h02)
On Dec 17, 3:18 pm, Mickaël Wolff <mickaelwo> wrote:
> James Kanze a écrit :


> > les traits peuvent servir à bien d'autres choses que simplement des
> > typedef ; la frontière entre traits et stratégie est en fait assez
> > floue. Le template std::numeric_limits, par exemple, est une classe
> > de traits.


> Tant qu'on parle des classes de trait, comment faut-il comprendre le
> mot « trait » ? Le meme sens que dans « chevaux de trait » ou dans «
> trait de caractère » ?


Trait de caractère. C'est bien la signification du mot en anglais.
Mickaël Wolff (17/12/2009, 21h18)
James Kanze a écrit :
>> Tant qu'on parle des classes de trait, comment faut-il comprendre le
>> mot « trait » ? Le meme sens que dans « chevaux de trait » ou dans «
>> trait de caractère » ?

> Trait de caractère. C'est bien la signification du mot en anglais.


Merci à tout les deux. C'était bien ce que j'avais compris
initialement, mais à force d'utiliser les traits, leur capacité à
transporter toutes ces informations (sémantiques ?) me faisait penser à
des mules, et donc aux animaux de trait.
Discussions similaires