La librairie STL va donner au C++ une réponse standardisée et exploitant très largement les mécanismes étendus de C++ par rapport à C:
La normalisation effective de la librairie STL en font une partie intégrante de C++, et on ne considèrera en général jamais une implémentation concernant la gestion des chaînes de caractères, les entrées sorties et les collections hors de la libraririe STL.
En particulier, la très grande utilisation de cette librairie a largement démontré sa fiabilité et son niveau d'optimisation, tant au niveau de l'utilisation de la mémoire que au niveau des performances. En particulier, les algorithmes utilisés en interne dans cette librairie ont été développés par des mathématiciens.
Nous allons décrire quelques uns seulement des services offerts par cette librairie.
La classe std::string permet de gérer des chaînes de caractères.
#include <string>
int main ()
{
std::string text = "abc defg";
std::string words[] = { "aaa", "bbb", "ccc", "ddd", "eee" };
text += words[0];
return (0);
}
std::string s = "abcd"; std::string t = s; t += "abcd";
std::string s = "abcd"; int size = s.size ();
std::string s = "abcd";
int pos = s.find ("bc");
std::string s = "abcd"; if (!strcmp (s.c_str (), "abcd")) ... ...
std::ifstream f; std::string s; std::getline (f, s); ...
La classe std::vector<T> permet de mémoriser tout type d'objet séquentiellement.
#include <vector>
int main ()
{
std::vector<int> v;
for (int i = 0; i < 10; i++)
{
v.push_back (i);
}
return (0);
}
#include <vector>
class A
{
public:
A (int value) { _value = value; }
private:
int _value;
};
int main ()
{
std::vector<A> v;
for (int i = 0; i < 10; i++)
{
v.push_back (A(i));
}
return (0);
}
#include <vector>
class A
{
public:
A (int value) { _value = value; }
private:
int _value;
};
int main ()
{
std::vector<A*> v;
for (int i = 0; i < 10; i++)
{
v.push_back (new A(i));
}
return (0);
}
int main ()
{
std::vector< std::vector< int > > v;
for (int x = 0; x < 10; x++)
{
std::vector< int > colonne;
for (int y = 0; y < 10; y++)
{
colonne.push_back (y*2);
}
v.push_back (colonne);
}
return (0);
v.push_back (12);
v.pop_back ();
v.clear ();
int first = v.front (); int last = v.back ();
int i = v[2];
On peut itérer sur les éléments d'un vecteur en utilisant un des itérateurs prédéfinis:
#include <iostream>
#include <vector>
typedef std::vector<int> int_vector;
int main ()
{
int_vector v;
for (int i = 0; i < 10; i++)
{
v.push_back (i);
}
int_vector::iterator it;
for (it = v.begin (); it != v.end (); ++it)
{
int i = *it;
std::cout << "i = " << i << std::endl;
}
return (0);
}
std::vector<int> v; std::vector<int>::iterator it; it = ...; v.erase (it);
std::vector<int> v; std::vector<int>::iterator it; it = v.begin (); // Insertion avant l'élément pointé par it v.insert (it, 24);
Les listes fournies par la classe list<T> fonctionnent de façon très similaires aux vecteurs, mais proposent une implémentation à base de listes chaînées bidirectionnelles permettant des insertions et suppressions plus performantes.
#include <list>
#include <iostream>
typedef std::list<int> int_list;
int main ()
{
int_list liste;
for (int i = 0; i < 10; i++)
{
liste.push_front (i);
liste.push_back (i);
}
int_list::iterator it;
for (it = liste.begin (); it != liste.end (); ++it)
{
int i = *it;
std::cout << "i = " << i << std::endl;
}
}
La classe map fournit une collection indexée.
#include <iostream>
#include <map>
#include <string>
typedef std::map<int,std::string> dictionary;
int main ()
{
dictionary d;
std::string words[] = { "aaa", "bbb", "ccc", "ddd", "eee" };
for (int i = 0; i < sizeof (words) / sizeof (std::string); i++)
{
d[i] = words[i];
}
dictionary::iterator it;
for (it = d.begin (); it != d.end (); ++it)
{
int key = (*it).first;
std::string word = (*it).second;
std::cout << "word = " << word << std::endl;
}
}