Array declaration

Массив — это тип, состоящий из непрерывно выделенной непустой последовательности объектов с определённым типом элементов . Количество этих объектов (размер массива) никогда не меняется в течение времени жизни массива.

Синтаксис

В грамматике объявлений объявления массива, type-specifier последовательность обозначает element type (который должен быть полным типом объекта), а declarator имеет форму:

float fa[11], *afp[17]; // fa - это массив из 11 элементов типа float
                        // afp - это массив из 17 указателей на float

Объяснение

Существует несколько разновидностей массивов: массивы известного постоянного размера, массивы переменной длины и массивы неизвестного размера.

Массивы постоянного известного размера

Если expression в деклараторе массива является целочисленным константным выражением со значением больше нуля и тип элемента является типом с известным постоянным размером (то есть элементы не являются VLA) (начиная с C99) , тогда декларатор объявляет массив постоянного известного размера:

int n[10]; // целочисленные константы являются константными выражениями
char o[sizeof(double)]; // sizeof является константным выражением
enum { MAX_SZ=100 };
int n[MAX_SZ]; // константы перечисления являются константными выражениями

Массивы постоянного известного размера могут использовать инициализаторы массивов для предоставления их начальных значений:

int a[5] = {1,2,3}; // объявляет int[5] инициализированный значениями 1,2,3,0,0
char str[] = "abc"; // объявляет char[4] инициализированный значениями 'a','b','c','\0'

void fadd(double a[static 10], const double b[static 10])
{
    for (int i = 0; i < 10; i++)
    {
        if (a[i] < 0.0) return;
        a[i] += b[i];
    }
}
// вызов fadd может выполнять проверку границ во время компиляции
// а также позволяет оптимизации, такие как предварительная выборка 10 чисел double
int main(void)
{
    double a[10] = {0}, b[20] = {0};
    fadd(a, b); // OK
    double x[5] = {0};
    fadd(x, b); // неопределенное поведение: аргумент-массив слишком мал
}

int f(const int a[20])
{
    // в этой функции a имеет тип const int* (указатель на const int)
}
int g(const int a[const 20])
{
    // в этой функции a имеет тип const int* const (константный указатель на const int)
}

void fadd(double a[static restrict 10],
          const double b[static restrict 10])
{
    for (int i = 0; i < 10; i++) // цикл может быть развернут и переупорядочен
    {
        if (a[i] < 0.0)
            break;
        a[i] += b[i];
    }
}

#include <stdio.h>
int main(void)
{
   int n = 1;
label:;
   int a[n]; // re-allocated 10 times, each with a different size
   printf("The array has %zu elements\n", sizeof a / sizeof *a);
   if (n++ < 10)
       goto label; // leaving the scope of a VLA ends its lifetime
}

void foo(size_t x, int a[*]);
void foo(size_t x, int a[x])
{
    printf("%zu\n", sizeof a); // то же самое, что sizeof(int*)
}

extern int n;
int A[n];            // Ошибка: VLA в области видимости файла
extern int (*p2)[n]; // Ошибка: VM в области видимости файла
int B[100];          // OK: массив в области видимости файла с известным постоянным размером
void fvla(int m, int C[m][m]); // OK: VLA в области видимости прототипа

void fvla(int m, int C[m][m]) // OK: указатель с областью видимости блока/автоматической длительностью на VLA
{
    typedef int VLA[m][m]; // OK: VLA с областью видимости блока
    int D[m];              // OK: VLA с областью видимости блока/автоматической длительностью
//  static int E[m]; // Ошибка: VLA со статической длительностью
//  extern int F[m]; // Ошибка: VLA с линковкой
    int (*s)[m];     // OK: VM с областью видимости блока/автоматической длительностью
    s = malloc(m * sizeof(int)); // OK: s указывает на VLA в выделенной памяти
//  extern int (*r)[m]; // Ошибка: VM с линковкой
    static int (*q)[m] = &B; // OK: VM с областью видимости блока/статической длительностью
}

struct tag
{
    int z[n]; // Ошибка: член структуры VLA
    int (*y)[n]; // Ошибка: член структуры VM
};

Массивы неизвестного размера

Если выражение в деклараторе массива опущено, он объявляет массив неизвестного размера. За исключением списков параметров функций (где такие массивы преобразуются в указатели) и случаев, когда доступен инициализатор , такой тип является неполным типом (обратите внимание, что VLA неопределенного размера, объявленный с * в качестве размера, является полным типом) (начиная с C99) :

