Вопрос 32. Многомерные массивы.

Многомерный массив представляет собой массив массивов, то есть массив, элементами которого служат массивы. Определение многомерного массива в общем случае должно содержать сведения о типе, размерности и количествах элементов каждой размерности, например описание: int ARRAY[4][3][6]; определяет массив, состоящий из четырех элементов, каждый из которых - двухмерный массив с размерами 3 на 6. В памяти массив ARRAY размещается в порядке возрастания самого правого индекса, то есть самый младший адрес имеет элемент ARRAY[0][0][0], затем идет элемент ARRAY[0][0][1] и т.д.

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

В массиве, где n- индексов, при вычислении функции делается n- умножений.

a[3][4]= a[3][4]+1-ужасная эффективность.

Лучше использовать еще одну ячейку памяти. Чтобы ускорить процесс работы системы нужно не каждый раз вызывать переменную из массива, а, вызвав 1 раз, вложить новую переменную и совершить нужные действия.

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

int ARRAY [4][3][6] = {0,1,2,3,4,5,6,7}

инициализирует только первые 8 элементов этого массива:

ARRAY[0][0][0]=0, ARRAY[0][0][1]=1, ARRAY[0][0][2]=2, ARRAY[0][0][3]=3,

ARRAY[0][0][4]=4, ARRAY[0][0][5]=5, ARRAY[0][1][0]=6, ARRAY[0][1][1]=7.

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

float matrix [ ][5] = { {1}, {2}, {3} };

формирует массив matrix с размерами 3 на 5, но не определяет явно начальных значений всех его элементов.

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

Многомерные массивы в C++ рассматриваются как массивы, элементами которых являются массивы.

Определение многомерного массива должно содержать информацию о типе, размерности и количестве элементов каждой размерности.

int MyArray1[10]; // Одномерный массив размерности 10.

int MyArray2[20][10]; // 20 одномерных массивов размерности 10.

int MyArray3[30][20][10]; // 30 двумерных массивов размерности 20*10.

По крайней мере, для Borland C++ 4.5, элементы многомерного массива располагаются в памяти в порядке возрастания самого правого индекса, т.е. самый младший адрес имеют элементы

MyArray1[0],

MyArray2[0][0],

MyArray3[0][0][0],

затем элементы

MyArray1[1],

MyArray2[0][1],

MyArray3[0][0][1]

и т.д.

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

int MyArray[3][3][3] = {0,1,2,3,4,5,6,7,8,9,10,11};

Начальные значения получают следующие элементы трёхмерного массива:

MyArray[0][0][0] == 0

MyArray[0][0][1] == 1

MyArray[0][0][2] == 2

MyArray[0][1][0] == 3

MyArray[0][1][1] == 4

MyArray[0][1][2] == 5

MyArray[0][2][0] == 6

MyArray[0][2][1] == 7

MyArray[0][2][2] == 8

MyArray[1][0][0] == 9

MyArray[1][0][1] == 10

MyArray[1][0][2] == 11

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

Дополнительные фигурные скобки в инициализаторе позволяют инициализировать отдельные фрагменты многомерного массива. Каждая пара фигурных скобок специфицирует значения, относящиеся к одной определённой размерности. Пустые фигурные скобки не допускаются (и это означает, что в C++ реализован жёсткий алгоритм инициализации массивов):

int MyArray[3][3][3] = {

{{0,1}},

{{100},{200,210},{300}},

{{1000},{2000,2100},{3000,3100,3200}}

};

В результате выполнения этого оператора определения будут означены следующие элементы массива MyArray:

MyArray[0][0][0] == 0

MyArray[0][0][1] == 1

MyArray[1][0][0] == 100

MyArray[1][1][0] == 200

MyArray[1][1][1] == 210

MyArray[1][2][0] == 300

MyArray[2][0][0] == 1000

MyArray[2][1][0] == 2000

MyArray[2][1][1] == 2100

MyArray[2][2][0] == 3000

MyArray[2][2][1] == 3100

MyArray[2][2][2] == 3200

