Der Unterschied zwischen dem ersten Byte und der Adresse des Elements der ersten Byte

Question

sich das folgende 2-dimensionale Array:

array= { 
     {'a','b','c'}, 
     {'d','e','f'}, 
     {'g','h','i'} 
     } 

Die Aussage: array, an die Adresse des ersten Byte des Arrays zeigen würde, und die Anweisung: &array[0][0], würde auf das erste Byte des ersten Elements des Arrays zeigen.

Was ist der Unterschied zwischen diesen beiden? Sind sie nicht das Gleiche? Wie können wir den Unterschied zwischen diesen beiden mit einfachen Codes demonstrieren?

Answer 1

#include <stdio.h> 


int main(int argc, char* argv[]){ 
    int arr[3][3] = {{'a','b','c'}, 
        {'d','e','f'}, 
        {'g','h','i'} 
    }; 

    //value of the first elemnt 
    printf("%c\n",arr[0][0]); 

    //3 ways to print the address of the first element 
    printf("%p\n",arr); 
    printf("%p\n",(arr+0)); 
    printf("%p\n",&arr[0][0]); 

    //the value of the first element in the second row 
    printf("%c\n",arr[1][0]); 
    //2 ways to use the address of the first element in the second row 
    printf("%p\n",&arr[1][0]); 
    printf("%p\n",(arr+1)); 
    return 0; 
} 

ich hoffe, dass dieser Code es klarer machen, haben einen Blick auf die Kommentare.

Answer 2

Es gibt drei Dinge, die die gleiche Adresse darstellt: array (die &array[0] zerfällt), array[0] (die &array[0][0] zerfällt) und &array.

Während diese drei Dinge in der gleichen Adresse resultiert, sie repräsentieren verschiedene Dinge, und haben daher verschiedene Arten.

Die Ausdrücke array und &array[0] haben den Typ char(*)[3].

Die Ausdrücke array[0] und &array[0][0] haben den Typ char*.

Schließlich hat der Ausdruck &array den Typ char(*)[3][3].

---

Es könnte einfacher sein, zu verstehen, wenn es ein wenig mehr „grafisch“ dargestellt:

Das Array, in Speicher, sieht so etwas wie dieses

 
+-----+-----+-----+-----+-----+-----+-----+-----+-----+ 
| 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 
+-----+-----+-----+-----+-----+-----+-----+-----+-----+ 

Wenn wir setzen in denen alle Zeiger wirklich verweisen wir

 
+-----+-----+-----+-----+-----+-----+-----+-----+-----+ 
| 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 
+-----+-----+-----+-----+-----+-----+-----+-----+-----+ 
^ ^  ^    ^    ^
|  |   |     |     | 
|  |   &array[1]   &array[2]   &array[3] 
|  |   |     |     | 
|  |   &array[1][0]  &array[2][0]  &array[3][0] 
|  |            | 
|  &array[0][1]         | 
|              | 
&array            (&array)[1] 
| 
&array[0] 
| 
&array[0][0] 

natürlich haben, array[3] ist ou t Grenzen, aber es kann verwendet werden, während über die Anordnung (en) mit Hilfe von Zeigern iteriert wird, um das Ende zu markieren (d. h. Sie iterieren, während der Zeiger weniger als z. &array[3][0])

Answer 3

Zuerst gibt es einen Fehler in Ihrer Deklaration, die Sie Punkt (.) Anstelle von Komma (,).

In C Arrays sind kontinuierlich gespeichert und "Array" ist die mnemonic hier also der Wert von Array und & Array [0] [0] ist gleich.

Answer 4

char array[3][3] = { 
     {'a','b','c'}, 
     {'d','e','f'}, 
     {'g','h','i'} 
     }; 

char *a = &array[0][0]; // compiles 
char (*b)[3] = array; // compiles 

char *c = array; // error 
char (*d)[3] = &array[0][0]; // error