Différence entre * ptr et (* ptr)

Pour le code suivant:

int (*ptr)[10]; int a[10]={99,1,2,3,4,5,6,7,8,9}; ptr=&a; printf("%d",(*ptr)[1]); 

Que devrait-il imprimer? Je m’attends à la valeur des déchets ici, mais la sortie est 1 .
(pour lequel je conclus que cette initialisation de cette manière tableau de pointeur c’est-à-dire que ptr[10] commencerait à pointer vers les éléments d’ a[10] dans l’ordre).

Mais qu’en est-il de ce fragment de code:

 int *ptr[10]; int a[10]={0,1,2,3,4,5,6,7,8,9}; *ptr=a; printf("%d",*ptr[1]); 

C’est donner la faute à la segmentation.

int *ptr[10];

Ceci est un tableau de 10 pointeurs int* , pas comme vous le supposeriez, un pointeur sur un tableau de 10 points d’ int .

int (*ptr)[10];

Ceci est un pointeur sur un tableau de 10 int

C’est je crois la même chose que int *ptr; en ce que les deux peuvent pointer vers un tableau, mais la forme donnée peut UNIQUEMENT pointer vers un tableau de 10 int s

 int (*ptr)[10]; 

est un pointeur sur un tableau de 10 ints.

 int *ptr[10]; 

est un tableau de 10 pointeurs.

Raison du segfault:

* ptr = a; printf (“% d”, * ptr [1]);

Ici, vous affectez l’adresse du tableau a à ptr qui pointerait sur l’élément a[0] . Cela équivaut à: *ptr=&a[0];

Cependant, lorsque vous imprimez, vous accédez à ptr[1] qui est un pointeur non initialisé, un comportement non défini et donnant ainsi un segfault.

int(*)[10] est un pointeur sur un tableau int de 10 membres. c’est-à-dire qu’il pointe vers int a[10] .

où as int *[10] est un tableau de pointeurs entiers

 #include  int main() { int *ptr[10]; int a[10]={0,1,2,3,4,5,6,7,8,9}; printf("\n%p %p", ptr[0], a); *ptr=a; //ptr[0] is assigned with address of array a. printf("\n%p %p", ptr[0], a); //gives you same address printf("\n%d",*ptr[0]); //Prints zero. If *ptr[1] is given then *(ptr + 1) ie ptr[1] is considered which is uninitialized one. return 0; } 

int (* p) [10] signifie que p est maintenant un pointeur sur un tableau entier de taille 10.

int * p [10] signifie que p est un tableau de 10 pointeurs d’entiers.

int (*p)[10] est un pointeur sur un tableau de 10 entiers dans chaque ligne, ce qui signifie qu’il peut y avoir un nombre quelconque de lignes. en gros, il peut être utilisé pour pointer sur un tableau 2D et accéder aux dimensions en incrémentant i pour *(p+i)[10] ce qui est identique à a[i][10] , ici 'i=1,2,3...' pour accéder aux 1,2,3.. rows .

où as, int *p[10] est un tableau de 10 pointeurs entiers.

Si array est deux dimesional, par exemple

b[2][10]={{0,1,2,3,4,5,6,7,8,9},{10,11,12,13,14,15,16,17,18,19}}; fondamentalement, (*ptr)[10] // where the higher dimension index is omitted ie, 2 peut être utilisé comme pointeur bidimensionnel vers un tableau (contenant 10 éléments dans chaque ligne, c’est-à-dire la 1ère dimension) comme (*ptr)[10] = &b . Dans le printf("%d",(*ptr)[1]); tel que fourni (*ptr) est identique à *(ptr+0) à la première dimension, c.-à-d. b[0][0] dont la valeur est 0. De même, pour accéder à la deuxième dimension du tableau b[1][0] l’expression sera **(ptr+1) ou *(ptr+1)[0] ou *(*(ptr+i)+j); // where i=1 and j=0 *(*(ptr+i)+j); // where i=1 and j=0 donne le premier élément de la 2e dimension, c’est-à-dire 10.

J’y ai répondu longtemps pour comprendre facilement.

Les deux seuls cas d’utilisation de (*ptr)[10] sont les suivants:

  • lorsque vous travaillez avec des tableaux bidimensionnels;
  • typedef tableaux de longueur fixe.

Comme le premier cas a déjà été expliqué ci-dessus par Sree harsha Punyasamudram, je vais expliquer le cas d’utilisation plus exotique.

  #include  typedef int arr1d10[10]; typedef int arr2d3[3][3]; void test1d0(arr1d10 *arr) { /* This is the same as the case with function test1d1(). */ printf("Element: %d\n", (*arr)[0]); } void test1d1(int (*arr)[10]) { /* As arr is a pointer to an array of 10 integers, pointer arithmetic will work with the size of an array of 10 integers, ie when you increment arr it will increment by sizeof(arr1d10), which is 40 bytes. That's why when you dereference it, you can't simply do arr[1], because it will increment arr by 40 bytes forward. Also when dereferencing it, because it thinks it points to a whole array it will give you that array - it's address. This is another reason you can't do just arr[i], because those will be just addresses. The correct way is to dereference it once(*arr)), to get the address (think of implicitely casting to int*) and then you can do as usually (*arr)[1]). */ printf("Element: %d\n", (*arr)[1]); } void test2d0(arr2d3 *arr2d) { /* This is a little more complicated, but the principle is the same as above. */ printf("Element: %d\n", (*arr2d)[0][0]); } void test2d1(int (*arr2d)[3][3]) { printf("Element: %d\n", (*arr2d)[0][1]); } int main(void) { arr1d10 arr1d = {0, 1, 2}; arr2d3 arr2d = { {0,1},{2,3},{3,4}}; int (*p1d)[10] = &arr1d; int (*p2d)[3][3] = &arr2d; printf("********** PRINT 1D array **********\n"); test1d0(&arr1d); test1d1(&arr1d); test1d0(p1d); test1d1(p1d); printf("********** PRINT 2D array **********\n"); test2d0(&arr2d); test2d1(&arr2d); test2d0(p2d); test2d1(p2d); return 0; }