Pointeurs en c
Le pointeur est un concept très important dans le langage C car le pointeur nous donne le concept d'adresse en mémoire. Tout ce qui n'est pas accessible par les autres, le pointeur peut y accéder très facilement à l'aide de l'adresse.
Ici, nous discuterons du concept de base du pointeur.
Objectif:
L'objectif principal du pointeur est principalement:
- Concept étendu de pointeur
- L'arithmétique du pointeur
Concept étendu de pointeur:
| X | p | q | r |
|---|---|---|---|
| 1000 | 2000 | 3000 | 4000 |
Exemple:
| 1 2 3 4 5 6 7 8 9 dix 11 12 13 14 15 | #inclure Vide main () Int x = 5, * p, ** q, *** r; p = & x; q = & p; r = & q; ** q = 7; *** r = 7; |
Explication:
Ici p est un pointeur. De la ligne P = & x, il est à comprendre que P est un pointeur tenant l'adresse de x .
** Q est également un type de pointeur dont le niveau d'indirection est 2 et R est également un pointeur dont le niveau d'indirection est 3. Combien y a-t-il du niveau de ce pointeur?
La règle est que le niveau de pointeur est tel qu'il détient l'adresse d'une autre variable dont le niveau d'indirection est exactement un de moins de ce pointeur.
Pour ce Q tient l'adresse de P. P tient l'adresse de x.
La procédure de lecture de la ligne int x = 5, * p, ** q, *** r;
x est un int. P est un pointeur vers un int. Q est un pointeur vers l'apointer d'un int. Combien y en a-t-il? Nous disons exactement le même NO de Pointeur de mot. Tout comme ** r, cela signifie que r est un pointeur, vers un pointeur, vers un pointeur vers un int.
Si nous mettons une certaine valeur à l'aide de Q, nous écrivons
| 1 | * q = p, * r = q, * p = x; |
Si nous écrivons un pointeur ou * avant une variable de pointeur, il se transforme en une telle variable qui pointe vers la moyenne de la variable, le bloc P.
pointeurs arithmétique:
Nous ne pouvons pas ajouter de multiplier ou de diviser en deux adresses (la soustraction est possible).
Nous ne pouvons pas multiplier un entier à une adresse. De même, nous ne pouvons pas diviser une adresse avec une valeur entière.
Exemple de programmation 1:
| 1 2 3 4 5 6 7 8 9 dix 11 12 13 14 15 16 17 18 19 20 21 | #inclure vide main () int a, b; int * p, * q; p = & a; q = & b; printf ("% d", p + q); printf ("% d", p * q); printf ("% d", p / q); |
Sortir:
Explication:
Dans le programme susmentionné, nous essayons d'ajouter, de multiplier et de diviser les deux adresses en écrivant certaines déclarations.
| 1 2 3 4 5 | printf ("% d", p + q); printf ("% d", p * q); printf ("% d", p / q); |
Mais ce n'est pas possible comme vous pouvez le voir sur la sortie. Pointer ne donne jamais la permission d'ajouter, de multiplier et de diviser une adresse.
Le pointeur peut permettre un calcul mathématique. Ils sont mentionnés ci-dessous:
| 1 2 3 4 5 6 7 | P = 1000 P + 1 = 1002 P + 4 = 1008 P - 1 = 998 |
P est le pointeur 1000 de type entier qui est basé sur l'adresse d'un. La variable «A» a deux octets. L'adresse du 1er octet est de 1001 et l'adresse du 2e octet est de 1002. Si nous ajoutons 1 à un pointeur, il fait l'adresse du bloc suivant ou de la variable suivante au lieu de l'adresse de l'octet suivant.
| 1 2 3 4 5 | Pointeur + n = pointeur + taille de (type de pointeur) * n = 1000 + 2 * 1 = 1002 |
Nous pouvons soustraire deux adresses du même type. Le pointeur le permet.
Exemple de programmation 2:
| 1 2 3 4 5 6 7 8 9 dix 11 12 13 14 | #inclure vide main () int a, b; int * p, * q; p = & a; q = & b; printf ("% d", p - q); |
Sortir:
Explication:
Ici, nous essayons de soustraire deux adresses. Heureusement, il peut soutenir par le pointeur. Ce n'est pas littéralement soustrait. Il est composé d'un bloc en fonction de son type de données.
Formule
| 1 | Pointeur 1 - pointeur 2 = (soustraction littérale) / taille de (type de pointeur) |
S'il s'agit de type char, divisé par 4.
S'il s'agit de type flotteur, divisé par 4.
S'il s'agit de type int, divisé par 2.
Exemple de programmation 3:
| 1 2 3 4 5 6 7 8 9 dix 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | #inclure VOID Swap (int *, int *); int main() int a, b; printf ("Entrez deux numéro"); scanf ("% d% d", & a, & b); échange (& a, & b); printf ("a =% d b =% d", a, b); Void Swap (int * x, int * y) int t; t = * x; * x = * y; * y = t; |
Sortir:
Explication:
Ici, un pointeur peut passer par une fonction. C'est ce qu'on appelle l'appel par références. Si nous voulons échanger deux entiers en passant les valeurs de deux entiers à travers une fonction, ce n'est pas possible.
Nous devons passer l'adresse de la variable t = & x. Si nous ajoutons * à une variable de pointeur, alors * x transformé en une telle variable qui maintient la valeur de la variable, qu'il pointe la variable P. Cela signifie t = * x, signifie, t détient la valeur d'un indirect.
Appelez par références:
Appeler par références est le même que l'appel par l'adresse. Lorsque les arguments formels sont des variables de pointeur, il est appelé par références.
Adresse des moyens de référence. Appel par référence signifie que lorsque nous appelons une fonction, nous passons les adresses des variables, elle est appelée appel de référence.
Une question importante peut se poser lié à l'adresse ou pourquoi nous utilisons l'adresse de (&) dans scanf ()?
ScanF () est une fonction prédéfinie dans le langage C. main () est également une fonction du langage C. Nous utilisons ScanF () à l'intérieur de Main (). Donc, si nous déclarons deux variables à l'intérieur de la fonction main (), nous accédons à cette variable dans ScanF (). Nous ne pouvons pas utiliser les variables d'une fonction à une autre fonction. Ainsi, la fonction ScanF () veut mettre une valeur à une variable et une variable B, alors il doit connaître l'adresse de A et B.
Pour cette adresse de (&) est utilisée dans Scanf ().
Conclusion:
Nous pouvons connaître tout le concept de base du pointeur. À partir de cette discussion, nous sommes arrivés à cette conclusion que sans pointeur, nous ne pouvons pas visualiser la gestion de la mémoire dans le langage C. Contrôles d'adresses L'ensemble du schéma de gestion de la mémoire. Pour cela, nous devons connaître le concept de pointeur.