W C, są tablice wskaźniki lub używane jako wskaźniki?

Oto dokładny język ze standardu C ( n1256):

6.3.2.1 Lvalues, arrays, and function designators
...
3 z wyjątkiem sytuacji, gdy jest operandem operatora sizeof lub operatora jednoargumentowego &, lub jest ciągiem literalnym używanym do inicjalizacji tablicy, wyrażenie, które ma typ "array of type" jest konwertowane do wyrażenia z typem " pointer to type", które wskazuje na początkowy element obiektu array i nie jest lvalue. Jeśli obiekt array posiada klasę register storage, zachowanie jest niezdefiniowane.

Ważną rzeczą do zapamiętania jest to, że istnieje różnica między obiektem (w języku C, co oznacza coś, co zajmuje pamięć) a wyrażeniem używanym do odniesienia się do tego obiektu.

Gdy zadeklarujesz tablicę taką jak

int a[10];

Obiekt wyznaczony przez wyrażenie a jest tablicą (tzn. sąsiadującym blokiem pamięci jest wystarczająco duży, aby pomieścić 10 int wartości), a typ wyrażenia a to " 10-elementowa tablica int" lub int [10]. Jeśli wyrażenie a pojawia się w kontekście innym niż operand operatorów sizeof lub &, wtedy jego typ jest domyślnie konwertowany na int *, a jego wartością jest adres pierwszego elementu.

W przypadku operatora sizeof, jeśli operand jest wyrażeniem typu T [N], to wynikiem jest liczba bajtów w obiekt array, a nie wskaźnik do tego obiektu: N * sizeof T.

W przypadku operatora & wartością jest adres tablicy, który jest taki sam jak adres pierwszego elementu tablicy, ale typ wyrażenia jest inny: biorąc pod uwagę deklarację T a[N];, typ wyrażenia &a to T (*)[N], lub wskaźnik do tablicy N-elementowej T. wartość jest taka sama jak a lub &a[0] (adres tablicy jest taki sam jak adres pierwszy element w tablicy), ale różnica typów ma znaczenie. Na przykład, biorąc pod uwagę kod

int a[10];
int *p = a;
int (*ap)[10] = &a;

printf("p = %p, ap = %p\n", (void *) p, (void *) ap);
p++;
ap++;
printf("p = %p, ap = %p\n", (void *) p, (void *) ap);

Zobaczysz wynik w kolejności

p = 0xbff11e58, ap = 0xbff11e58
p = 0xbff11e5c, ap = 0xbff11e80

IOW, advancing p dodaje sizeof int (4) do pierwotnej wartości, podczas gdy advancing ap dodaje 10 * sizeof int (40).

Bardziej standardowy język:

6.5.2.1 array subscripting

ograniczenia

1 jedno z wyrażeń ma typ " wskaźnik do obiektu typ ", inne wyrażenie ma typ integer, a wynik ma typ " type ".

semantyka

2 wyrażenie postfix, po którym następuje wyrażenie w nawiasach kwadratowych [] jest podpisanym oznaczeniem elementu obiektu array. Definicja operatora indeksu dolnego [] jest taka, że E1[E2] jest identyczny z (*((E1)+(E2))). Ze względu na reguły konwersji, które mają zastosowanie do operatora binarnego +, jeśli E1 jest obiektem tablicy (równoważnie wskaźnikiem do element początkowy obiektu tablicy) i E2 jest liczbą całkowitą, E1[E2] wyznacza E2 - ten element E1 (licząc od zera).

Tak więc, kiedy indeksujesz wyrażenie tablicy, to pod maską dzieje się to, że przesunięcie od adresu pierwszego elementu tablicy jest obliczane, a wynik jest dereferowany. Wyrażenie

a[i] = 10;

Jest równoważne

*((a)+(i)) = 10;

Co jest równoważne

*((i)+(a)) = 10;

Co jest równoważne do

 i[a] = 10;

Tak, zapisywanie tablicy w C jest przemienne; na miłość boską, nigdy nie rób tego w kodzie produkcyjnym.

Ponieważ array subscripting jest zdefiniowany w kategoriach operacji wskaźnika, można zastosować operator indeksu do wyrażeń typu wskaźnika oraz typu tablicy:

int *p = malloc(sizeof *p * 10);
int i;
for (i = 0; i < 10; i++)
  p[i] = some_initial_value(); 

Declaration: T a[N];

Expression    Type    Converts to     Value
----------    ----    ------------    -----
         a    T [N]   T *             Address of the first element in a;
                                        identical to writing &a[0]
        &a    T (*)[N]                Address of the array; value is the same
                                        as above, but the type is different
  sizeof a    size_t                  Number of bytes contained in the array
                                        object (N * sizeof T)
        *a    T                       Value at a[0]
      a[i]    T                       Value at a[i]
     &a[i]    T *                     Address of a[i] 

Declaration: T a[N][M];

Expression     Type        Converts to     Value
----------     ----        ------------    -----
          a    T [N][M]    T (*)[M]        Address of the first subarray (&a[0])
         &a    T (*)[N][M]                 Address of the array (same value as
                                             above, but different type)
   sizeof a    size_t                      Number of bytes contained in the
                                             array object (N * M * sizeof T)
         *a    T [M]      T *              Value of a[0], which is the address
                                             of the first element of the first subarray
                                             (same as &a[0][0])
       a[i]    T [M]      T *              Value of a[i], which is the address
                                             of the first element of the i'th subarray
      &a[i]    T (*)[M]                    Address of the i-th subarray; same value as
                                             above, but different type
sizeof a[i]    size_t                      Number of bytes contained in the i'th subarray
                                             object (M * sizeof T)
      *a[i]    T                           Value of the first element of the i'th 
                                             subarray (a[i][0])
    a[i][j]    T                           Value at a[i][j]
   &a[i][j]    T *                         Address of a[i][j]

Declaration: T a[N][M][O];

Expression        Type             Converts to
----------        ----             -----------
         a        T [N][M][O]      T (*)[M][O]
        &a        T (*)[N][M][O]
        *a        T [M][O]         T (*)[O]
      a[i]        T [M][O]         T (*)[O]
     &a[i]        T (*)[M][O]
     *a[i]        T [O]            T *
   a[i][j]        T [O]            T *
  &a[i][j]        T (*)[O]
  *a[i][j]        T 
a[i][j][k]        T

Stąd wzór dla tablic wyższych wymiarów powinien być jasny.

Tak więc w podsumowaniu: tablice nie są wskaźnikami. W większości kontekstów wyrażenia array są konwertowane na typy wskaźników.