Массивы (C++)
Массив представляет собой последовательность объектов того же типа, которые занимают непрерывную область памяти. Традиционные массивы стилей C являются источником многих ошибок, но по-прежнему распространены, особенно в старых базах кода. В современном C++настоятельно рекомендуется использовать std::vector или std::array вместо массивов стилей C, описанных в этом разделе. Оба этих стандартных типов библиотек хранят их элементы в виде непрерывного блока памяти. Однако они обеспечивают большую безопасность типов и поддерживают итераторы, которые гарантированно указывают на допустимое расположение в последовательности. Дополнительные сведения см. в разделе "Контейнеры".
Объявления стека
В объявлении массива C++ размер массива указывается после имени переменной, а не после имени типа, как в других языках. В следующем примере объявляется массив из 1000 двойных размеров, выделенных в стеке. Число элементов должно быть предоставлено в виде целочисленного литерала или в качестве константного выражения. Это связано с тем, что компилятор должен знать, сколько пространства стека следует выделить; он не может использовать значение, вычисляемое во время выполнения. Каждому элементу в массиве присваивается значение по умолчанию 0. Если вы не назначаете значение по умолчанию, каждый элемент изначально содержит все случайные значения в этом расположении памяти.
constexpr size_t size = 1000;
// Declare an array of doubles to be allocated on the stack
double numbers[size] {0};
// Assign a new value to the first element
numbers[0] = 1;
// Assign a value to each subsequent element
// (numbers[1] is the second element in the array.)
for (size_t i = 1; i < size; i++)
{
numbers[i] = numbers[i-1] * 1.1;
}
// Access each element
for (size_t i = 0; i < size; i++)
{
std::cout << numbers[i] << " ";
}
Первый элемент в массиве — это нулевой элемент. Последний элемент — это элемент (n-1), где n — это количество элементов, которые может содержать массив. Число элементов в объявлении должно иметь целочисленный тип и должно быть больше 0. Вы несете ответственность за то, чтобы программа никогда не передает значение оператору подстрока, который больше (size - 1).
Массив нулевого размера является законным только в том случае, если массив является последним полем в списке struct или union когда расширения Майкрософт включены (/Za или /permissive- не заданы).
Массивы на основе стека быстрее выделяют и получают доступ, чем массивы на основе кучи. Однако пространство стека ограничено. Количество элементов массива не может быть таким большим, что использует слишком много памяти стека. Сколько слишком много зависит от вашей программы. Средства профилирования можно использовать для определения того, слишком ли большой массив.
Объявления кучи
Может потребоваться слишком большой массив для выделения в стеке или размер которого не известен во время компиляции. Этот массив можно выделить в куче с помощью new[] выражения. Оператор возвращает указатель на первый элемент. Оператор подстрока работает с переменной указателя так же, как и в массиве на основе стека. Вы также можете использовать арифметику указателя для перемещения указателя на любые произвольные элементы в массиве. Это ваша ответственность за обеспечение того, чтобы:
- Вы всегда храните копию исходного адреса указателя, чтобы можно было удалить память, если массив больше не нужен.
- Вы не увеличиваете или уменьшаете адрес указателя в пределах массива.
В следующем примере показано, как определить массив в куче во время выполнения. В нем показано, как получить доступ к элементам массива с помощью оператора подстрочного и с помощью арифметики указателя:
void do_something(size_t size)
{
// Declare an array of doubles to be allocated on the heap
double* numbers = new double[size]{ 0 };
// Assign a new value to the first element
numbers[0] = 1;
// Assign a value to each subsequent element
// (numbers[1] is the second element in the array.)
for (size_t i = 1; i < size; i++)
{
numbers[i] = numbers[i - 1] * 1.1;
}
// Access each element with subscript operator
for (size_t i = 0; i < size; i++)
{
std::cout << numbers[i] << " ";
}
// Access each element with pointer arithmetic
// Use a copy of the pointer for iterating
double* p = numbers;
for (size_t i = 0; i < size; i++)
{
// Dereference the pointer, then increment it
std::cout << *p++ << " ";
}
// Alternate method:
// Reset p to numbers[0]:
p = numbers;
// Use address of pointer to compute bounds.
// The compiler computes size as the number
// of elements * (bytes per element).
while (p < (numbers + size))
{
// Dereference the pointer, then increment it
std::cout << *p++ << " ";
}
delete[] numbers; // don't forget to do this!
}
int main()
{
do_something(108);
}
Инициализация массивов
Вы можете инициализировать массив в цикле, один элемент за раз или в одной инструкции. Содержимое следующих двух массивов идентичны:
int a[10];
for (int i = 0; i < 10; ++i)
{
a[i] = i + 1;
}
int b[10]{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
Передача массивов в функции
Когда массив передается функции, он передается в качестве указателя на первый элемент, будь то массив на основе стека или кучи. Указатель не содержит других сведений о размере или типе. Это поведение называется разложением указателя. При передаче массива функции всегда необходимо указать количество элементов в отдельном параметре. Это также означает, что элементы массива не копируются при передаче массива функции. Чтобы предотвратить изменение элементов функции, укажите параметр в качестве указателя на const элементы.
В следующем примере показана функция, которая принимает массив и длину. Указатель указывает на исходный массив, а не копию. Так как параметр не constявляется, функция может изменять элементы массива.
void process(double *p, const size_t len)
{
std::cout << "process:\n";
for (size_t i = 0; i < len; ++i)
{
// do something with p[i]
}
}
Объявите и определите параметр p массива, const чтобы сделать его доступным только для чтения в блоке функций:
void process(const double *p, const size_t len);
Эта же функция также может быть объявлена таким образом без изменений в поведении. Массив по-прежнему передается в качестве указателя на первый элемент:
// Unsized array
void process(const double p[], const size_t len);
// Fixed-size array. Length must still be specified explicitly.
void process(const double p[1000], const size_t len);
Многомерные массивы
Массивы, созданные из других массивов, являются многомерными. Такие многомерные массивы определяются путем последовательного размещения нескольких константных выражений, заключенных в квадратные скобки. Рассмотрим, например, следующее объявление:
int i2[5][7];
Он задает массив типа int, концептуально упорядоченный в двухмерной матрице из пяти строк и семи столбцов, как показано на следующем рисунке:
Изображение представляет собой сетку 7 ячеек, широких и 5 ячеек. Каждая ячейка содержит индекс ячейки. Первый индекс ячейки помечен как 0,0. Следующая ячейка в этой строке составляет 0,1 и т. д. до последней ячейки в этой строке, которая составляет 0,6. Следующая строка начинается с индекса 1,0. После этого ячейка имеет индекс 1,1. Последняя ячейка в этой строке — 1,6. Этот шаблон повторяется до последней строки, которая начинается с индекса 4,0. Последняя ячейка в последней строке имеет индекс 4,6. :::image-end
Можно объявить многомерные массивы с списком инициализаторов (как описано в инициализаторах). В этих объявлениях константное выражение, указывающее границы для первого измерения, может быть опущено. Например:
// arrays2.cpp
// compile with: /c
const int cMarkets = 4;
// Declare a float that represents the transportation costs.
double TransportCosts[][cMarkets] = {
{ 32.19, 47.29, 31.99, 19.11 },
{ 11.29, 22.49, 33.47, 17.29 },
{ 41.97, 22.09, 9.76, 22.55 }
};
В показанном выше объявлении определяется массив, состоящий из трех строк и четырех столбцов. Строки представляют фабрики, а столбцы — рынки, на которые фабрики поставляют свою продукцию. Значения — это стоимости транспортировки с фабрик на рынки. Первое измерение массива опущено, но компилятор заполняет его, проверяя инициализатор.
Использование оператора непрямого выражения (*) в типе массива n-1 приводит к получению массива n-1. Если значение n равно 1, возвращается скалярный элемент (или элемент массива).
Массивы C++ размещаются в памяти по срокам. Построчный порядок означает, что быстрее всего изменяется последний индекс.
Пример
Вы также можете опустить спецификацию границ для первого измерения многомерного массива в объявлениях функций, как показано ниже:
// multidimensional_arrays.cpp
// compile with: /EHsc
// arguments: 3
#include <limits> // Includes DBL_MAX
#include <iostream>
const int cMkts = 4, cFacts = 2;
// Declare a float that represents the transportation costs
double TransportCosts[][cMkts] = {
{ 32.19, 47.29, 31.99, 19.11 },
{ 11.29, 22.49, 33.47, 17.29 },
{ 41.97, 22.09, 9.76, 22.55 }
};
// Calculate size of unspecified dimension
const int cFactories = sizeof TransportCosts /
sizeof( double[cMkts] );
double FindMinToMkt( int Mkt, double myTransportCosts[][cMkts], int mycFacts);
using namespace std;
int main( int argc, char *argv[] ) {
double MinCost;
if (argv[1] == 0) {
cout << "You must specify the number of markets." << endl;
exit(0);
}
MinCost = FindMinToMkt( *argv[1] - '0', TransportCosts, cFacts);
cout << "The minimum cost to Market " << argv[1] << " is: "
<< MinCost << "\n";
}
double FindMinToMkt(int Mkt, double myTransportCosts[][cMkts], int mycFacts) {
double MinCost = DBL_MAX;
for( size_t i = 0; i < cFacts; ++i )
MinCost = (MinCost < TransportCosts[i][Mkt]) ?
MinCost : TransportCosts[i][Mkt];
return MinCost;
}
The minimum cost to Market 3 is: 17.29
Функция FindMinToMkt записывается таким образом, что добавление новых фабрик не требует изменений кода, просто перекомпиляции.
Инициализация массивов
Массивы объектов с конструктором классов инициализированы конструктором. Если в списке инициализатора меньше элементов в массиве, конструктор по умолчанию используется для остальных элементов. Если конструктор по умолчанию не определен для класса, список инициализаторов должен быть завершен, то есть должен быть один инициализатор для каждого элемента в массиве.
Рассмотрим класс Point, определяющий два конструктора:
// initializing_arrays1.cpp
class Point
{
public:
Point() // Default constructor.
{
}
Point( int, int ) // Construct from two ints
{
}
};
// An array of Point objects can be declared as follows:
Point aPoint[3] = {
Point( 3, 3 ) // Use int, int constructor.
};
int main()
{
}
Первый элемент aPoint создается с помощью конструктора Point( int, int ), а оставшиеся два элемента — с помощью конструктора по умолчанию.
Массивы статических элементов (независимо от того, можно ли const ) инициализировать в их определениях (за пределами объявления класса). Например:
// initializing_arrays2.cpp
class WindowColors
{
public:
static const char *rgszWindowPartList[7];
};
const char *WindowColors::rgszWindowPartList[7] = {
"Active Title Bar", "Inactive Title Bar", "Title Bar Text",
"Menu Bar", "Menu Bar Text", "Window Background", "Frame" };
int main()
{
}
Доступ к элементам массива
К отдельным элементам массива можно обращаться при помощи оператора индекса массива ([ ]). Если вы используете имя одномерного массива без подстрока, он оценивается как указатель на первый элемент массива.
// using_arrays.cpp
int main() {
char chArray[10];
char *pch = chArray; // Evaluates to a pointer to the first element.
char ch = chArray[0]; // Evaluates to the value of the first element.
ch = chArray[3]; // Evaluates to the value of the fourth element.
}
Если используются многомерные массивы, в выражениях можно использовать различные сочетания.
// using_arrays_2.cpp
// compile with: /EHsc /W1
#include <iostream>
using namespace std;
int main() {
double multi[4][4][3]; // Declare the array.
double (*p2multi)[3];
double (*p1multi);
cout << multi[3][2][2] << "\n"; // C4700 Use three subscripts.
p2multi = multi[3]; // Make p2multi point to
// fourth "plane" of multi.
p1multi = multi[3][2]; // Make p1multi point to
// fourth plane, third row
// of multi.
}
В приведенном выше коде multi представляет собой трехмерный массив типа double. Указатель p2multi указывает на массив типа double размера три. В этом примере массив используется с одним, двумя и тремя индексами. Хотя в инструкции чаще всего указываются все подстроки, как и в cout инструкции, иногда полезно выбрать определенное подмножество элементов массива, как показано в приведенных ниже coutинструкциях.
Оператор перегрузки подстрока
Как и другие операторы, оператор подстрочного ([]) может быть переопределен пользователем. Поведение оператора индекса по умолчанию, если он не перегружен, — совмещать имя массива и индекс с помощью следующего метода.
*((array_name) + (subscript))
Как и во всех дополнениях, включающих типы указателей, масштабирование выполняется автоматически, чтобы настроить размер типа. Результирующий значение не является n байтами из источника array_name; вместо этого это n-йэлемент массива. Дополнительные сведения об этом преобразовании см. в разделе "Адитивные операторы".
Аналогично, для многомерных массивов адрес извлекается с использованием следующего метода.
((array_name) + (subscript1 * max2 * max3 * ... * maxn) + (subscript2 * max3 * ... * maxn) + ... + subscriptn))
Массивы в выражениях
Если идентификатор типа массива отображается в выражении, отличном от sizeofадреса (&) или инициализации ссылки, он преобразуется в указатель на первый элемент массива. Например:
char szError1[] = "Error: Disk drive not ready.";
char *psz = szError1;
Указатель psz указывает на первый элемент массива szError1. Массивы, в отличие от указателей, не изменяются l-значения. Вот почему следующее назначение является незаконным:
szError1 = psz;
См. также
Обратная связь
Ожидается в ближайшее время: в течение 2024 года мы постепенно откажемся от GitHub Issues как механизма обратной связи для контента и заменим его новой системой обратной связи. Дополнительные сведения см. в разделе https://aka.ms/ContentUserFeedback.
Отправить и просмотреть отзыв по