По аналогии с одномерным массивом, при явной инициализации массива входящего в состав многомерного массива его самая левая размерность может не указываться. Она определяется на основе инициализатора.

int MyArray[ ][3][3] = {

{{0,1}},

{{100},{200,210},{300}},

{{1000},{2000,2100}}

};

Транслятор понимает, что речь идёт об определении массива размерности 3*3*3.

А в таком случае

int MyArray[ ][3][3] = {

{{0,1}},

{{100},{200,210},{300}},

{{1000},{2000,2100}},

{{10000}}

};

предполагается размерность 4*3*3. В результате MyArray оказывается массивом из четырёх частично проинициализированных двумерных массивов. Следует помнить, что в C++ нет принципиальной разницы между массивом массивов произвольной размерности и обычным одномерным массивом. Потому и простор для творчества в деле инициализации многомерных массивов ограничивается левым индексом.

//Одномерный динамический массив

int a = 5;

int *r = new int[a];

for(int i = 0; i < a; i++)

{

r[i] = GetTickCount();

Memo1->Lines->Add(r[i]);

}

delete r;

 

//Двумерный динамический массив

int len1 = 8;

int len2 = 9;

int **Arr = new int*[len1];

for(int i = 0; i < len1; i++)

{

Arr[i] = new int[len2];

}

Arr[1][1] = 4444;

 

//Трехмерный динамический массив

int l1 = 8;

int l2 = 9;

int l3 = 10;

int ***Arra = new int**[l1];

for(int i = 0; i < l1; i++)

{

Arra[i] = new int*[l2];

for(int u = 0; u < l2; u++)

{

Arra[i][u] = new int[l3];

}

}

Arra[1][1][1] = 9;

и так далее…

 

Вопрос 33. Строки и массивы символов.

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

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

Строки представляются в виде массива элементов типа char. Это означает, что символы строки можно представить расположенными в соседних ячейках памяти - по одному символу в ячейке. Но массив символов - не всегда строка!

последним элементом массива является символ '\0'. Это нуль-символ: в языке C++ он используется для того, чтобы отмечать конец строки. Нуль-символ - не есть цифра 0; он не выводится на печать и в таблице кодов ASCII имеет номер 0. Наличие нуль-символа означает, что количество ячеек массива должно быть по крайней мере на одну больше, чем количество символов, которые необходимо размещать в памяти.

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

#include <iostream.h>

int n=5;

char line[] = "Дом!"; /* Инициализация символьного мас- */

/* сива внешнего класса памяти. */

void main ()

{

cout << "Получили слово: ";

for (int i=0; i<n; i++)

cout << line[i];

1. Символьная строка представляет собой массив символов, завершающийся 0 (символом NULL).
2. Вы создаете символьную строку, объявляя массив типа char.
3. Ваша программа ответственна за размещение символа NULL за последним символом строки.
4. Если программа использует строковые константы, заключенные в
5. двойные кавычки, компилятор C++ автоматически добавляет символ NULL.
6. C++ позволяет вам инициализировать строки при объявлении, указывая требуемые символы внутри двойных кавычек.

Большинство компиляторов C++ в своих библиотеках этапа выполнения обеспечивают широкий набор функций для манипулирования строками.

 

Строка представляет собой последовательность (одномерный массив) из одного или более символов, последним из которых является нулевой символ таблицы ASCII '\0'. Это единственный вид строки, определенный в C.

Язык C поддерживает строковые константы, называемые строковыми литералами. Строковый литерал – это любая последовательность символов, заключенная в двойные кавычки ("…"). В конце литерала компилятор автоматически добавляет нулевой символ.

Не следует путать понятия строки и символа. Символьная константа заключается в одинарные кавычки, а строковая – в двойные.

Например, 'c' – символьная константа, а "c" – строковая константа.

Литерал можно задать с помощью директивы препроцессора define:

# define STR "…"

Строковая переменная может быть сформирована как одномерный массив типа char либо с помощью указателя на переменную типа char. Количество символов в массиве (объем выделяемой памяти) должно быть не меньше, чем количество символов в строке плюс один символ для хранения символа нуль.