Langage C

Notification de cookies

Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies. Plus d'informations

les tableaux en C

Un tableau est une collection d'éléments stockés dans des emplacements de mémoire continus.

Pourquoi avons-nous besoin de tableaux?

Nous pouvons utiliser des variables normales (v1, v2, v3, ..) lorsque nous avons un petit nombre d'objets, mais si nous voulons stocker un grand nombre d'objets(instances), il devient difficile de les gérer avec des variables normales. L'idée de tableau est de représenter plusieurs objets dans une seule variable.

Déclaration de tableaux en C / C ++:

Nous pouvons déclarer un tableau en spécifiant son type et sa taille ou en l'initialisant, ou les deux.

Déclaration de tableau en spécifiant la taille
Exemple 1 :
                                int main(void){
                                    // Déclaration de tableau en spécifiant la taille
                                    int tab[10];

                                    // nous pouvons également déclarer un tableau de taille spécifiée par l'utilisateur
                                    int n=10;
                                    int T[n];

                                    return 0;
                                }
                            
Déclaration de tableau en initialisant des éléments
Exemple 2 :
                                int main(void){
                                    int tab[] = { 10, 20, 30, 40 }
                                    
                                    // Le compilateur crée un tableau de taille 4. 
                                    // ci-dessus est identique à "int tab[4] = {10, 20, 30, 40}"

                                    return 0;
                                }
                            
Déclaration de tableau en spécifiant la taille et en initialisant les éléments
Exemple 2 :
                                int main(void){
                                    int tab[6] = { 10, 20, 30, 40 } 
                                    // Le compilateur crée un tableau de taille 6, initialise d'abord
                                    // 4 éléments tels que spécifiés par l'utilisateur et deux éléments par 0.
                                    // ci-dessus est identique à "int tab[] = {10, 20, 30, 40, 0, 0}"

                                    return 0;
                                }
                            

Proprietes d'un tableau en C / C ++:

Accéder aux éléments du tableau :

Les éléments de tableau sont accessibles à l'aide d'un index entier. L'indice de tableau commence par 0 et va jusqu'à la taille du tableau moins 1.

Exemple 3 :
                                #include < stdio.h> 
                                int main(void){
                                    int tab[] = { 10, 20, 30, 40 } 
                                    tab[2]=5;
                                    tab[0]=2;
                                    tab[2]=tab[1];

                                    printf("%d - %d - %d - %d", tab[0], tab[1], tab[2], tab[3]);

                                    return 0;
                                }
                            
  2 - 20 - 20 - 40

pas de contrôle d'indice hors limite :

Il n'y a pas de contrôle d'indice hors limite en C, par exemple, le programme suivant compile bien mais peut produire une sortie inattendue lors de l'exécution.

Exemple 4 :
                                #include < stdio.h> 
                                int main(void){
                                    int tab[2];
                                    printf("%d \n", arr[3]); 
                                    printf("%d ", arr[-2]); 

                                    return 0;
                                }
                            
-434996632
32766
initialiser un tableau avec plus d’éléments que la taille spécifiée

De même, en C, ce n’est pas une erreur du compilateur d’initialiser un tableau avec plus d’éléments que la taille spécifiée. Par exemple, le programme ci-dessous compile bien et ne montre que Warning.

Exemple 5 :
                                #include < stdio.h> 
                                int main(void){
                                    int tab[2] = { 10, 20, 30, 40, 50 }; 

                                    return 0;
                                }
                            
prog.c:4:27: warning: excess elements in array initializer
int tab[2] = {10, 20, 30, 40, 50};
                       ^~
1 warning generated.

les éléments du tableau sont stockés à des emplacements contigus

Exemple 6 :
                                #include < stdio.h> 
                                int main(void){
                                    int tab[5],i;
                                    printf("La taille de l'entier dans ce compilateur est %lu\n", sizeof(int));
                                    for (i = 0; i < 5; i++){
                                        printf("Adresse tab[%d] est %p\n", i, &tab[i]); 
                                    } 

                                    return 0;
                                }
                            
La taille de l'entier dans ce compilateur est 4
Adresse tab[0] is 0x7ffee793ba00
Adresse tab[1] is 0x7ffee793ba04
Adresse tab[2] is 0x7ffee793ba08
Adresse tab[3] is 0x7ffee793ba0c
Adresse tab[4] is 0x7ffee793ba10