extern int x[]; // тип x - "массив int неизвестного размера"
int a[] = {1,2,3}; // тип a - "массив из 3 int"

struct s { int n; double d[]; }; // s.d is a flexible array member
struct s *s1 = malloc(sizeof (struct s) + (sizeof (double) * 8)); // as if d was double d[8]

Квалификаторы

typedef int A[2][3];
const A a = {{4, 5, 6}, {7, 8, 9}}; // массив массивов константных int
int* pi = a[0]; // Ошибка: a[0] имеет тип const int*
void* unqual_ptr = a; // OK до C23; ошибка начиная с C23
// Примечание: clang применяет правило из C++/C23 даже в режимах C89-C17

typedef int A[2];
// _Atomic A a0 = {0};    // Ошибка
// _Atomic(A) a1 = {0};   // Ошибка
_Atomic int a2[2] = {0};  // OK
_Atomic(int) a3[2] = {0}; // OK

Присваивание

Объекты типа массива не являются изменяемыми lvalue , и хотя их адрес может быть получен, они не могут находиться в левой части оператора присваивания. Однако структуры с элементами-массивами являются изменяемыми lvalue и могут быть присвоены:

int a[3] = {1,2,3}, b[3] = {4,5,6};
int (*p)[3] = &a; // корректно, можно взять адрес a
// a = b;            // ошибка, a является массивом
struct { int c[3]; } s1, s2 = {3,4,5};
s1 = s2; // корректно: можно присваивать структуры, содержащие члены-массивы

Преобразование массива в указатель

Любое lvalue-выражение массива, используемое в любом контексте, кроме

• в качестве операнда оператора взятия адреса
• в качестве операнда sizeof
• в качестве операнда typeof и typeof_unqual (начиная с C23)
• в качестве строкового литерала для инициализации массива

подвергается неявному преобразованию в указатель на свой первый элемент. Результат не является lvalue.

Если массив был объявлен register , поведение программы, которая пытается выполнить такое преобразование, не определено.

int a[3] = {1,2,3};
int* p = a;
printf("%zu\n", sizeof a); // выводит размер массива
printf("%zu\n", sizeof p); // выводит размер указателя

Когда тип массива используется в списке параметров функции, он преобразуется в соответствующий тип указателя: int f ( int a [ 2 ] ) и int f ( int * a ) объявляют одну и ту же функцию. Поскольку фактический тип параметра функции является типом указателя, вызов функции с аргументом массива выполняет преобразование массива в указатель; размер массива-аргумента недоступен вызываемой функции и должен быть передан явно:

#include <stdio.h>
void f(int a[], int sz) // фактически объявляет void f(int* a, int sz)
{
    for (int i = 0; i < sz; ++i)
        printf("%d\n", a[i]);
}
void g(int (*a)[10]) // параметр указателя на массив не преобразуется
{
    for (int i = 0; i < 10; ++i)
        printf("%d\n", (*a)[i]);
}
int main(void)
{
    int a[10] = {0};
    f(a, 10); // преобразует a в int*, передает указатель
    g(&a);    // передает указатель на массив (не нужно передавать размер)
}

Многомерные массивы

Когда тип элемента массива сам является массивом, говорят, что массив многомерный:

// массив из 2 массивов по 3 int каждый
int a[2][3] = {{1,2,3},  // может рассматриваться как матрица 2x3
               {4,5,6}}; // с построчным расположением элементов

Обратите внимание, что при применении преобразования массива в указатель многомерный массив преобразуется в указатель на свой первый элемент, например, указатель на первую строку:

int a[2][3]; // матрица 2x3
int (*p1)[3] = a; // указатель на первую строку из 3 элементов
int b[3][3][3]; // куб 3x3x3
int (*p2)[3][3] = b; // указатель на первую плоскость 3x3

int n = 10;
int a[n][2*n];

Примечания

Объявления массивов нулевой длины не разрешены, даже несмотря на то, что некоторые компиляторы предоставляют их в качестве расширений (обычно в качестве реализации гибких элементов массива до стандарта C99).

Если выражение размера expression VLA имеет побочные эффекты, они гарантированно выполняются, за исключением случаев, когда оно является частью выражения sizeof, результат которого от него не зависит:

int n = 5, m = 5;
size_t sz = sizeof(int (*[n++])[m++]); // n инкрементируется, m может быть инкрементировано или нет

Ссылки

Смотрите также