Объект array (массив)

Введение в std::array

Представленный в C++11, std::array — это фиксированный массив, который не распадается в указатель при передаче в функцию. std::array определяется в заголовочном файле array, внутри пространства имен std. Объявление переменной std::array следующее:

#include <array>

std::array<int, 4> myarray; // объявляем массив типа int длиной 4

Подобно обычным фиксированным массивам, длина std::array должна быть установлена во время компиляции. std::array можно инициализировать с использованием списка инициализаторов или :

std::array<int, 4> myarray = { 8, 6, 4, 1 }; // список инициализаторов
std::array<int, 4> myarray2 { 8, 6, 4, 1 }; // uniform-инициализация

В отличие от стандартных фиксированных массивов, в std::array вы не можете пропустить (не указывать) длину массива:

std::array<int, > myarray = { 8, 6, 4, 1 }; // нельзя, должна быть указана длина массива

Также можно присваивать значения массиву с помощью списка инициализаторов:

std::array<int, 4> myarray;
myarray = { 0, 1, 2, 3 }; // ок
myarray = { 8, 6 }; // ок, элементам 2 и 3 присвоен нуль!
myarray = { 0, 1, 3, 5, 7, 9 }; // нельзя, слишком много элементов в списке инициализаторов!

Доступ к значениям массива через оператор индекса осуществляется как обычно:

std::cout << myarray;
myarray = 7;

Так же, как и в стандартных фиксированных массивах, оператор индекса не выполняет никаких проверок на диапазон. Если указан недопустимый индекс, то произойдут плохие вещи.

std::array поддерживает вторую форму доступа к элементам массива — функция at(), которая осуществляет проверку диапазона:

std::array<int, 4> myarray { 8, 6, 4, 1 };
myarray.at(1) = 7; // элемент массива под номером 1 — корректный, присваиваем ему значение 7
myarray.at(8) = 15; // элемент массива под номером 8 — некорректный, получим ошибку

В примере, приведенном выше, вызов проверяет, есть ли элемент массива под номером 1, и, поскольку он есть, возвращается ссылка на этот элемент. Затем мы присваиваем ему значение . Однако, вызов не срабатывает, так как элемента под номером 8 в массиве нет. Вместо возвращения ссылки, функция at() выдает ошибку, которая завершает работу программы (на самом деле выбрасывается исключение типа . Об исключениях мы поговорим на соответствующих уроках). Поскольку проверка диапазона выполняется, то функция at() работает медленнее (но безопаснее), чем оператор .

std::array автоматически делает все очистки после себя, когда выходит из области видимости, поэтому нет необходимости прописывать это вручную.

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

Как мы знаем, строка представляет собой массив символов, последний элемент которого является нулевым символом по таблице ASCII, обозначаемым ‘\0’. При работе со строками также как с численными массивами можно использовать указатели. Мы можем объявить в программе массив символов, записать туда строку, потом присвоить указателю адрес на первый или любой другой элемент этого массива и работать со строкой через указатель:

	char name30;
	char *nP;
 
	printf("Введите имя и фамилию: ");
	gets(name);
 
	printf("Имя: ");
	for(nP = name; *nP != ' '; nP++)
		putchar(*nP);
 
	printf("\nФамилия: ");
	puts(nP+1);

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

Иногда в программах можно видеть такое объявление и определение переменной-указателя:

Строку, которая была присвоена не массиву, а указателю, также можно получить, обратившись по указателю:

Но давайте посмотрим, что же все-таки происходит, и чем такая строка, присвоенная указателю, отличается от строки, присвоенной массиву.

Когда в программе определяются данные и объявляются переменные, то под них отводится память. При этом данные, которые не были присвоены переменным, поменять в процессе выполнения программы уже нельзя.

Что происходит в примере? В программе вводится строковый объект, который по сути является строковой константой (литералом). Ссылка на первый элемент этой строки присваивается указателю. Мы можем менять значение указателя сколько угодно, переходить к любому из элементов константного массива символов или даже начать ссылаться на совершенно другую строку. Но вот поменять значение элементов строки не можем. Это можно доказать таким кодом:

	char *strP;
	strP = "This is a literal";  // работает, но строку нельзя изменить
 
	puts(strP); 
	printf("%c\n",strP3);
	strP3 = 'z'; // не получится

В последней строке кода возникнет ошибка, т.к. совершается попытка изменить строку-константу.
Тем более нельзя делать так:

	char *strP;
	scanf("%s",strP); // ошибка сегментирования

