Apprendre C/C++ Étape par Étape - Page 9

 printf("\nL'adresse de A est     : 0x%x", &a);

int *ptr;

pointer   ptr;          /*  invalide */
``` Le problème est que le compilateur doit savoir quel type de variable le pointeur pointe.  |


|  | Déclaration d'une variable pointeur  
char *cptr;           /* Pointeur vers un caractère */  
int *iptr;            /* Pointeur vers un int */  
float *fptr;            /* Pointeur vers un float */  
struct emp *e;            /* Pointeur vers des données abstraites emp e */ |


#### Accéder à la variable pointée :

Voici une manière spéciale d'accéder aux valeurs d'une variable en utilisant son adresse au lieu de son nom.



|  | /* 60_addr.c */  
#include   
int main()  
{  
int var1 = 11; /* variable var1 = 11 */  
int *ptr; /* Variable ptr comme pointeur vers */  
  
ptr = &var1; /* Conserve l'adresse de var1 dans ptr */  
  
printf("La valeur de var1 est %d", *ptr); /* Pointeur vers l'adresse de var1 */  
return 0;  
} |


|  | ![](/files/4f55092a-e6b6-422d-af47-d517ba51db5b.jpg) |


Si l'instruction est printf ("%d", ptr); alors elle affiche la valeur de ptr, c'est-à-dire l'adresse de var1, mais l'instruction ci-dessus peut afficher le contenu de l'adresse, qui était stocké dans la variable ptr.

Programme pour démontrer l'utilisation de Address_Of et Pointer_To


|  | /* 61_ptrdemo.c */  
#include   
int main()  
{  
int a = 10, *p; /* Entier a et pointeur p */  
p = &a; /* Assigne l'adresse de a à p */  
  
printf("\nValeur de A : %d", a); /* Contenu de a */  
printf("\nAdresse de A : 0x%x", &a); /* Adresse de a */  
printf("\nValeur de P : 0x%x", p); /* Contenu de p */  
printf("\nAdresse de P : 0x%x", &p); /* Adresse de p */  
printf("\nContenu à l'adresse de a : %d", *p); /* Pointeur vers &a */  
return 0;  
} |


#### 5. Arithmétique des pointeurs

Toutes les variables peuvent supporter des opérations arithmétiques, et nous pouvons également effectuer des opérations arithmétiques sur les pointeurs. Le langage C/C++ peut prendre en charge 4 opérations arithmétiques sur les pointeurs, à savoir.


|  | Opération  
Addition  
Soustraction  
Incrémentation  
Décrémentation | Symbole  
+  
-  
++  
-- |



Remarque : La caractéristique principale de l'arithmétique des pointeurs est que les opérateurs ci-dessus sont en octets par rapport à son type de variable.



|  | /* 62_ptr.c */  
/* Démonstration de l'arithmétique des pointeurs */  
#include   
int main()  
{  
int a, *p;  
a = 100;  
p = &a;  
(*p)++; /* Incrémente le pointeur vers (contenu à l'adresse) de 1 */  
printf("%d", *p);  
return 0;  
} |
|  | Sortie  
101 |


Démonstration de l'arithmétique des pointeurs, Incrémente la valeur d'adresse


|  | /* 63_ptr.c */  
/* Incrémente la valeur d'adresse de 1 */  
#include   
int main()  
{  
int a, *p;  
a = 100;  
p = &a;  
*p++; /* Incrémente la valeur d'adresse dans p de 1 */  
printf("%d", *p);  
return 0;  
}  |
|  | Sortie  
Sortie inattendue |


Le programme ci-dessus illustre les opérateurs arithmétiques par rapport à l'incrémentation de la valeur et de l'adresse. p est une variable pointeur et a est assigné à 100, ainsi que p est assigné à l'adresse de a.

Maintenant, *p++ effectue l'incrémentation ou en fait saute la mémoire de 2 octets pour obtenir la nouvelle adresse et son contenu.
  
Si c'est **(*p)++, alors le contenu pointé par p** est 100 est incrémenté, résultant en 101.

#### 6. Pointeurs et tableaux

Dans le langage C/C++, les types de données pointeurs et tableaux se ressemblent. Les éléments du tableau sont référencés ainsi que la variable pointeur, les deux sont utilisés pour contenir l'adresse des éléments de données en mémoire.


|  | char name[20];  
Ou  
char *name ;  
  
char months[12][10];  
Ou  
char **months; |


Il existe une association étroite entre les pointeurs et les tableaux. Voici un aperçu des tableaux.


|  | /* 64_ptrarr.c */  
#include   
int main()  
{  
int i, a[5] = { 56, 43, 78, 98, 12 };  
for( i = 0; i < 5; i++)  
printf("\n%d", a[i]);  
return 0;  
} |


Il est possible d'accéder aux éléments du tableau en utilisant la notation des pointeurs.  
Trouvez la sortie du programme suivant.


|  | /* 65_ptrarr.c */  
#include   
int main()  
{  
int i, a[5] = { 56, 43, 78, 98, 12 };  
for( i = 0; i < 5; i++)  
printf("\n%d", *(a+ i) );  
return 0;  
} |


Suivez le programme suivant :


|  | /* 66_ptrarr.c */  
#include   
int main()  
{  
int i, a[ ] = { 56, 43, 78, 98, 12 }, *p;  
p = a;  
for( i = 0; i < 5; i++)  
printf("\n%d", *(p+ i) );  
return 0;  
} |


Voici une approche la plus simple pour imprimer les éléments du tableau donné (la taille n'est pas requise).


|  | /* 67_ptrarr.c */  
#include   
int main()  
{  
int i, a[ ] = { 56, 43, 78, 98, 12 }, *p;  
p = a;  
while (*p)           /* ou for(int i = 0; i<5; i++ ) */  
printf("\n%d", *p++);  
return 0;  
} |


#### 7. Pointeurs et chaînes de caractères

Une chaîne est une collection de caractères, y compris des espaces. Cette fois, nous discutons de la façon de gérer les chaînes en utilisant des pointeurs. Pas plus de discussions pour créer de la confusion. Voici la tâche simple pour vérifier à la fois le pointeur et le tableau de chaînes.

Il y a une différence subtile entre les chaînes et les pointeurs, suivez le programme.


|  | /* 68_ptrstr.c */  
#include   
int main()  
{  
char str1[ ] = "Vous aimeriez explorer C.";  
char *str2 = "Vous aimeriez explorer C.";  
puts(str1);  
puts(str2);  
str1++; /* Expression invalide */  
str2++; /* Expression valide */  
puts(str2); /* imprime ou aimeriez explorer…… */  
return 0;  
} |


Chaînes comme arguments de fonction

Une variable pointeur est plus flexible que les variables de tableau, voici le programme pour démontrer et afficher une chaîne avec la notation des pointeurs.


|  | /* 69_ptrarr.c */  
#include   
void disp(char *p);  
int main()  
{  
char str[ ] = "Bonjour!!..Bonjour!!.. Les pointeurs peuvent le gérer ?";  
disp(str);  
return 0;  
} void disp(char *p)  
{  
while(*p)  
printf("%c", *p++);  
} |


Tableau de pointeurs vers des chaînes

Il y a un inconvénient à stocker un tableau de chaînes, en ce sens que les sous-tableaux qui contiennent la chaîne doivent tous avoir la même longueur. Ainsi, de l'espace est gaspillé lorsque les chaînes sont plus courtes que les sous-tableaux.  
Voici la solution :


|  | /* 70_strings.c */  
#include   
int main()  
{  
char *weeks[7 ] = { "Dimanche", "Lundi", "Mardi", "Mercredi",  
"Jeudi", "Vendredi", "Samedi" };  
int i;  
for( i = 0; i<7; i++)  
puts(weeks[ i ] );  
return 0;  
} |


Lorsque les chaînes ne font pas partie d'un tableau, C/C++ les place de manière contiguë en mémoire, donc il n'y a pas d'espace gaspillé.
  
**/* Un exemple de programme pour contenir un tableau de pointeurs de type ‘int’ */**


|  | /* 71_ptrarr.c */  
#include   
int main()  
{  
int *arr[4]; /* Tableau de pointeurs int */  
int i = 31, j = 5, k = 19, l = 71, m;  
  
arr[0] = &i;  
arr[1] = &j;  
arr[2] = &k;  
arr[3] = &l;  
  
for(m = 0; m <= 3; m++)  
printf("\n%d", *(arr[m]) );  
return 0;  
} |


Un aperçu des fonctions de bibliothèque

Nous sommes déjà familiers avec les fonctions de chaîne standard. Elles ont des arguments de chaîne qui sont spécifiés en utilisant la notation des pointeurs,  
Si nous sommes clairs sur le concept de pointeurs et de chaînes, nous sommes capables d'écrire nos propres fonctions de chaîne.  
Voici un exemple de programme pour copier une chaîne.
  
**/* Copie une chaîne dans une autre avec des pointeurs */**


|  | /* 72_strcpy1.c */  
#include   
void strcpy1(char * dest, char *src);  
  
int main()  
{  
char *str1 = "Comment puis-je en apprendre davantage sur C/C++ !!!";  
char *str2;  
strcpy1(str2, str1);  
puts(str2);  
return 0;  
} void strcpy1(char * dest, char *src)  
{  
while(*src)  
*dest++ = *src++;  
*dest = '\0';  
} |


#### 8. Glossaire


| Adresse | Une valeur qui pointe vers un emplacement en mémoire. Un pointeur contient l'adresse ou l'emplacement d'une valeur, par opposition à la valeur elle-même. |
| Tableau | Un tableau est une collection d'éléments de données du même type. |
| Contigu | Une caractéristique de stockage qui spécifie que les valeurs sont stockées dans des emplacements consécutifs soit en mémoire, soit sur disque. |
| Fonction | Une série d'instructions pour effectuer une tâche spécifique, qui peut être combinée avec d'autres fonctions pour créer un programme. |
| Mémoire | Descriptif d'un dispositif ou d'un support qui peut accepter des données, les conserver et les livrer à la demande ultérieure. Synonyme de stockage. |
| Pointeur | Contient l'adresse ou l'emplacement mémoire d'une valeur, par opposition à la valeur elle-même. |
| RAM | (Mémoire à accès aléatoire) 1. Un dispositif de stockage structuré de sorte que le temps nécessaire pour récupérer des données n'est pas significativement affecté par l'emplacement physique des données.  2. La *section de stockage principale* d'un ordinateur personnel. |
| Chaîne | Un tableau capable de stocker zéro ou plusieurs caractères. En C, une chaîne est déclarée comme un tableau de caractères avec le caractère NULL (\0) ajouté pour spécifier la fin de la chaîne. |
| Variable | Un nom associé à un emplacement en mémoire dont la valeur peut changer pendant l'exécution du programme. |