Opérateur d’indice : []
Syntaxe
postfix-expression [ expression ]
Notes
Une expression suffixée (qui peut également être une expression primaire) suivie de l’opérateur d’indice, [ ]
, spécifie l’indexation d’un tableau.
Pour plus d’informations sur les tableaux managés dans C++/CLI, consultez Tableaux.
Généralement, la valeur représentée par postfix-expression est une valeur de pointeur, par exemple un identificateur de tableau, et expression est une valeur intégrale (y compris des types énumérés). Toutefois, sur le plan de la syntaxe, il est requis que l'une des expressions soit de type pointeur et l'autre de type intégral. La valeur intégrale peut donc se trouver dans la position de postfix-expression et la valeur de pointeur peut être entre les crochets, dans la position de expression ou de l’indice. Prenons le fragment de code suivant :
int nArray[5] = { 0, 1, 2, 3, 4 };
cout << nArray[2] << endl; // prints "2"
cout << 2[nArray] << endl; // prints "2"
Dans l'exemple précédent, l'expression nArray[2]
est identique à 2[nArray]
. La raison en est que le résultat d’une expression d’indice e1[e2]
est donné par :
*((e2) + (e1))
L’adresse produite par l’expression n’est pas e2 octets à partir de l’adresse e1. Au lieu de cela, l’adresse est mise à l’échelle pour produire l’objet suivant du tableau e2. Par exemple :
double aDbl[2];
Les adresses de aDb[0]
et aDb[1]
ont 8 octets de différence – la taille d’un objet de type double
. Cette mise à l’échelle selon le type d’objet est effectuée automatiquement par le langage C++ et est définie dans Opérateurs additifs, où l’ajout et la soustraction des opérandes de type pointeur sont abordés.
Une expression d'indice peut également avoir plusieurs indices, comme suit :
expression1[expression2] [expression3] ...
Les expressions d'indice s'associent de gauche à droite. L'expression d'indice extrême gauche, expression1[expression2], est évaluée en premier. L'adresse qui résulte de l'ajout d'expression1 et expression2 forme une expression de pointeur. Ensuite, expression3 est ajouté à cette expression de pointeur pour former une nouvelle expression de pointeur, et ainsi de suite jusqu'à ce que la dernière expression d'indice ait été ajoutée. L’opérateur d’indirection (*
) est appliqué après l’évaluation de la dernière expression d’indice, à moins que la valeur de pointeur finale pointe vers un type tableau.
Les expressions à indices multiples font référence à des éléments de tableaux multidimensionnels. Un tableau multidimensionnel est un tableau dont les éléments sont des tableaux. Par exemple, le premier élément d'un tableau tridimensionnel est un tableau à deux dimensions. L'exemple suivant déclare et initialise un tableau de caractères simple à deux dimensions :
// expre_Subscript_Operator.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;
#define MAX_ROWS 2
#define MAX_COLS 2
int main() {
char c[ MAX_ROWS ][ MAX_COLS ] = { { 'a', 'b' }, { 'c', 'd' } };
for ( int i = 0; i < MAX_ROWS; i++ )
for ( int j = 0; j < MAX_COLS; j++ )
cout << c[ i ][ j ] << endl;
}
Indices positifs et négatifs
Le premier élément d'un tableau est l'élément 0. La plage d’un tableau C++ est comprise entre tableau[0] et tableau[taille - 1]. Toutefois, C++ prend en charge les indices positifs et négatifs. Les indices négatifs doivent rester dans les limites du tableau. Sinon, les résultats sont imprévisibles. Le code suivant montre des indices de tableau positifs et négatifs :
#include <iostream>
using namespace std;
int main() {
int intArray[1024];
for (int i = 0, j = 0; i < 1024; i++)
{
intArray[i] = j++;
}
cout << intArray[512] << endl; // 512
cout << 257[intArray] << endl; // 257
int *midArray = &intArray[512]; // pointer to the middle of the array
cout << midArray[-256] << endl; // 256
cout << intArray[-256] << endl; // unpredictable, may crash
}
L’indice négatif de la dernière ligne peut provoquer une erreur à l’exécution, car il pointe vers une adresse qui est 256 positions int
plus bas dans la mémoire que l’origine du tableau. Le pointeur midArray
est initialisé au milieu de intArray
: il est donc possible (mais dangereux) d’utiliser à la fois des indices de tableau négatifs et positifs sur celui-ci. Les erreurs d’indice de tableau ne génèrent pas d’erreurs au moment de la compilation, mais ils produisent des résultats imprévisibles.
L'opérateur d'indice est commutatif. Par conséquent, les expressions tableau[index] et index[tableau] sont garanties équivalentes, à condition que l’opérateur d’indice ne soit pas surchargé (consultez Opérateurs surchargés). La première forme constitue la pratique de codage la plus courante, mais les deux fonctionnent.
Voir aussi
Expressions suffixées
Opérateurs intégrés, priorité et associativité C++
Tableaux
Tableaux unidimensionnels
Tableaux multidimensionnels
Commentaires
https://aka.ms/ContentUserFeedback.
Bientôt disponible : tout au long de 2024, nous allons éliminer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d'informations, consultez :Envoyer et afficher des commentaires pour