В данном случае память не была выделена под массив символов, который мы пытаемся считать функцией ; память была выделена только под указатель. Поэтому записать строку просто некуда. Другое дело, если память была выделена с помощью объявления массива, после чего указателю был присвоен адрес на этот массив:

	char str12;
	char *strP; 
	strP = str; 	
	gets(strP); // память резервируется под массив ранее
	puts(strP);

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

Специфические типы массивов

Динамические массивы

Основная статья: Динамический массив

Динамическими называются массивы, размер которых может изменяться во время выполнения программы. Обычные (не динамические) массивы называют ещё фиксированными или статическими.

Динамические массивы могут реализовываться как на уровне языка программирования, так и на уровне системных библиотек. Во втором случае динамический массив представляет собой объект стандартной библиотеки, и все операции с ним реализуются в рамках той же библиотеки. Так или иначе, поддержка динамических массивов предполагает наличие следующих возможностей:

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

Ниже приведён пример конструкций для работы с динамическими массивами на Delphi.

var  // Описания динамических массивов
  byteArray   Array of Byte;           // Одномерный массив
  multiArray  Array of Array of string;  // Многомерный массив
...
  SetLength(byteArray, 1); // Установка размера массива в 1 элемент.
  byteArray := 16;       // Запись элемента.
  SetLength(byteArray, Length(byteArray)+1); // Увеличение размера массива на единицу
  byteArrayLength(byteArray) - 1 := 10;    // Запись значения в последний элемент.
  WriteLn(byteArrayLength(byteArray) - 1]); // Вывод последнего элемента массива. 
...
  SetLength(multiArray, 20, 30); // Установка размера двумерного массива
  multiArray10,15 := 12;
  SetLength(multiArray, 10, 15); // Уменьшение размера 
  WriteLn(Length(multiArray), '  ', Length(multiArray])

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

Гетерогенным называется массив, в разные элементы которого могут быть непосредственно записаны значения, относящиеся к различным типам данных. Массив, хранящий указатели на значения различных типов, не является гетерогенным, так как собственно хранящиеся в массиве данные относятся к единственному типу — типу «указатель». Гетерогенные массивы удобны как универсальная структура для хранения наборов данных произвольных типов. Реализация гетерогенности требует усложнения механизма поддержки массивов в трансляторе языка.

Общее описание

Массив — упорядоченный набор данных, используемый для хранения данных одного типа, идентифицируемых с помощью одного или нескольких индексов. В простейшем случае массив имеет постоянную длину и хранит единицы данных одного и того же типа.

Количество используемых индексов массива может быть различным: массивы с одним индексом называют одномерными, с двумя — двумерными, и т. д. Одномерный массив — нестрого соответствует вектору в математике; двумерный («строка», «столбец»)— матрице. Чаще всего применяются массивы с одним или двумя индексами; реже — с тремя; ещё большее количество индексов — встречается крайне редко.

Пример фиксированного массива на языке Паскаль

    {Одномерный массив целых чисел.
     Нумерация элементов от 1 до 15} 
  a array 1..15 of Integer;
    {Двумерный массив символов.
     Нумерация по столбцам по типу Byte (от 0 до 255)
     по строкам от 1 до 5}
  multiArray  array Byte, 1..5 of Char; 
    {Одномерный массив из строк.
     Нумерация по типу word (от 0 до 65536)}
  rangeArray  array Word of String;

Пример фиксированного массива на С/С++

  int Array10];         // Одномерный массив: целых чисел, размера 10;
                         // Нумерация элементов — от 0 до 9.
                         
  double Array12];  // Двумерный массив: 
                         // вещественных чисел двойной точности, 
                         // размера 12 на 15;
                         // Нумерация: по строкам — от 0 до 11, 
                         // по столбцам — от 0 до 14.

В некоторых языках программирования многомерные массивы создаются на основе одномерных, у которых элементы являются массивами.

Пример двумерного массива на JavaScript

    //Создание двумерного массива чисел: 
    var array = 
        11, 12, 13, 14, 15, 16], // Первая строка-массив
        21, 22, 23, 24, 25, 26], // Вторая
        31, 32, 33, 34, 35, 36  // Третья
    ];
    
    // Вывод массива на консоль:
    array.forEach((subArray) => {   // Для каждого под-массива,
       subArray.forEach((item) => { // для каждого его элемента,
           console.log(item);       // — вывести этот элемент на консоль.
       });
    });

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

