Массив программа пример с числами

Массивы. Часть 3. Примеры решения наиболее распространенных задач с одномерными массивами

Поиск на других ресурсах:

1. Нахождение сумм и произведений элементов массива. Примеры

Пример 1. Задан массив A , содержащий 100 целых чисел. Найти сумму элементов этого массива. Фрагмент кода, решающего эту задачу

// сумма элементов массива A из 100 целых чисел int A[100]; int suma; // переменная, содержащая сумму int i; // дополнительная переменная // ввод массива A // . // Вычисление суммы suma = 0; // обнулить сумму for (i=0; i

Перебор всех элементов массива выполняется в цикле for .

Переменная sum сохраняет результирующее значение суммы элементов массива. Переменная i есть счетчиком, определяющим индекс элемента массива A[i] .

Пример 2. Задан массив B , содержащий 20 вещественных чисел. Найти сумму элементов массива, которые лежат на парных позициях. Считать, что позиции 0 , 2 , 4 и т.д. есть парными.

// сумма элементов массива B // лежащих на парных позициях float B[20]; float sum; // переменная, содержащая сумму int i; // дополнительная переменная // ввод массива // . // Вычисление суммы sum = 0; // обнулить сумму for (i=0; iif ((i%2)==0) sum += B[i];

В этом примере выражение

Пример программы для нахождения суммы отрицательных элементов массива. Программирование на С++

определяет парную позицию (парный индекс) массива B . Если нужно взять нечетные позиции, то нужно написать

Пример 3. Задан массив, который содержит 50 целых чисел. Найти сумму положительных элементов массива.

// сумма положительных элементов массива int A[50]; int sum; // переменная, содержащая сумму int i; // дополнительная переменная // ввод массива // . // Вычисление суммы sum = 0; // обнулить сумму for (i=0; iif (A[i]>0) sum = sum + A[i];

Пример 4. Задан массив из 50 целых чисел. Найти произведение элементов массива, которые есть нечетными числами.

// произведение нечетных элементов массива int A[50]; int d; // переменная, содержащая произведение int i; // вспомогательная переменная // ввод массива // . // Вычисление произведения d = 1; // начальная установка переменной d for (i=0; iif ((A[i]%2)==1) d = d * A[i];

Чтобы определить, есть ли элемент массива A[i] нечетным, нужно проверить условие

(A[i]%2)==1

Если условие выполняется, то элемент массива есть нечетное число.

2. Нахождение максимального (минимального) элемента массива. Примеры

Пример 1. Задан массив из 30 вещественных чисел. Найти элемент (индекс), имеющий максимальное значение в массиве.

// поиск позиции (индекса), содержащего максимальное значение float B[30]; float max; // переменная, содержащая максимум int index; // позиция элемента, содержащего максимальное значение int i; // дополнительная переменная // ввод массива // . // поиск максимума // установить максимум как 1-й элемент массива index = 0; max = B[0]; for (i=1; iif (max// запомнить максимум index = i; // запомнить позицию максимального элемента >

В вышеприведенном примере переменная max содержит максимальное значение. Переменная index содержит позицию элемента, который имеет максимальное значение. В начале переменной max присваивается значение первого элемента массива. Затем, начиная со второго элемента, происходит прохождение всего массива в цикле for . Одновременно проверяется условие

rand. srand. rand задать диапазон. srand time null. Генератора случайных чисел. randomize. Урок #29.

