« Programmation C++/Les tableaux » : différence entre les versions

Contenu supprimé Contenu ajouté
Isdine (discussion | contributions)
m Formatage, ajout de code
Ligne 8 :
 
==== Sémantique ====
<ttcode>''identificateur''</ttcode> est un tableau de <ttcode>''taille''</ttcode> éléments de type <ttcode>''type''</ttcode>. <ttcode>''taille''</ttcode> est obligatoirement une valeur constante. La taille du tableau est donc figée une fois pour toute et ne peut pas être modifiée en cours d'exécution.
 
Pour désigner la i-ième case de tableau, on écrit
''identificateur''[''i'']
où <ttcode>''i''</ttcode> est un entier quelconque. Les cases sont numérotées à partir de 0 : les valeurs possibles de i vont donc de <ttcode>0</ttcode> à <ttcode>''taille''-1</ttcode>.
 
==== Pointeurs et tableaux ====
Ligne 68 :
'''Syntaxe : '''
''pointeur''=new ''type''[''taille''];
L'opérateur <ttcode>new</ttcode> permet d'allouer une zone mémoire pouvant stocker ''taille'' éléments de type ''type'', et retourne l'adresse de cette zone. Le paramètre ''taille'' est un entier qui peut être quelconque (variable, constante, expression). <ttcode>new</ttcode> renverra un pointeur vers un ''type''. La variable ''pointeur'' est donc du type ''type *''. Les cases du tableaux seront numérotées de 0 à ''taille''-1 et on y accédera comme un tableau statique. S'il n'y a pas assez de mémoire disponible, <ttcode>new</ttcode> renvoie le pointeur <ttcode>NULL</ttcode>.
 
==== L'opérateur <ttcode>delete[]</ttcode> ====
'''Syntaxe : '''
delete[] ''pointeur'';
Cette utilisation de delete[] permet de détruire un tableau précédemment alloué grâce à new. N'oubliez surtout pas les crochets juste après <ttcode>delete</ttcode>, sinon le tableau ne sera pas correctement libéré. Le programmeur en C++ doit gérer la destruction effective des tableaux qu'il a créé dynamiquement.
==== Exemple ====
<source lang="cpp">
Ligne 181 :
 
=== Parcours d'un tableau ===
Le parcours de tous les éléments d'un tableau se fait avec une boucle <ttcode>for</ttcode>.
Exemple :
<source lang="cpp">
Ligne 196 :
cout << "Nombre : " << *p << endl;
</source>
Initialement le pointeur <ttcode>p</ttcode> pointe le premier élément du tableau.
L'instruction <ttcode>p++</ttcode> dans la boucle <ttcode>for</ttcode> incrémente le pointeur, c'est à dire qu'il passe à l'élément suivant. L'adresse contenue dans le pointeur n'augmente pas de 1, mais de la taille de l'élément pointé (ici <ttcode>int</ttcode>, soit 4 octets en général).
 
== Les tableaux à deux dimensions ==
Ligne 318 :
 
 
=== Les tableaux de <ttcode>char</ttcode> ===
Un tableau de <ttcode>char</ttcode> constitue une chaîne de caractères.
Exemple :
<source lang="cpp">
char chaine[20] = "BONJOUR";
</source>
La variable <ttcode>chaine</ttcode> peut stocker jusqu'à 20 caractères, et contient les caractères suivants :
'B','O','N','J','O','U','R','\0'
Le dernier caractère est nul pour indiquer la fin de la chaîne de caractères.
Ligne 340 :
Dans ce cas la variable ne pourra stocker que des chaînes de taille inférieure ou égale à celle d'initialisation.
 
Les fonctions de manipulation de chaîne de caractères sont les mêmes que dans le langage C. Elles portent un nom commençant par <ttcode>str</ttcode> ('''Str'''ing) :
;<ttcode>int strlen(const char* source)</ttcode>:Retourne la longueur de la chaîne <ttcode>source</ttcode> (sans le caractère nul final).
;<ttcode>void strcpy(char* dest, const char* source)</ttcode>:Copie la chaîne <ttcode>source</ttcode> dans le tableau pointé par <ttcode>dest</ttcode>.
 
=== Les tableaux de <code>char16_t</code> and <code>char32_t</code> ===
Ligne 357 :
</source>
 
=== Les tableaux de <ttcode>wchar_t</ttcode> ===
Les compilateurs moderne permettent de faire des chaînes de <ttcode>wchar_t</ttcode> (16 bits ou 32 bits) au lieu de <ttcode>char</ttcode> (8 bits). Ceci a été fait pour permettre de représenter une plus grande partie des caractères Unicode, même si on peut représenter l'ensemble de ces caractères en [[UTF-8]].
 
Dans ce cas, il faut précéder les caractères par <ttcode>L</ttcode> :
<source lang="cpp">
wchar_t chaine[20] = L"BONJOUR";
Ligne 368 :
wchar_t chaine[20] = {L'B',L'O',L'N',L'J',L'O',L'U',L'R',L'\0'};
</source>
Les fonctions permettant leur manipulation portent un nom similaire, excepté que <ttcode>str</ttcode> doit être remplacé par <ttcode>wcs</ttcode> ('''W'''ide '''C'''haracter '''S'''tring) :
*<ttcode>int wcslen(const wchar_t* source)</ttcode>
*<ttcode>wcscpy(wchar_t* dest, const wchar_t* source)</ttcode>
 
=== Portabilité ===
Certains environnements de développement (Visual C++ en particulier) considèrent Unicode comme une option de compilation.
Cette option de compilation définit alors le type <ttcode>TCHAR</ttcode> comme <ttcode>char</ttcode> (option legacy) ou <ttcode>wchar_t</ttcode> (option unicode), selon l'option Unicode. Les constantes sont alors à encadrer par la macro <ttcode>_T(x)</ttcode> qui ajoutera <ttcode>L</ttcode> si nécessaire :
<source lang="cpp">
TCHAR chaine1[20] = _T("BONJOUR");
Ligne 380 :
{_T('B'),_T('O'),_T('N'),_T('J'),_T('O'),_T('U'),_T('R'),_T('\0')};
</source>
Le nom des fonctions de manipulation commencent par <ttcode>_tcs</ttcode> :
*<ttcode>int _tcslen(const TCHAR* source)</ttcode>
*<ttcode>_tcscpy(TCHAR* dest, const TCHAR* source)</ttcode>
 
== Voir aussi ==