В языках программирования, допускающих объявления программистом собственных типов, как правило, существует возможность создания типа «массив». В определении такого типа задаются типы и/или диапазоны значений каждого из индексов и тип элементов массива. Объявленный тип в дальнейшем может использоваться для определения переменных, формальных параметров и возвращаемых значений функций. Некоторые языки поддерживают для переменных-массивов операции присваивания (когда одной операцией всем элементам массива присваиваются значения соответствующих элементов другого массива).

Объявление типа «массив» в языке Паскаль

  type
    TArrayType = array ..9 of Integer; 
    (* Массивы, имеющие заданные параметры:
        1. Размер — 10 ячеек; 
        2. Тип элементов, пригодных для хранения — 
                — целые числа диапазона ,
        — объявляются типом операндов, называющимся "TArrayType". *)

  var
    arr1, arr2, arr3 TArrayType; 
    (* Объявление трёх переменных-массивов одного типа 
        (вышеуказанного "TArrayType"). *)

В языке программирования APL массив является основным типом данных (при этом нуль-мерный массив называется скаляром, одномерный — вектором, двумерный — матрицей). Помимо присваивания массивов в этом языке поддерживаются операции векторной и матричной арифметики, каждая из которых выполняется одной командой, операции сдвига данных в массивах, сортировка строк матрицы и т. п.

Массив может и не может

Почему $foo неправильно?

Вы всегда должны использовать кавычки вокруг индекса ассоциативного массива.
Например, пишите $foo, а не $foo. Но почему не верна запись $foo?
Вы могли встретить в старых скриптах такой синтаксис:

$foo = 'enemy';
echo $foo;
// etc

Это неправильно, но работает

Тогда почему неправильно? Суть в том, что
этот код содержит неопределённую константу (bar), а не строку ‘bar’
(обратите внимание на кавычки), и PHP может в дальнейшем определить константу,
которая, к несчастью для вашего кода, имеет то же самое имя. Это работает,
поскольку неопределённая константа конвертируется в строку с тем же именем

Как указано в разделе ,
между квадратными скобками (» и ») должно иметься выражение.
Это означает, что вы можете записать:

echo $arr;

Это пример использования return-значения функции в качестве индекса массива. PHP знает также и о константах,
и вы можете увидеть спереди E_*.

$error_descriptions = "A fatal error has occured";
$error_descriptions = "PHP issued a warning";
$error_descriptions = "This is just an informal notice";

Обратите внимание, что E_ERROR это такой же идентификатор,
как и bar в первом примере. Но последний пример равносилен записи:

$error_descriptions = "A fatal error has occured";
$error_descriptions = "PHP issued a warning";
$error_descriptions = "This is just an informal notice";

поскольку
E_ERROR равна 1, etc.

Тогда как может работать $foo?
Это работает, поскольку bar, по причине своего синтаксиса, ожидается как константное выражение. Однако в
этом случае константа с именем bar не существует. PHP теперь принимает, что вы обозначили
bar литерально как строку "bar", но что вы забыли указать кавычки.

Так почему же это неправильно?

Когда-нибудь в будущем команда PHP может добавить другую константу или
ключевое слово, и у вас появятся проблемы. Например,
вы уже не можете использовать слова empty и default таким способом, поскольку
они являются теперь зарезервированными ключевыми словами.

Передача массивов в функции

На уроке №75 мы говорили, что, из-за того, что копирование больших массивов при передаче в функцию является очень затратной операцией, C++ не копирует массив. При передаче массива в качестве аргумента в функцию, массив распадается в указатель на массив и этот указатель передается в функцию:

#include <iostream>

void printSize(int *array)
{
// Здесь массив рассматривается как указатель
std::cout << sizeof(array) << ‘\n’; // выведется размер указателя, а не длина массива!
}

int main()
{
int array[] = { 1, 2, 3, 4, 4, 9, 15, 25 };
std::cout << sizeof(array) << ‘\n’; // выведется sizeof(int) * длина массива

printSize(array); // здесь аргумент array распадается на указатель

return 0;
}

Результат выполнения программы:

Обратите внимание, результат будет таким же, даже если параметром будет фиксированный массив:

#include <iostream>

// C++ неявно конвертирует параметр array[] в *array
void printSize(int array[])
{
// Здесь массив рассматривается как указатель, а не как фиксированный массив
std::cout << sizeof(array) << ‘\n’; // выведется размер указателя, а не размер массива!
}

int main()
{
int array[] = { 1, 2, 3, 4, 4, 9, 15, 25 };
std::cout << sizeof(array) << ‘\n’; // выведется sizeof(int) * длина массива array

printSize(array); // здесь аргумент array распадается на указатель

return 0;
}

