Просмотр кода страницы cpp/language/array

У вас нет прав на выполнение действия «редактирование этой страницы» по следующей причине:
Запрошенное действие могут выполнять участники одной из следующих групп: Участники, Администраторы.
Вы можете просмотреть и скопировать исходный код этой страницы.
{{title|Объявление массива}}
{{cpp/language/declarations/navbar}}

Объявляет объект типа массив.

===Синтакс===
Объявление массива это любое простое объявление, у которого {{rlp|declarations|декларатор}} имеет форму

{{sdsc begin}}
{{sdsc|1=
{{spar|декларатор-не-указатель}} {{ttb|[}} {{spar optional|выражение}} {{ttb|]}} {{spar optional|атрибуты}}
}}
{{sdsc end}}

{{par begin}}
{{par|{{spar|декларатор-не-указатель}}|любой допустимый {{spar|декларатор}}, но если он начинается с {{tt|*}}, {{tt|&}} или {{tt|&&}}, он должен быть заключён в круглые скобки. }}
{{par|{{spar|выражение}}|{{rev inl|until=c++14|{{rlp|constant expression|целочисленное константное выражение}}}}{{rev inl|since=c++14|{{rlp|constant expression|преобразованное константное выражение}} типа {{lc|std::size_t}}}}, которое оценивается как значение больше нуля }}
{{par|{{spar|атрибуты}}|{{mark since c++11}} список {{rlp|attributes|атрибутов}} }}
{{par end}}

