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

МАССИВЫ

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

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

Вся совокупность компонент определяется одним именем. Для обозначения отдельных компонент используется конструкция, называемая переменной с индексом или с индексами. Переменная с индексом представляет собой имя массива, вслед за которым в квадратных скобках записывается индекс (или индексы).

Описание массива выглядит следующим образом:

базовый_тип имя_массива [размерность];

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

Например:

//одномерный массив целочисленного типа из 5 элементов

int array[5];

//одномерный массив вещественного типа из N элементов (N - константа!!!)

const int N = 20;

float x[N];

//одномерный массив беззнакового целочисленного типа из 2*M элементов

const int M = 5;

unsigned int b[2*M];

При описании массив можно инициализировать, то есть присвоить его элементам начальные значения:

базовый_тип имя_массива [размерность] = {начальные_значения};

Если инициализирующих значений меньше, чем элементов в массиве, остаток массива обнуляется, если больше – лишние значения не используются.

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

Например:

int a[3] = {1, 2, 3}; //a[0] = 1, a[1] = 2, a[2] = 3

// недостающие значения инициализации заполняются нулями

int b[5] = {1, 2, 3}; //b[0] = 1, b[1] = 2, b[2] = 3, b[3] = 0, b[4] = 0

// лишние значения (4 и 5) не используются

int с[3] = {1, 2, 3, 4, 5}; //c[0] = 1, c[1] = 2, c[2] = 3

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

// по количеству элементов инициализации

int d[] = {0, 2, 4}; //c[0] = 0, c[1] = 2, c[2] = 4 (размер 3)

//строка так же является массивом символов,

//оканчивающимся нуль-символом (управляющей последовательностью \0)

char s[] = "Hi!"; //s[0]='H', s[1]='i', s[2]='!', s[3]='\0' (размер 4)

Для доступа к элементу массива после его имени указывается номер элемента (индекс), в квадратных скобках:

имя_массива [индекс];

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

Например, для объявленных выше массивов обращения и использование будет выглядеть следующим образом:

//обращения к элементам массива

cout << a [ 1 ];

int i = 2;

cout << b [ i - 1 ];

cout << c [ 2 * i ];

int z;

a [ 2 ] = -1;

z = a [ 0 ] + ( b [ i ] + d [ i + 1 ]) / c [ 2 * i + 1 ];

d [ 0 ] = z - d [ i ]) / c [ 2 * i + 1 ];

Рассмотрим пример нахождения суммы элементов массива.

Замечание.

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

#include <iostream>

using namespace std;

void main()

{

cout << "Привет мир!" << endl;

setlocale(LC_ALL, "Russian");

cout << "Привет мир!" << endl;

}

Результат работы программы:

╧ЁштхЄ ьшЁ!

Привет мир!

Задача: найти сумму элементов массива, вывести ее и сам массив на экран. Элементы массива ввести с клавиатуры.

#include <iostream>

using namespace std;

void main ()

{

setlocale ( LC_ALL, "Russian" );

//определим размер массива

const int N = 10;

int a [ N ];

//введем элементы массива с клавиатуры

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

{

cout << "Введите " << i << "-й элемент массива: ";

cin >> a [ i ];

}

//объявим переменную для хранения суммы элементов

int s = 0;

//просуммируем элементы массива

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

s += a [ i ];

//выведем на экран элементы массива и их сумму

cout << "a:";

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

{

cout << " " << a [ i ];

}

cout << endl << "Сумма элементов: " << s;

}

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

N = sizeof( array )/sizeof( array [ 0 ])

Здесь array – имя массива, N – полученный размер массива, sizeof( array ) возвращает размер всего массива в батах, а sizeof( array [ 0 ]) – размер первого элемента в байтах (естественно совпадающий с размером остальных элементов). Таким образом, поделив размер всего массива на размер одного элемента, мы получим количество элементов, т.е. искомый размер массива.

Рассмотрим следующий пример: найти максимальный элемент в массиве.

#include <iostream>

using namespace std;

void main ()