Результат выполнения программы:

В примере, приведенном выше, C++ неявно конвертирует параметр из синтаксиса массива () в синтаксис указателя (). Это означает, что следующие два объявления функции идентичны:

void printSize(int array[]);
void printSize(int *array);

Некоторые программисты предпочитают использовать синтаксис , так как он позволяет понять, что функция ожидает массив, а не указатель на значение. Однако, в большинстве случаев, поскольку указатель не знает, насколько велик массив, вам придется передавать размер массива в качестве отдельного параметра (строки являются исключением, так как они нуль-терминированные).

Рекомендуется использовать синтаксис указателя, поскольку он позволяет понять, что параметр будет обработан как указатель, а не как фиксированный массив, и определенные операции, такие как в случае с оператором sizeof, будут выполняться с параметром-указателем (а не с параметром-массивом).

Совет: Используйте синтаксис указателя () вместо синтаксиса массива () при передаче массивов в качестве параметров в функции.

Общее описание

Массив — упорядоченный набор элементов, каждый из которых хранит одно значение, идентифицируемое с помощью одного или нескольких индексов. В простейшем случае массив имеет постоянную длину и хранит единицы данных одного и того же типа, а в качестве индексов выступают целые числа.

Количество используемых индексов массива может быть различным: массивы с одним индексом называют одномерными, с двумя — двумерными, и т. д. Одномерный массив — нестрого соответствует вектору в математике; двумерный («строка», «столбец»)— матрице. Чаще всего применяются массивы с одним или двумя индексами; реже — с тремя; ещё большее количество индексов — встречается крайне редко.

Пример фиксированного массива на языке Паскаль

    {Одномерный массив целых чисел.
     Нумерация элементов от 1 до 15} 
  a array 1..15 of Integer;
    {Двумерный массив символов.
     Нумерация по столбцам по типу Byte (от 0 до 255)
     по строкам от 1 до 5}
  multiArray  array Byte, 1..5 of Char; 
    {Одномерный массив из строк.
     Нумерация по типу word (от 0 до 65536)}
  rangeArray  array Word of String;

Пример фиксированного массива на С/С++

  int Array10];         // Одномерный массив: целых чисел, размера 10;
                         // Нумерация элементов — от 0 до 9.
                         
  double Array12];  // Двумерный массив: 
                         // вещественных чисел двойной точности, 
                         // размера 12 на 15;
                         // Нумерация: по строкам — от 0 до 11, 
                         // по столбцам — от 0 до 14.

В некоторых языках программирования многомерные массивы создаются на основе одномерных, у которых элементы являются массивами.

Пример двумерного массива на JavaScript

    //Создание двумерного массива чисел: 
    var array = 
        11, 12, 13, 14, 15, 16], // Первая строка-массив
        21, 22, 23, 24, 25, 26], // Вторая
        31, 32, 33, 34, 35, 36  // Третья
    ];
    
    // Вывод массива на консоль:
    array.forEach((subArray) => {   // Для каждого под-массива,
       subArray.forEach((item) => { // для каждого его элемента,
           console.log(item);       // — вывести этот элемент на консоль.
       });
    });

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

В языках программирования, допускающих объявления программистом собственных типов, как правило, существует возможность создания типа «массив». В определении такого типа задаются типы и/или диапазоны значений каждого из индексов и тип элементов массива. Объявленный тип в дальнейшем может использоваться для определения переменных, формальных параметров и возвращаемых значений функций. Некоторые языки поддерживают для переменных-массивов операции присваивания (когда одной операцией всем элементам массива присваиваются значения соответствующих элементов другого массива).

Объявление типа «массив» в языке Паскаль

  type
    TArrayType = array ..9 of Integer; 
    (* Массивы, имеющие заданные параметры:
        1. Размер — 10 ячеек; 
        2. Тип элементов, пригодных для хранения — 
                — целые числа диапазона ,
        — объявляются типом операндов, называющимся "TArrayType". *)

  var
    arr1, arr2, arr3 TArrayType; 
    (* Объявление трёх переменных-массивов одного типа 
        (вышеуказанного "TArrayType"). *)

В языке программирования APL массив является основным типом данных (при этом нуль-мерный массив называется скаляром, одномерный — вектором, двумерный — матрицей). Помимо присваивания массивов в этом языке поддерживаются операции векторной и матричной арифметики, каждая из которых выполняется одной командой, операции сдвига данных в массивах, сортировка строк матрицы и т. п.

Свойства массива