if (max

Если условие выполняется (найден другой максимум), тогда новое значение максимума фиксируется в переменных max и index .

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

Пример 2. Задан массив содержащий 50 целых чисел. Найти позицию (позиции) элемента, который имеет минимальное значение. Если таких элементов несколько, сформировать дополнительный массив индексов.

// поиск позиций (индексов), содержащих минимальное значение int A[50]; int min; // переменная, содержащая минимальное значение int INDEXES[50]; // позиции элементов, содержащих минимальное значение int n; // число одинаковых минимальных значений int i; // дополнительная переменная // ввод массива // . // 1. Поиск минимального значения // установить минимальное значение в первом элементе массива min = A[0]; for (i=1; iif (min>A[i]) min = A[i]; // запомнить минимальное значение // 2. Формирование массива n = 0; // обнулить счетчик в массиве INDEXES for (i=0; i// увеличить число элементов в INDEXES INDEXES[n-1] = i; // запомнить позицию > listBox1->Items->Clear(); // 3. Вывод массива INDEXES в listBox1 for (i=0; iItems->Add(INDEXES[i].ToString());

В вышеприведенном листинге сначала ищется минимальное значение min .

На втором шаге формируется массив INDEXES , в котором число элементов записывается в переменную n . Происходит поиск минимального значения в массиве A с одновременным формированием массива INDEXES .

На третьем шаге приведен пример, как вывести массив INDEXES в элементе управления listBox1 ( ListBox ).

3. Сортировка массива методом вставки

Пример. Пусть дан массив A , содержащий 10 целых чисел. Отсортировать элементы массива в нисходящем порядке с помощью метода вставки.

// сортировка массива методом вставки int A[10]; int i, j; // дополнительные переменные — счетчики int t; // дополнительная переменная // ввод массива A // . // сортировка for (i=0; ifor (j=i; j>=0; j—) if (A[j]// поменять местами A[j] и A[j+1] t = A[j]; A[j] = A[j+1]; A[j+1] = t; >

4. Поиск элемента в массиве. Примеры

Пример 1. Определить, находится ли число k в массиве M состоящем из 50 целых чисел.

// определение наличия заданного числа в массиве чисел int M[50]; int i; int k; // искомое значение bool f_is; // результат поиска, true — число k есть в массиве, иначе false // ввод массива M // . // ввод числа k // . // поиск числа в массиве f_is = false; for (i=0; iif (k==M[i]) < f_is = true; // число найдено break; // выход из цикла, дальнейший поиск не имеет смысла > // вывод результата if (f_is) label1->Text = «Число » + k.ToString() + » есть в массиве M.»; else label1->Text = «Числа » + k.ToString() + » нет в массиве M.»;

Пример 2. Найти все позиции вхождения числа k в массиве M состоящим из 50 целых чисел.

// определение всех позиций заданного числа в массиве чисел int M[50]; // массив чисел int i; // вспомогательная переменная int k; // искомое значение int INDEXES[50]; // искомый массив позиций вхождения числа k int n; // количество найденных позиций или количество элементов в массиве INDEXES // ввод массива M // . // ввод числа k // . // поиск числа k в массиве M и одновременное формирование массива INDEXES n = 0; for (i=0; iif (k==M[i]) < // число найдено n++; INDEXES[n-1] = i; > // вывод результата в listBox1 listBox1->Items->Clear(); for (i=0; iItems->Add(INDEXES[i].ToString());

Связанные темы

• Массивы. Часть 1. Определение массива в C++ . Одномерные массивы. Инициализация массива
• Массивы. Часть 2. Двумерные массивы. Массивы строк. Многомерные массивы

Источник: www.bestprog.net

Массивы в С++

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

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

Одномерные массивы в С++

Одномерный массив — массив, с одним параметром, характеризующим количество элементов одномерного массива. Фактически одномерный массив — это массив, у которого может быть только одна строка, и n-е количество столбцов. Столбцы в одномерном массиве — это элементы массива. На рисунке 1 показана структура целочисленного одномерного массива a. Размер этого массива — 16 ячеек.

Рисунок 1 — Массивы в С++

Заметьте, что максимальный индекс одномерного массива a равен 15, но размер массива 16 ячеек, потому что нумерация ячеек массива всегда начинается с 0. Индекс ячейки – это целое неотрицательное число, по которому можно обращаться к каждой ячейке массива и выполнять какие-либо действия над ней (ячейкой).

//синтаксис объявления одномерного массива в С++: /*тип данных*/ /*имя одномерного массива*/[/*размерность одномерного массива*/]; //пример объявления одномерного массива, изображенного на рисунке 1: int a[16];

где, int — целочисленный тип данных;

а — имя одномерного массива;
16 — размер одномерного массива, 16 ячеек.

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

//ещё один способ объявления одномерных массивов int mas[10], a[16];

Объявлены два одномерных массива mas и а размерами 10 и 16 соответственно. Причём в таком способе объявления все массивы будут иметь одинаковый тип данных, в нашем случае — int .

// массивы могут быть инициализированы при объявлении: int a[16] = < 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 >; // инициализация одномерного массива

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

int a[]=; // инициализации массива без определения его размера.

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

// array.cpp: определяет точку входа для консольного приложения. #include «stdafx.h» #include using namespace std; int main(int argc, char* argv[]) < cout ; // объявление и инициализация одномерного массива cout system(«pause»); return 0; >
// array.cpp: определяет точку входа для консольного приложения. #include using namespace std; int main(int argc, char* argv[]) < cout ; // объявление и инициализация одномерного массива cout return 0; >

В строках 10 — 11 объявлен и проинициализирован целочисленный одномерный массив с именем array1 , размер которого равен 16 ячейкам, то есть такой массив может хранить 16 чисел. Любая обработка массива осуществима только совместно с циклами. Какой цикл выбрать для обработки массива — это вам решать.

Но лучше всего для этой задачи подходит цикл for . Переменную-счётчик counter будем использовать для обращения к элементам одномерного массива array1 . В условии продолжения цикла for стоит строгий знак неравенства, так как шестнадцатого индекса в одномерном массиве array1 нет. А так как нумерация ячеек начинается с нуля, то элементов в массиве 16. В теле цикла for оператор cout печатает элементы одномерного массива (см. Рисунок 2).

CppStudio.com

obrabotka massiva indeks element massiva array1[0] 5 array1[1] -12 array1[2] -12 array1[3] 9 array1[4] 10 array1[5] 0 array1[6] -9 array1[7] -12 array1[8] -1 array1[9] 23 array1[10] 65 array1[11] 64 array1[12] 11 array1[13] 43 array1[14] 39 array1[15] -15 Для продолжения нажмите любую клавишу . . .

Рисунок 2 — Массивы в С++

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

// array_sum.cpp: определяет точку входа для консольного приложения. #include «stdafx.h» #include using namespace std; int main(int argc, char* argv[]) < int array1[10]; // объявляем целочисленный массив cout > array1[counter]; // считываем вводимые с клавиатуры числа cout nsum = »
// array_sum.cpp: определяет точку входа для консольного приложения. #include using namespace std; int main(int argc, char* argv[]) < int array1[10]; // объявляем целочисленный массив cout > array1[counter]; // считываем вводимые с клавиатуры числа cout nsum = »

Перед тем как выполнять обработку массива его необходимо объявить, причём размер одномерного массива равен 10, так как это оговорено условием задачи. В переменной sum будем накапливать сумму элементов одномерного массива. Первый цикл for заполняет объявленный одномерный массив, введёнными с клавиатуры числами, строки 12 — 13.

Переменная счётчик counter используется для последовательного доступа к элементам одномерного массива array1 , начиная с индекса 0 и до 9-го включительно. Второй цикл for выводит на экран элементы массива, строки 15 — 16. Третий цикл for последовательно считывает элементы одномерного массива и суммирует их, сумма накапливается в переменной sum , строки 17 — 18. Результат работы программы смотреть на рисунке 3.

CppStudio.com

Enter elementi massiva: 0 1 2 3 4 5 6 7 8 9 array1 = sum = 45 Для продолжения нажмите любую клавишу . . .

Рисунок 3 — Массивы в С++

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

Двумерные массивы в С++

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

Также и в двумерном массиве, кроме количества элементов массива, есть такие характеристики как, количество строк и количество столбцов двумерного массива. То есть, визуально, двумерный массив — это обычная таблица, со строками и столбцами. Фактически двумерный массив — это одномерный массив одномерных массивов. Структура двумерного массива, с именем a , размером m на n показана ниже (см. Рисунок 4).

Рисунок 4 — Массивы в С++

где, m — количество строк двумерного массива;
n — количество столбцов двумерного массива;
m * n — количество элементов массива.

// синтаксис объявления двумерного массива /*тип данных*/ /*имя массива*/[/*количество строк*/][/*количество столбцов*/];

В объявлении двумерного массива, также как и в объявлении одномерного массива, первым делом, нужно указать:

• тип данных;
• имя массива.

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

// пример объявление двумерного массива: int a[5][3];

• a — имя целочисленного массива
• число в первых квадратных скобках указывает количество строк двумерного массива, в данном случае их 5;
• число во вторых квадратных скобках указывает количество столбцов двумерного массива, в данном случае их 3.

// инициализация двумерного массива: int a[5][3] = < , , , , >;

В данном массиве 5 строк, 3 столбца. после знака присвоить ставятся общие фигурные скобочки, внутри которых ставится столько пар фигурных скобочек, сколько должно быть строк в двумерном массиве, причём эти скобочки разделяются запятыми. В каждой паре фигурных скобочек записывать через запятую элементы двумерного массива. Во всех фигурных скобочках количество элементов должно совпадать. Так как в массиве пять строк, то и внутренних пар скобочек тоже пять. Во внутренних скобочках записаны по три элемента, так как количество столбцов — три. Графически наш массив будет выглядеть, как двумерная таблица (см. Рисунок 5).

Рисунок 5 — Массивы в С++

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

Разработаем несложную программу, на обработку двумерного массива, которая называется «Лабиринт». Лабиринт должен быть построен на основе двумерного массива. Размер лабиринта выберем на свое усмотрение.

// array2.cpp: определяет точку входа для консольного приложения. #include «stdafx.h» #include using namespace std; int main(int argc, char* argv[]) < // 1-условно «стенки лабиринта» // 2-«правильный путь, выход из лабиринта» // 0-«ложный путь» int mas[33][20] = < , // инициализация двумерного массива , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , >; // два цикла — внутренний и внешний, осуществляющие обращение к каждому элементу массива for (int i = 0; i < 33; i++) //переключение по строкам < for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) < // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout (176); cout (176); > else cout system(«pause»); return 0; >
// array2.cpp: определяет точку входа для консольного приложения. #include using namespace std; int main(int argc, char* argv[]) < // 1-условно «стенки лабиринта» // 2-«правильный путь, выход из лабиринта» // 0-«ложный путь» int mas[33][20] = < , // инициализация двумерного массива , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , >; // два цикла — внутренний и внешний, осуществляющие обращение к каждому элементу массива for (int i = 0; i < 33; i++) //переключение по строкам < for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) < // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout (176); cout (176); > else cout return 0; >

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

Первый цикл for выполняет переключение между строками двумерного массива. Так как строк в двумерном массиве 33, то и переменная-счетчик i инкрементируется от 0 до 33, строка 46. Внутри первого цикла стоит цикл for , который переключается между элементами строки двумерного массива.

В теле второго цикла for внутри оператора условного выбора if выполняетcя унарная операция преобразования типа данных — static_cast<>() , которая печатает символ таблицы ASCII, под номером 176. операция преобразования типов данных дублируется для увеличения ширины лабиринта. Результат работы программы (см. Рисунок 6).

CppStudio.com

░░ ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ░░ ░░ ░░ ░░ ░░░░░░░░ ░░ ░░ ░░░░ ░░ ░░ ░░ ░░ ░░░░ ░░ ░░ ░░ ░░░░░░░░ ░░ ░░ ░░ ░░░░░░░░░░░░ ░░ ░░ ░░ ░░░░ ░░ ░░ ░░ ░░ ░░░░ ░░ ░░ ░░ ░░░░ ░░░░░░░░░░ ░░ ░░░░░░░░ ░░ ░░ ░░░░░░░░ ░░ ░░ ░░░░░░░░░░░░ ░░░░░░ ░░ ░░░░░░░░ ░░░░ ░░ ░░░░ ░░░░░░░░ ░░ ░░ ░░ ░░ ░░░░░░░░ ░░ ░░░░░░░░░░░░░░░░░░░░░░░░░░ ░░ ░░ ░░ ░░ ░░░░░░░░ ░░ ░░░░ ░░░░░░░░░░░░░░░░░░░░ ░░ ░░ ░░ ░░ ░░ ░░░░ ░░ ░░ ░░░░░░░░░░ ░░ ░░░░░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░░░░░░░░░░░░░░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░░░░░░░░░░░░░░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░░░░░░░░░░░ ░░ ░░ ░░ ░░ ░░░░░░░░░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░░░░░ ░░ ░░░░ ░░ ░░ ░░░░ ░░░░ ░░ ░░ ░░ ░░ ░░ ░░░░ ░░ ░░░░░░░░░░░░░░░░░░░░ ░░ ░░ ░░░░ ░░░░ ░░ ░░ ░░ ░░░░ ░░ ░░ ░░░░░░░░░░░░░░░░░░░░ ░░ ░░░░ ░░ ░░░░ ░░░░░░░░░░░░░░░░ ░░ ░░░░ ░░ ░░ ░░░░ ░░ ░░ ░░░░ ░░ ░░░░ ░░░░ ░░░░░░░░░░░░░░ ░░ ░░░░ ░░ ░░ ░░░░ ░░ ░░ ░░ ░░ ░░ ░░░░ ░░ ░░ ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ Для продолжения нажмите любую клавишу . . .

Рисунок 6 — Массивы в С++

Источник: cppstudio.com

Массивы в C++ на практике

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

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

• Организация массива

• Использование автоматических массивов
• Использование массивов с динамическим выделением памяти

• Заполнение массива случайными числами
• Заполнение массива числами, введёнными пользователем

• Поиск максимального/максимального значения в массиве
• Поиск определённого значения в массиве
• Сумма/произведение отрицательных элементов массива
• Сумма элементов массива с чётными/нечётными индексами

Организация массива

Память под массив может выделяться автоматически или динамически.

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

Динамическое выделение памяти используют, когда размер массива неизвестен на этапе компиляции (допустим, запрашивается у пользователя).

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

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

Глобальные автоматические массивы в плане переполнения стека безопасны. Но они будут видны во всём коде, лексикографически расположенному после объявления массивов, что может спровоцировать их использование напрямую, минуя их передачу в функции через параметры. Это приведёт к возникновению побочных эффектов работы функций, что затрудняет отладку и делает программы менее надёжными. Такого использования глобальных массивов следует избегать.

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

Использование автоматических массивов

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

Размер массива в коде настоятельно рекомендуется указывать с помощью именованной константы. Это полезно по нескольким соображениям:

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

Тип константного выражения для определения размера (количество элементов) автоматического массива должен быть целочисленный: char , int , unsigned int , long , etc.

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

Пример определения глобального автоматического массива длиной 10 элементов типа int :

Пример определения локального автоматического массива длиной 10 элементов типа int :

Использование массивов с динамическим выделением памяти

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

Память для массива выделяется оператором new в форме new тип[количество_элементов] .

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

Когда работа с массивом закончена, память, выделенную под массив необходимо освободить. Это делается с помощью оператора delete в форме delete [] имя_переменной . После того, как память освобождена, работать с массивом нельзя.

Пример использования массива с динамическим выделением памяти:

Заполнение массива значениями

При решении учебных задач, обычно предлагается заполнить массив значениями либо введёнными с клавиатуры, либо случайными значениями из определённого диапазона. Начнём со второго случая, как более простого (Парадокс? Нет, правда жизни).

Заполнение массива случайными числами

Для начала необходим генератор случайных чисел. Ниже приведён код одной из простейших реализаций:

using namespace std; // функция генерации случайного числа из диапазона от range_min до range_max включительно int rrand(int range_min, int range_max)

Однако без дополнительных телодвижений стандартная функция rand() будет при каждом запуске программы генерировать одинаковую последовательность случайных чисел (кстати, это очень удобно при отладке!). Для того, что бы при каждом запуске программы получать уникальную последовательность случайных чисел, функцию rand() надо «разогнать» начальным случайным значением. Это делается с помощью функций srand() и time() .

Заполнение массива значениями, естественно, делаем в цикле. Помним, что элементы массива в C/C++ нумеруются с 0. Следовательно последний элемент массива имеет индекс на единицу меньший, чем размер массива.

В примере показано заполнение глобального автоматического массива из 10 элементов типа int случайными значения из диапазона от −100 до 100 включительно:

#include using namespace std; // функция генерации случайного числа из диапазона от range_min до range_max включительно int rrand(int range_min, int range_max) < return rand() % (range_max — range_min + 1) + range_min; >const unsigned int ARRSIZE = 10; const int ABSLIMIT = 100; int ary[ARRSIZE]; int main(void) < srand(static_cast(time(NULL))); // инициализация массива случайными значениями из диапазона -ABSLIMIT..ABSLIMIT for (unsigned int i = 0; i < ARRSIZE; i++) < ary[i] = rrand(-ABSLIMIT, ABSLIMIT); >return 0; >

Обратите внимание на включение заголовочных файлов!

Заполнение массива числами, введёнными пользователем

Как ни странно, это более сложный случай. Дело в том, что во-первых, наличие человека всегда может приводить к некорректному вводу данных (ошибкам), во-вторых, для человека необходимо обеспечить какой-никакой интерфейс, а в-третьих, система потокового ввода-вывода STL имеет свои неприятные особенности.

Итак, пользуясь предыдущим примером, попробуем написать фрагмент, отвечающий за ввод значений массива с клавиатуры. Добавим в начало кода заголовочный файл #include , а вместо инициализации массива случайными значениями напишем что-то типа:

> ary[i]; >

Оно как бы работает, но если вы попытаетесь в качестве числа (конечно случайно!) ввести 1111111111111111111111111111111111 или 11q, то, в зависимости от компилятора, сможете наблюдать некоторые интересные эффекты работы вашей программы.

Поэтому приходится писать более сложный код:

> ary[i]; if (cin.fail()) < cout cin.clear(); cin.ignore(); > while (fail); >

Подробный разбор данного фрагмента выходит за рамки данной статьи. Но интересующиеся могут его разобрать, вооружившись, например, известной книгой Г. Шилдта.

Вывод на консоль значений из массива

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

(time(NULL))); // инициализация массива случайными значениями из диапазона -ABSLIMIT..ABSLIMIT for (unsigned int i = 0; i < ARRSIZE; i++) < ary[i] = rrand(-ABSLIMIT, ABSLIMIT); >// вывод в cout значений элементов массива for (unsigned int i = 0; i < ARRSIZE; i++) < cout // поиск максимального значения в массиве и его индекса // при наличии нескольких минимальных значений находится первое int min_val = ary[0]; unsigned int min_idx = 0; for (unsigned int i = 1; i < ARRSIZE; i++) < if (min_val >ary[i]) < min_val = ary[i]; min_idx = i; >> cout