I. Conteneurs séquentiels▲
I-A. La classe array▲
Cette classe donne des méthodes pour la gestion d'un tableau à taille fixe. Pour l'utiliser,
il faut inclure la Bibliothèque <array> :
#
include
<array>
I-A-1. Template, constructeurs, destructeurs▲
Le template est le suivant :
template
<
class
T, size_t N >
class
array;
La classe array ne fournit ni constructeur ni destructeur, mais des méthodes pour l'utilisation d'un tableau statique. Le type et le nombre des éléments sont déterminés à la déclaration dans le template :
array<
int
1
>
tab ; //
un
tableau
de
10
int
array<
double
, 50
>
d ; //
un
tableau
de
50
double
I-A-2. Accès éléments, itérateurs▲
operator[ ] : opérateur crochet pour l'accès immédiat à chaque élément selon son indice, comme pour tous les tableaux classiques. L'accès n'est pas contrôlé et il y a possibilité de débordement si l'indice est hors tableau.
array<
int
,10
>
a;
for
(
int
i =
0
; i <
10
; i+
+
) {
a[i] =
i ;
cout <
<
a[i] <
<
'
'
; //
0
1
2
3
4
5
6
7
8
9
}
cout <
<
endl;
at() : méthode pour un accès contrôlé à un élément du tableau selon son indice donné en paramètre. En cas de débordement, il est possible de récupérer une erreur de type exception.
array<
int
,10
>
a;
for
(
int
i =
0
; i <
10
; i+
+
) {
a.at
(
i) =
i ;
cout <
<
a.at
(
i) <
<
'
'
; //
0
1
2
3
4
5
6
7
8
9
}
cout <
<
endl;
back() : retourne une référence sur le dernier.
front() : retourne une référence sur le premier élément :
array<
int
,5
>
a =
{
1
,2
,3
,4
,5
}
;
cout <
<
"
front
:
"
<
<
a.front
(
) <
<
endl; //
1
cout <
<
"
back
:
"
<
<
a.back
(
) <
<
endl; //
5
a.back
(
) +
=
50
;
a.front
(
)+
=
50
;
for
(
int
&
i : a )
cout <
<
i <
<
'
'
; //
51
2
3
4
55
cout <
<
endl;
data() : retourne un pointeur sur le premier élément du tableau interne au conteneur. Un tableau array est continu en mémoire et il est possible de le parcourir avec un pointeur.
array<
int
, 5
>
a =
{
10
, 20
, 30
, 40
, 50
}
;
int
*
ptr;
ptr =
a.data
(
);
for
(
int
i =
0
; i <
a.size
(
); i+
+
)
cout <
<
ptr[i] <
<
'
'
; //
10
20
30
40
50
cout <
<
endl;
for
(
int
i =
0
; i <
a.size
(
); i+
+
){
ptr[i] =
rand
(
) %
10
;
cout <
<
ptr[i] <
<
'
'
; //
valeurs
entre
0
et
9
compris
}
cout<
<
endl;
Itérateurs
Le parcours d'un array peut aussi s'effectuer en utilisant des itérateurs (pointeurs) plutôt que le système d'indice. Pour ce faire la classe array contient les méthodes suivantes :
begin() : retourne un itérateur iterator qui pointe sur le premier élément ;
end() : retourne un itérateur iterator qui pointe sur l'élément suivant le dernier (balise de fin, par exemple NULL) ;
rbegin() : retourne un itérateur reverse_iterator qui pointe sur le premier élément de la séquence inverse (le dernier) ;
rend() : retourne un itérateur reverse_iterator qui pointe sur l'élément suivant le dernier dans l'ordre inverse (balise de fin, par exemple NULL) ;
cbegin() : retourne un itérateur const_iterator qui pointe sur le premier élément. L'élément pointé n'est alors accessible qu'en lecture et non en écriture. Il ne peut être modifié ;
cend() : retourne un itérateur const_iterator qui pointe sur ce qui suit le dernier élément (balise de fin, par exemple NULL). L'élément pointé n'est alors accessible qu'en lecture et non en écriture. Il ne peut être modifié ;
crbegin() : retourne un itérateur const_reverse_iterator qui pointe sur le premier élément de la séquence inverse (le dernier). L'élément pointé n'est accessible qu'en lecture et ne peut pas être modifié ;
crend() : retourne un itérateur const_reverse_iterator qui pointe sur la fin de la séquence inverse, avant le premier élément (balise de fin sens inverse, par exemple NULL). L'élément pointé n'est accessible qu'en lecture et ne peut pas être modifié.
array<
int
,5
>
a =
{
10
,20
,30
,40
,50
}
;
//
begin-end
for
(
auto
it =
a.begin
(
); it !
=
a.end
(
); +
+
it){
(
*
it)+
+
;
cout <
<
*
it <
<
'
'
; //
11
21
31
41
51
}
cout <
<
endl;
//
rbegin-rend
for
(
auto
it =
a.rbegin
(
); it !
=
a.rend
(
); +
+
it){
(
*
it)+
+
;
cout <
<
*
it <
<
'
'
; //
52
42
32
22
12
}
cout <
<
endl;
//
cbegin-cend
:
pas
de
modification
possible
for
(
auto
it =
a.cbegin
(
); it !
=
a.cend
(
); +
+
it){
//
(*it)++;
//
erreur
*it
doit
être
modifiable
cout <
<
*
it <
<
'
'
; //
12
22
32
42
52
}
cout <
<
endl;
//
crbegin-crend
for
(
auto
it =
a.crbegin
(
); it !
=
a.crend
(
); +
+
it){
//
(*it)++;
//
erreur
*it
doit
être
modifiable
cout <
<
*
it <
<
'
'
; //
52
42
32
22
12
}
cout <
<
endl;
I-A-3. Opérations de liste▲
fill() : affecte la même valeur à tous les éléments du tableau.
swap() : échange le contenu de deux tableaux de même type d'éléments et de même taille.
array<
int
, 5
>
a ;
array<
int
, 5
>
b ;
//
fill
a.fill
(
5
);
for
(
int
&
x : a) {
cout <
<
x <
<
'
'
; //
5
5
5
5
5
}
cout<
<
endl;
b.fill
(
1
);
for
(
int
&
x : b) {
cout <
<
x <
<
'
'
; //
1
1
1
1
1
}
cout <
<
endl;
//
swap
a.swap
(
b);
for
(
int
&
x : a) {
cout <
<
x <
<
'
'
; //
1
1
1
1
1
}
cout <
<
endl;
for
(
int
&
x : b) {
cout <
<
x <
<
'
'
; //
5
5
5
5
5
}
cout <
<
endl;
I-A-4. Taille et capacité▲
max_size() : retourne le nombre maximum d'éléments que peut contenir le tableau, c’est-à-dire la taille demandée pour le tableau dans le template de sa déclaration.
size() : donne le nombre d'éléments dans le tableau, équivaut à max_size().
empty() : retourne un booléen qui indique vrai ou faux selon que le tableau est vide (taille de 0) ou pas.
array<
int
, 5
>
a;
cout <
<
"
max_size:
"
<
<
a.max_size
(
) <
<
endl; //
5
cout <
<
"
size
:
"
<
<
a.size
(
) <
<
endl; //
5
cout <
<
"
empty
:
"
<
<
(
a.empty
(
)?"
oui
"
:"
non
"
)<
<
endl;//
non
I-A-5. Comparaisons▲
Les opérateurs de comparaison ==, !=, <, <=, >, >= sont supportés. Pour les notions d'infériorité et de supériorité, c'est un ordre lexicographique qui est pris en compte.
c++ |
0 |
1 |
|||
array<int,5> a = {1,2,3,4,5}; |
II. Conclusion▲
Ce tutoriel est extrait du livre Du C au C++ - De la programmation procédurale à l'objet de Frédéric Drouillon.
Commandez Du C au C++ - De la programmation procédurale à l'objet sur Amazon
III. Remerciements▲
Je tiens sincèrement à remercier Vincent VIALE pour la mise au gabarit et Claude LELOUP pour la relecture orthographique.