Свойство length – длина, или, иными словами, количество элементов в массиве. Значение свойства length всегда на еди­ницу больше, чем самый высокий индекс массива.

Чтобы изменить размер массива, можно установить значение свойства length. Если новое значение length меньше предыдущего, массив обрезается, и элементы в его конце удаляются. Можно также присвоить свойству length значение, большее, чем текущая длина массива. В результате будут созданы пустые элементы, со значением , и массив станет «разреженным»:

Свойство prototype – ссылается на объект, являющийся прототипом для объектов типа . Данное свойство используется интерпретатором JavaScript, когда функция используется как конструктор при создании нового объекта. Любой объект, созданный с помощью конструктора, наследует все свойства объекта, на который ссылается свойство .

сам является экземпляром :

Свойство прототип позволяет добавлять новые свойства и методы ко всем созданным массивам.

Например, следующее выражение добавляет свойство color ко всем уже созданным массивам:

Выполнить код »
Скрыть результаты

Прототипу можно присвоить функции. При этом они пополнят множество методов объекта Array.

Например, определим функцию sum(), которая возвращает сумму элементов числового массива. В качестве параметра наша функция будет принимать массив. Затем присоединим к прототипу массива новый метод sum:

Выполнить код »
Скрыть результаты

Этот пример просто демонстрирует использование свойства prototype. Чтобы вычислить сумму элементов массива, достаточно написать: .

Свойство constructor ссылается на функцию-конструктор, которая была использована при создании объекта.

Возвращаемое значение является ссылкой на функцию, а не на имя функции:

Выполнить код »
Скрыть результаты

Свойство constructor можно использовать для определения, является ли переменная массивом.

Что же такое массивы?

По определению, Массив — это нумерованный набор переменных.

Переменные в массиве – это элементы массива. Их позиция в массиве задается индексом.

Если понять это не очень просто, то представьте себе «волшебную» коробку. В ней Вы можете создавать сколько угодно отделов и складывать что-то в эти отделы. При необходимости, Вы можете: удалять отделы; создавать новые; вытаскивать и использовать содержимое, которое в них находится; заменять содержимое отдельных отсеков чем-то другим; Вы можете даже хранить в одном из отсеков другой массив, который также содержит разные отделы.

Таким образом, Массив – это тип данных, который содержит в себе набор элементов. Сразу хочется сказать, что элементы эти, если мы говорим о языке php, не обязательно должны являться однотипными!

6.3. Многомерные динамические массивы

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

Оператор возвращает указатель на массив. Доступ к элементам такого массива будет осуществляться через выражение , в свою очередь будет массив из элементов типа .

При использовании псевдонимов можно получить более лаконичный синтаксис.

Используя перегрузку оператора легко создать класс, который хранит данные в одномерном массиве, но при этом предоставляет интерфейс многомерного массива. Вот пример предельно упрощенного класса матрицы.

Вот пример использования:

Более продвинутый класс матрицы может использовать специальный вложенный proxy-класс, представляющий строку, например , и индексатор будет возвращать экземпляр этого класса. Такой класс может, например, контролировать значение индекса, предоставлять функции-члены , , etc. Аналогичное решение может быть и для столбцов.

7. Частичная специализация шаблонов для массивов

Можно определить частичную специализацию шаблона класса для массивов не задавая при этом размер массива, то есть для массивов «вообще». Для этого в качестве типа специализации надо использовать . Вот пример.

Вывод:

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

8. Стандартные альтернативы массивам

Стандартная библиотека предоставляет несколько классов (точнее шаблонов классов), которые рекомендуется использовать вместо массивов.

Вместо встроенных массивов рекомендуется использовать шаблон . (Появился в C++11, см. .) Этот шаблон является объектной оберткой встроенного массива, он имеет два шаблонных параметра: тип элементов и размер. Размер должен быть известен на стадии компиляции, но в отличии от встроенного массива может быть нулевым. Вот пример:

Этот шаблон поддерживает индексатор и традиционный интерфейс стандартного контейнера.

Вместо динамических массивов рекомендуется использовать . Этот шаблон хорошо известен программистам, подробно описан в литературе (стандартный контейнер №1), поэтому каких-то дополнительных подробностей можно не приводить.

Есть еще довольно специфический и не особо популярный шаблон . Он позволяет эмулировать интерфейс многомерных массивов.

Список литературы

Джосаттис, Николаи М. Стандартная библиотека C++: справочное руководство, 2-е изд.: Пер. с англ. — М.: ООО «И.Д. Вильямс», 2014.