[32] Librairie de class (STL),Librairie de class (STL)

[Récemment ajouté (on 10/99).]

La STL ("Standard Templates Library") est une librairie qui est constituée principalement par des classes containers (très efficace), ainsi que des fonctionnalités pour parcourir (iterator) leur contenu et des algorithmes pour travailler sur leur contenu.

Techniquement parlant le terme "STL" n'est plus significatif car ces classes on été pleinement intégrés à la librairie standard (std) ainsi que d'autres classes telles que iostream, aussi, en parlant de ces classes, on utilise souvent le terme std. Toutefois beaucoup de gens se réfèrent à la STL comme si elle était une chose séparée, donc vous entendrez le terme STL à la place de std.

Etant donné que les classes de la STL sont une partie de la librairie standard, votre compilateur devrait fournir ces classes. Si votre compilateur ne les inclut pas, soit vous devrez mettre a jour votre compilateur, soit vous devrez télécharger une copie de la STL depuis un des sites suivants :

• The SGI implementation: _LINK([[http://www.sgi.com/tech/stl/]],[[www.sgi.com/tech/stl/]])
• STLport: _LINK([[http://www.stlport.org/]],[[www.stlport.org]])

Des fonctions de la STL telle que std::find_if()vous aident à trouver un élément de type Tdans un container de T's. Mais si vous avez un container de pointeurs tel que vector<Fred*>, ces fonctions permettront de trouver un élément qui correspond a un pointeur Fred*donné, mais elles ne trouvent pas un objet Freddonné. N.D.T : la recherche se fait sur la valeur du pointeur et non sur l'objet pointé.

La solution est de fournir un paramètre optionnel qui spécifie la fonction de "comparaison". La class template suivante permet de comparer des objets connaissant un pointeur vers ces objets.

template<class T>
class DereferencedEqual {
public:
DereferencedEqual(const T* p) : p_(p) { }
bool operator() (const T* p2) const { return *p_ == *p2; }
private:
const T* p_;
};

Maintenant vous pouvez utiliser ce template pour trouver une objet Fred:

void userCode(vector<Fred*> v, const Fred& match)
{
find_if(v.begin(), v.end(), DereferencedEqual<Fred>(&match));
// ...
}

La FAQ de la STL (anglais): ftp://butler.hpl.hp.com/stl/stl.faq

Le guide de Kenny Zalewski's sur la STL (anglais): www.cs.rpi.edu/projects/STL/htdocs/stl.html

Le guide de Musser's sur la STL (anglais): www.cs.rpi.edu/~musser/stl.html

Le guide de Mumit's sur la STL pour débutant (anglais): www.xraylith.wisc.edu/~khan/software/stl/STL.newbie.html

• Signe #1: quand toute chose est dérivée d'une classe de base unique, habituellement Object.
• Signe #2: quand les classes containers (List, Stack, Set, etc) ne sont pas des templates.
• Signe #3: quand les classes containers (List, Stack, Set, etc) insèrent/extraient des éléments en tant que pointeurs d'Object. Ceci permet d'insérer une Pomme dans un tel container, mais quand vous "récupérez", le compilateur sait seulement qu'il est dérivé de Object, aussi vous devez utiliser un transtypage de pointeur pour obtenir un Apple*; (et vous avez intérêt a prier que le pointeur soit réellement un Apple*, sinon ca vous retombera dessus).

Vous pouvez faire un transtypage "sûr" en utilisant dynamic_cast, mais ce test dynamique est seulement ce qu'il est : dynamique. Ce style de codage est l'essence même du typage dynamique en C++. Vous appelez une fonction qui dit "convertissez-moi cet Objeten une Pommeou retourner moi NULLsi ce n'est pas une Pomme,". Vous obtenez ainsi du typage dynamique: vous ne savez pas ce qui se passe avant l'exécution.

Si vous utilisez des templates pour implémenter des containers, le compilateur C++ peut valider statiquement 90% des informations de type d'une application (l'estimation "90+%" est un apocryphe; certain disent obtenir 100% de typage statique, les gens qui ont besoin de persistance obtiennent moins de 100% de vérification de type statique). Le point important est: la généricité en C++ est obtenue avec les templates et non pas avec l'héritage.

NIHCL signifie "National-Institute-of-Health's-class-library." il peut être obtenue ftp://128.231.128.7/pub/NIHCL/nihcl-3.0.tar.Z

NIHCL (des gens prononce "N-I-H-C-L," d'autres "nickel") est une traduction C++ de la librairie de classe de Smalltalk . Il y a des cas ou l'utilisation du typage dynamique aide NIHCL (E.g., les objets persistent ). Il y a aussi d'autre cas ou l'utilisation du typage dynamique crée des tension avec le typage statique du langage C++.

Ce logiciel est payant et il est illégal de le fournir sur le net. Toutefois il ne coûte seulement qu'à peu prés 30$.

Beaucoup de gens sont surpris par la taille de leurs exécutables, spécialement si le code source est trivial. Par exemple, un programme qui imprime "hello world"peut générer une exécutable plus gros qu'attendu ( + 40K octets).

Une raison qui rend les exécutables aussi volumineux est que des portions de la librairie d'exécution C++ peut être lié avec votre programme. Quelle quantité sera lié dépend de ce que vous utilisez et de comment le programmeur a découpé la librairie en modules (fichiers). (N.D.T : des lieurs récents tente de n'inclure que le code réellement utilisé et non pas tout les modules ou une portion du code est utilisé) Par exemple, la librairie <iostream.h> est assez volumineuse, et inclus de nombreuse classes et de nombreuses fonctions virtuel . Utiliser une partie de cette librairie peut conduire a l'inclusion de tout (ou presque) le code de <iostream.h> du aux interdépendances du code (N.D.T : ceci est particulièrement vrai lorsque que l'on utilise intensivement les fonctions virtuels dans une librairie).

Vous pouvez rendre votre programme plus petit en utilisant une version dynamiquement lié (DLL) de la libraire en place d'une version lié statiquement.

Vous devez consulter le manuel de votre compilateur ou le support technique du compilateur pour une réponse plus détaillé.

La FAQ des librairies C++est maintenu par Nikki Lockeet est disponible a www.trumphurst.com/cpplibs1.html