{

setlocale ( LC_ALL, "Russian" );

int b [] = { 1, -5, 8, 7, 4, -7, 3, 0, -8, 6 };

//определим размер массива

int n = sizeof( b )/sizeof( b [ 0 ]);

//объявим переменную для хранения максимального элемента

//присвоим начальное значение, равное нулевому элементу

int m = b [ 0 ];

//просмотрим все элементы начиная с 1-ого элемента

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

{

//если i-й элемент будет больше

//текущего максимального значения,

//то изменим это максимальное значение

//на значение i-го элемента

if ( b [ i ] > m )

m = b [ i ];

}

//выведем на экран элементы массива

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

cout << " " << b [ i ];

//и максимальный элемент

cout << endl << "Максимальный элемент: " << m;

}

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

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

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

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

Например:

//одномерный массив (вектор) размерностью 10

int vector [ 10 ];

//двумерный массив (матрица) размерностью 3x3

int matrix [ 3 ][ 3 ];

//двумерный массив размерностью 6 строк на 8 столбцов

int x [ 6 ][ 8 ];

//трехмерный массив размерностью 6x3x2

int y [ 6 ][ 3 ][ 2 ];

//шестимерный массив размерностью 6x3x2x5x8x4

int z [ 6 ][ 3 ][ 2 ][ 5 ][ 8 ][ 4 ];

//объявление массива с инициализацией

//крайняя левая размерность отсутствует

int mass0 [][ 2 ] = { { 1, 1 }, { 0, 2 }, { 3, 0 } };

//объявление массива с инициализацией

int mass1 [ 3 ][ 2 ] = { { 1, 1 }, { 0, 2 }, { 3, 0 } };

//объявление массива с инициализацией

//для удобства чтения каждая строка массива находится в отдельной строчке

int mass2 [ 3 ][ 2 ] = {

{ 1, 1 },

{ 0, 2 },

{ 3, 0 }

};

//объявление массива с инициализацией

//внутренние фигурные скобки могут отсутствовать

int mass3 [ 3 ][ 2 ] = ( 1, 1, 0, 2, 3, 0 ):

//объявление массива с инициализацией

//для удобства чтения каждая строка массива находится на отдельной строчке

int mass4 [ 3 ][ 2 ] = (

1, 1,

0, 2,

3, 0

):

Пример: в целочисленной матрице 3x4 определить номера строки и столбца элемента, который равен нулю. Массив задать случайными числами.

#include <iostream>

using namespace std;

void main ()

{

setlocale ( LC_ALL, "Russian" );

const int N = 3, M = 4;

int r [ N ][ M ];

//заполним массив случайными числами от 0 до 9

//внешний цикл для перемещения по строкам

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

//внутренний цикл для перемещения по столбцам

for (int j = 0; j < M; j ++)

//остаток от деления на 10 позволяет

//получить требуемый диапазон значений

r [ i ][ j ] = rand () % 10;

//выведем массив на экран

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

{

for (int j = 0; j < M; j ++)

{

cout << r [ i ][ j ] << " ";

}

//перейдем на новую строчку

cout << endl;

}

cout << "Нулевые элементы:" << endl;

//найдем элементы равные 0 и выведем их индексы на экран

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

for (int j = 0; j < M; j ++)

if ( r [ i ][ j ] == 0 )

{

cout << "a[" << i << "][" << j << "] == 0" << endl;

}

}

Обработка массивов в языке Си++

Массив - структурированный тип данных, состоящий из фиксированного числа элементов одного типа. На рис. 1 представлен массив вещественных чисел X.

Рисунок 1: Пример массива

Одномерный массив описывают так:

тип имя_переменной [n];

где n - количество элементов в массиве, причем нумерация начинается с нуля:от 0 до n - 1.

Например:

int х[10];

float g[25];

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

Например,

x[0] x[4]

Двумерный массив (матрицу) можно объявить так:

тип имя_переменной [n][m];

где n - количество строк (от 0 до n-1), m - количество столбцов (от 0 до m-1).

Например, double m[3][4];

Обращаются к элементу матрицы, указывая последовательно в квадратных скобках соответствующие индексы:

Например, a[1][2] элемент матрицы a, находящийся в первой строке и втором столбце.

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

Например,

float a[5]={1.2,(float)3/4, 5./6,6.1,7.8};

Не нашли, что искали? Воспользуйтесь поиском: