Czy macierz int macie [5] [5] to samo co int **? [duplikat] - c

Proste tablice 1-wymiarowe są uważane za wskaźnik, ale czy dotyczy to również matrycy?

Jednak sześcian int[5][5][5] byłoby również uważane za int *** ?

Odpowiedzi:

10 dla odpowiedzi № 1

Nie, wskaźnik do wskaźnika do liczby całkowitej nie jest taki sam jak tablica tablic liczb całkowitych.

Pomyśl, jak wyglądałyby w pamięci.

Tablica tablic (np. int a[2][2]):

+ --------- + --------- + --------- + --------- + | a [0] [0] | a [0] [1] | a [1] [0] | a [1] [1] | + --------- + --------- + --------- + --------- +

Wskaźnik do wskaźnika (np. int **a):

+ ------ + ------ + ------ + | a [0] | a [1] | … | + ------ + ------ + ------ + | | | v | + --------- + --------- + --------- + | | A [1] [0] | a [1] [1] | ....... | | + --------- + --------- + --------- + v + --------- + --------- + --------- + | A [0] [0] | a [0] [1] | ....... | + --------- + --------- + --------- +

---

3 dla odpowiedzi № 2

Nie oni nie są. Weźmy na przykład dwie deklaracje podane poniżej.

int c[5][5][5];
int ***d;

Dla pierwszej deklaracji zapotrzebowanie na pamięć wynosi 125 X 4 = 500 bajtów.

Gdzie, jak w przypadku drugiej deklaracji, zapotrzebowanie na pamięć wynosi zaledwie 4 bajty. Dla wielu praktycznych celów możemy zamieniać tablicę i wskaźnik, ale nie są one takie same.

---

2 dla odpowiedzi nr 3

Oczywiście, że nie. Tablica liczb całkowitych różni się od wskaźnika do wskaźnika do liczby całkowitej. Tablica to zbiór podobnych elementów danych przechowywanych w ciągłej lokalizacji w pamięci. Ale wskaźnik do wskaźnika do liczb całkowitych nie jest.

int a[5][5];

W tej deklaracji przydzieli on ciągłą lokalizację pamięci dla wszystkich elementów. powiedzmy, że początkowa lokalizacja pamięci to 1000.

array  starting   array elements
address
a[0]--> 1000 --> a[0][0] a[0][1] ... a[0][4]
a[1]--> 1020 --> a[1][0] a[1][1] ... a[1][4]
a[2]--> 1040 --> a[2][0] a[2][1] ... a[2][4]
a[3]--> 1060 --> a[3][0] a[3][1] ... a[3][4]
a[4]--> 1080 --> a[4][0] a[4][1] ... a[4][4]

Ale kiedy masz wskaźnik od wskaźnika do liczby całkowitej w ten sposób -

int **a;

kiedy przydzielisz do tego pamięć

array --> a[0] a[1] a[2] a[3] a[4]
address > 1000 1004 1008 1012 1016 // address of array which points to some other location

Zostaną przydzielone ciągłe lokalizacje pamięci. ale każda tablica wskazuje / przechowuje inną lokalizację pamięci dla elementów.

array"s  array  element"s   array elements
address         address
1000 --> a[0]--> 2000 --> a[0][0] a[0][1] ... a[0][4]
1004 --> a[1]--> 3000 --> a[1][0] a[1][1] ... a[1][4]
1008 --> a[2]--> 4000 --> a[2][0] a[2][1] ... a[2][4]
1012 --> a[3]--> 5000 --> a[3][0] a[3][1] ... a[3][4]
1016 --> a[4]--> 6000 --> a[4][0] a[4][1] ... a[4][4]

Tablice te przechowują adres początkowy swoich elementów w różnych lokalizacjach.

---