char ** et pointeurs de déréférencement

Un pointeur est un type qui est titulaire d'une adresse à une valeur, au lieu de la tenue de la valeur réelle.

Ainsi, dans le cas de char *p, une fois attribuées, p doit contenir une adresse A. Déréférencement du pointeur signifie accéder à la valeur stockée à l'adresse A. La raison pour laquelle vous pouvez stocker des chaînes de caractères dans un char *, c'est parce mémoire allouée est contiguë. Donc, A est une adresse qui stocke le premier caractère, Un+1 est une adresse qui stocke le deuxième caractère, et ainsi de suite.

Dans le cas de char **pp, il stocke l'adresse d'un char *. Appeler cette adresse B. Donc, de déférence pp signifie accéder à la valeur à l'adresse B, qui se trouve être un char *, qui arrive à tenir une chaîne de caractères. De la même manière, B+1 (en fait B + sizeof (char *)) stocke la valeur suivante, qui est une autre chaîne de caractères.

Déréférencement pp deux fois (ie **pp) signifie que vous êtes d'abord accéder à la valeur à l'adresse B, qui, par exemple, est Un, et puis de déférence qu'une fois de plus pour obtenir la valeur à l'adresse de A, qui est de certains personnages.

Déréférencement d'un pointeur signifie accéder à la valeur du pointeur points. Par exemple,

char c = 'c'; //This is a primitive value. You cannot dereference it.
char* p1 = &c; //A pointer to the address of c
char** p2 = &p1; //A pointer to the address of p1
/* Now, the following is true:
*p1 == c, i.e. dereferencing p1 allows us to read from/write to c.
*p2 == p1
**p2 == *(*p2) == *p1 = c - dereferencing p2 twice is c, too */

La raison pour laquelle vous utilisez un pointeur vers c au lieu de c directement est qu'un pointeur vous permet d'accéder à plus de 1 valeur. Prenez cet exemple:

char[4] str;
char c0 = 'a', c1 = 'b', c3 = 'c', c4 = '
char[4] str;
char c0 = 'a', c1 = 'b', c3 = 'c', c4 = '\0';
str[0] = c0; str[1] = c1; str[2] = c2; str[3] = c3;
str = "abc"; //Same as the above line
';
str[0] = c0; str[1] = c1; str[2] = c2; str[3] = c3;
str = "abc"; //Same as the above line

Maintenant, supposons que nous avons besoin de la deuxième personnage. Nous avons pu y accéder avec c1. Mais comme vous pouvez le voir, cette notation est vraiment lourd. De Plus, si nous lisons la chaîne dans un fichier au lieu de l'écrire, nous aurions à faire des choses compliquées. Au lieu de cela, nous venons d'écrire

str[1] /* or */ *(str+1)

Noter que le premier élément a la indice 0, le deuxième 1 - c'est pourquoi nous sommes à l'aide de 1 ici. Un char** transforme ce jusqu'à onze, nous avons un tableau d'un tableau de caractères. Supposons que nous avons un tel tableau, nous allons l'appeler inputet ont besoin de trouver la longueur de toutes les chaînes. C'est la manière dont nous le faisons:

int lensum(char **input) {
    int res = 0;
    while (*input) { //This loops as long as the value input points to is not 0.
        char* p = *input; //Make a copy of the value input currently points to
        while (*p != '
int lensum(char **input) {
int res = 0;
while (*input) { //This loops as long as the value input points to is not 0.
char* p = *input; //Make a copy of the value input currently points to
while (*p != '\0') { //Loop while the copy does not point to a char '\0'
res += 1; //We found a character
p++; //Check next character in the next iteration
}
input++; //Check next string in the next iteration
}
return res;
}
') { //Loop while the copy does not point to a char '
int lensum(char **input) {
int res = 0;
while (*input) { //This loops as long as the value input points to is not 0.
char* p = *input; //Make a copy of the value input currently points to
while (*p != '\0') { //Loop while the copy does not point to a char '\0'
res += 1; //We found a character
p++; //Check next character in the next iteration
}
input++; //Check next string in the next iteration
}
return res;
}
'
            res += 1; //We found a character
            p++; //Check next character in the next iteration
        }
        input++; //Check next string in the next iteration
    }
    return res;
}