Объявление вида {{c|T a[N];}} объявляет {{c|a}} как {{rlp|object|объект}} массив, состоящий из {{c|N}} последовательно размещённых объектов типа {{tt|T}}. Элементы массива нумеруются {{c|0}}, …, {{c|N - 1}}, к ним можно получить доступ с помощью {{rlp|operator member access#Встроенный оператор индексации|оператора индексации operator []}}, например: {{c|a[0]}}, …, {{c|a[N - 1]}}.

Массивы могут быть созданы из любого {{rlp|types|фундаментального типа}} (за исключением {{c/core|void}}), {{rlp|pointer|указателя}}, {{rlp|pointer|указателей на элементы}}, {{rlp|classes|классов}}, {{rlp|enum|перечислений}} или из других массивов с известными границами (в этом случае массив называется многомерным). Другими словами, только объекты за исключением массивов с неизвестными границами могут быть элементами массивов. Массивы неполных типов также являются неполными типами.

{{rrev|начиная с=c++11|
{{rev inl|since=c++20|Возможно {{rlp|constraints|ограниченный}}}} спецификатор {{rlpt|auto}} может использоваться как тип элемента массива в объявлении указателя или ссылки на массив, которое выводит тип элемента из инициализатора{{rev inl|since=c++14| или аргумента функции}}, например {{c|1=auto (*p)[42] = &a;}} допустимо, если {{c|a}} являтся левосторонним значением типа {{c/core|int[42]}}.
}}

Не существует массивов ссылок или массивов функций.

Применение {{rlp|cv|cv-квалификаторов}} к массиву (через typedef или манипуляции с типом шаблона) применяет квалификаторы к типу элемента, но любой массив, элементы которого имеют cv-квалификацию, должен иметь такую-же cv-квалификацию.
{{source|1=
// a и b имеют одинаковую const-квалификацию типа "массив из 5 const char"

typedef const char CC;
CC a[5] = {}; 

typedef char CA[5];
const CA b = {};
}}

Когда используется вместе с {{rlp|new|выражением new[]}}, размер массива может быть нулевым; такой массив не имеет элементов:

{{source|1=
int* p = new int[0]; // доступ к p[0] или *p неопределён
delete[] p; // очистка всё равно требуется
}}

====Присваивание====
Массивы не могут быть изменены целиком: даже если они являются {{rlp|value category#lvalue|левосторонними значениями}} (например может быть взят адрес массива), они не могут присутствовать с левой стороны оператора присваивания:

{{source|1=
int a[3] = {1, 2, 3}, b[3] = {4, 5, 6};
int (*p)[3] = &a; // ok: адрес может быть взят
a = b;            // ошибка: a это массив

struct { int c[3]; } s1, s2 = {3, 4, 5};
s1 = s2; // ok: неявно определённый оператор присваивания копированием
         // может присваивать элементы данных массивов
}}

====Приведение массива к указателю====
Существует {{rlp|implicit conversion|неявное преобразование}} из левосторонних и правосторонних значений типа массивов к правосторонним значением типа указатель: оно создаёт указатель на первый элемент массива. Это преобразование используется всякий раз, когда массивы появляются в контексте, где массивы не ожидаются, а ожидаются указатели:

{{example|code=
#include <iostream>
#include <iterator>
#include <numeric>

void g(int (&a)[3])
{
    std::cout << a[0] << '\n';
}

void f(int* p)
{
    std::cout << *p << '\n';
}

int main()
{
    int a[3] = {1, 2, 3};
    int* p = a;

    std::cout << sizeof a << '\n'  // выводит размер массива
              << sizeof p << '\n'; // выводит размер указателя

    // когда доступны массивы, но не указатели, можно использовать только массивы
    g(a); // ok: функция принимает массив по ссылке
//  g(p); // ошибка

    for(int n: a)              // ok: массивы могут быть использованы в основанных
                               // на диапазоне циклах for
        std::cout << n << ' '; // выводит элементы массива
//  for(int n: p)              // ошибка
//      std::cout << n << ' ';

    std::iota(std::begin(a), std::end(a), 7); // ok: begin и end принимают массивы
//  std::iota(std::begin(p), std::end(p), 7); // ошибка

    // где указатели допустимы, а массивы нет, могут быть использованы как одни,
    // так и другие:
    f(a); // ok: функция принимает указатель
    f(p); // ok: функция принимает указатель

    std::cout << *a << '\n' // выводит первый элемент
              << *p << '\n' // так-же
              << *(a + 1) << ' ' << a[1] << '\n'  // выводит второй элемент
              << *(p + 1) << ' ' << p[1] << '\n'; // так-же
}
}}

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

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

Важно отметить, что когда применяется преобразование массива в указатель, многомерный массив преобразуется в указатель на его первый элемент (например, указатель на его первую строку или на его первую плоскость): преобразование массива в указатель применяется только один раз.

{{source|1=
int a[2];            // массив из 2-ух int
int* p1 = a;         // превращается в указатель на первый элемент массива

int b[2][3];         // массив из 2-ух массивов, в каждом из которых по 3 int
// int** p2 = b;     // ошибка: b не приводится к int**
int (*p2)[3] = b;    // b приводится к указателю на первую строку из 3-ёх элементов в b

int c[2][3][4];      // массив из 2-ух массивов, каждый из которых содержит 3 массива,
                     // содержащих 4 int
// int*** p3 = c;    // ошибка: c не приводится к int***
int (*p3)[3][4] = c; // c приводится к указателю на первую 3 × 4-элементную плоскость c
}}

====Массивы с неизвестными границами====
Если {{spar|выражение}} опущено в объявлении массива, объявляется "массив с неизвестными границами T", который является разновидностью {{rlp|incomplete_type|неполного типа}}, за исключением случаев, когда он используется в объявлении с {{rlp|aggregate_initialization|агрегатным инициализатором}}:

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

Поскольку элементы массива не могут быть массивами с неизвестными границами, многомерные массивы не могут иметь неизвестных границ в одном из измерений, отличном от первого:

{{source|1=
extern int a[][2]; // ok: массив с неизвестными границами, содержащий массивы из 2-ух int
extern int b[2][]; // ошибка: массив имеет неполный тип элементов
}}

Если существует предыдущее объявление сущности в той же области видимости, в которой была указана граница, опущенная граница массива считается такой же, как в этом более раннем объявлении, и аналогично для определения статического элемента данных класса:

{{source|1=
extern int x[10];
struct S
{
    static int y[10];
};

int x[];               // OK: граница равна 10
int S::y[];            // OK: граница равна 10

void f()
{
    extern int x[];
    int i = sizeof(x); // ошибка: неполный тип объекта
}
}}

Ссылки и указатели на массивы с неизвестными границами могут быть сформированы, {{rev inl|until=c++20|но не}}{{rev inl|since=c++20|и могут}} могут быть инициализированы или присвоены из массивов и указателей на массивы с известными границами. Нужно заметить, что в языке программирования C  указатели на массивы с неизвестными границами совместимы с указателями на массивы с известными границами и, таким образом, могут быть преобразованы и присвоены в обоих направлениях.

{{source|1=
extern int a1[];
int (&r1)[] = a1;  // ok
int (*p1)[] = &a1; // ok
int (*q)[2] = &a1; // ошибка (но ok в C)

int a2[] = {1, 2, 3};
int (&r2)[] = a2;  // ok (начиная с C++20)
int (*p2)[] = &a2; // ok (начиная с C++20)
}}

Указатели на массивы с неизвестными границами не могут участвовать в {{rlp|operator_arithmetic#Аддитивные операции|арифметике указателей}} и не могут быть использованы в левой части {{rlp|operator_member_access#Встроенный оператор индексации|оператора индексации}}, но могут быть разыменованы.

====Массив значений rvalue====
Несмотря на то, что массивы не могут быть возвращены из функций по значению и не могут быть целью преобразований, массив значений {{rlp|value category|prvalue}} может быть сформирован с использованием псевдонима типа для создания временного массива, используя {{rlp|explicit_cast|функциональное приведение, инициализированное скобками}}.
{{rrev|since=c++17|
Как и значения prvalue класса, значения prvalue массива преобразуются в значения xvalue с помощью {{rlp|implicit_conversion#Временная материализация|временной материализации}} при вычислении.
}}

Массив значений {{rlp|value category|xvalue}} может быть сформирован напрямую с помощью доступа к элементу массива правостороннего значения класса или используя {{lc|std::move}} или иное преобразование или вызов функции, которая возвращает ссылку на правостороннее значение.

{{example|code=
#include <iostream>
#include <type_traits>
#include <utility>

void f(int (&&x)[2][3])
{
    std::cout << sizeof x << '\n';
}

struct X
{
    int i[2][3];
} x;

template<typename T> using identity = T;

int main()
{
    std::cout << sizeof X().i << '\n';           // размер массива
    f(X().i);                                    // ok: привязка к xvalue
//  f(x.i);                                      // ошибка: не может быть привязано
                                                 // к левостороннему значению

    int a[2][3];
    f(std::move(a));                             // ok: привязка к xvalue

    using arr_t = int[2][3];
    f(arr_t{});                                  // ok: привязка к чистому
                                                 // правостороннему значению
    f(identity<int[][3]>{{1, 2, 3}, {4, 5, 6}}); // ok: привязка к чистому
                                                 // правостороннему значению

}
| output=
24
24
24
24
24
}}

===Отчёты о дефектах===
{{dr list begin}}
{{dr list item|wg=cwg|dr=393|std=C++98|before=указатель или ссылка на массив с неизвестными границами не могут быть<br>параметром функции|after=могут}}
{{dr list item|wg=cwg|dr=619|std=C++98|before=если она опущена, граница массива не может быть выведена из<br>предыдущего объявления|after=вывод разрешён}}
{{dr list item|wg=cwg|dr=2099|std=C++98|before=граница массива статических элементов данных не может быть опущена,<br>даже если предоставлен инициализатор|after=пропуск позволен}}
{{dr list item|wg=cwg|dr=2397|std=C++11|before={{c/core|auto}} нельзя использовать в качестве типа элемента|after=можно}}
{{dr list end}}

===Смотри также===
{{dsc begin}}
{{dsc see c|c/language/array|Объявление массива| nomono=true}}
{{dsc end}}

{{langlinks|en|es|ja|zh}}
Шаблоны, используемые на этой странице:
cppreference.com

Поиск

Пространства имён

Варианты

Просмотры

Действия

Просмотр кода страницы cpp/language/array