Différence entre le pointeur et le tableau en C

Les pointeurs sont utilisés pour stocker les adresses des tableaux alloués dynamiquement et pour ceux qui sont transmis en tant qu'arguments aux fonctions. Dans d'autres contextes, les tableaux et le pointeur sont deux choses différentes,

La plupart du temps, les accès de pointeur et de tableau peuvent être traités comme agissant de la même manière, les principales exceptions étant:

Opérateur sizeof
  • sizeof (tableau) renvoie la quantité de mémoire utilisée par tous les éléments du tableau.
  • sizeof (pointeur) ne renvoie que la quantité de mémoire utilisée par la variable de pointeur elle-même
Exemple 7 :
                                #include < stdio.h> 
                                int main(void){
                                    int tab[5] = { 10, 20, 30, 40, 50 }; 
                                    int *ptr = tab;
                                    printf("Taille de tab[] : %d\n", sizeof(tab)); 

                                    printf("taille de ptr : %d", sizeof(ptr)); 
                                    return 0;
                                }
                            
Taille de tab[] : 20
taille de ptr : 8
Attribution des adresses

L'attribution d'une adresse à une variable de type tableau n'est pas autorisée.

Exemple 8 :
                                #include < stdio.h> 
                                int main(void)
                                {
                                    int tab[5] = { 10, 20, 30, 40, 50 },x=5; 
                                    int *ptr = &x; // ok
                                    tab=&x // Erreur du compilation
                                    return 0;
                                }
                            
prog.c:6:9: error: array type 'int [5]' is not assignable
tab = &x; // Erreur du compilation
~~~ ^
1 error generated.
les opérateurs arithmétiques sur la variable de pointeur est autorisée
Exemple 9 :
                                int main(void)
                                {
                                    int a[10];
                                    int *p;
                                    p++; // ok 
                                    a++; // Erreur de compilation
                                    return 0;
                                }
                            
prog.c:6:6: error: cannot increment value of type 'int [10]'
a++; // Erreur de compilation
~^
1 error generated.

Bien que tableau et pointeur soient deux choses différentes, les propriétés suivantes du tableau les rendent similaires.

Le nom du tableau donne l'adresse du premier élément du tableau.
Exemple 10 :
                                #include < stdio.h> 
                                int main(void)
                                {
                                    int tab[] = {10, 20, 30, 40, 50, 60}; 
                                    int *ptr = tab;
                                    printf("La valeur du premier élément est %d", *ptr);
                                    return 0;
                                }
                            
La valeur du premier élément est 10
Les membres du tableau.

Le compilateur utilise l'arithmétique de pointeur pour accéder à un élément de tableau. Par exemple, une expression telle que "tab[i]" est traitée par *(tab + i) par le compilateur. C'est pourquoi les expressions comme *(tab + i) fonctionnent pour tableau tab et les expressions comme ptr[i] fonctionnent également pour le pointeur ptr.

Exemple 11 :
                                #include < stdio.h> 
                                int main(void)
                                {
                                    int tab[] = {10, 20, 30, 40, 50, 60}; 
                                    int *ptr = tab;
                                    printf("tab[2] = %d\n", tab[2]);
                                    printf("*(tab + 2) = %d\n", *(tab+ 2));
                                    printf("ptr[2] = %d\n", ptr[2]); 
                                    printf("*(ptr + 2) = %d\n", *(ptr + 2)); 
                                    return 0;
                                }
                            
tab[2] = 30
*(tab + 2) = 30
ptr[2] = 30
*(ptr + 2) = 30
Les paramètres du tableau.

Les paramètres de tableau sont toujours passés en tant que pointeurs, même lorsque nous utilisons des crochets.

Exemple 12 :
                                #include < stdio.h> 

                                int test(int ptr[]){
                                    int x=15;
                                    printf("sizeof(ptr) = %d\n", sizeof(ptr));

                                    ptr = &x; 

                                    printf("*ptr = %d ", *ptr); 

                                    return 0;
                                }
                                int main(void)
                                {
                                    int tab[] = {10, 20, 30, 40, 50, 60}; 
                                    test(tab); 
                                    return 0;
                                }
                            
sizeof(ptr) = 8
*ptr = 15

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :