Как найти среднее арифметическое в строке массива

И снова здравствуйте! В прошлой части мы рассмотрели что такое одномерный массив в C++, узнали для чего он необходим, а так же порешали некоторые типовые академические задачи. В этот раз примеры программ будут написаны в среде Visual Studio 2017, но вы можете использовать любой другой инструмент, например Code::Blocks или онлайн компиляторы. Сегодня мы рассмотрим двумерный массив. Это также простейшая структура данных как и одномерный массив, к данным все также возможно обращаться по индексу, но есть некоторая особенность. Давайте рассмотрим ее так же на примере контейнера с яблоками:

Получается, что у нас теперь многоэтажный контейнер, в каждой ячейке которой находятся яблоки (ячейка так же может быть пустой, для ссылочных типов это значение null и ноль для значимых типов). Для того что бы взять  или положить яблоки из определенной ячейки необходимо сначала выбрать строку, а затем столбец, после чего мы возьмем необходимые нам яблоки, или наоборот положим.  Обратите внимание, что нумерация ячеек строк и столбцов начинается с 0! Это важно, так как индексация массива начинается всегда с 0 а не 1. Т.е что бы обратиться к первой ячейке контейнера, нам необходимо достать яблоки из нулевой ячейки на пересечении двух координат (вспомнили игру Морской бой? =) ). Идем на нулевую строку и ищем нулевой столбец где находится нужная нам ячейка. 

Здесь у нас лежат два яблока. Так же не забываем, что С++ строго типизированный язык программирования, поэтому мы не можем в целочисленный массив записать вещественное число (float или double) или символ (char) и наоборот. Но существуют языки в которых такое возможно, например PHP и Java Script.  Итак для работы с нашим контейнером и ячейками, нам предварительно нужно его создать и заполнить ячейки яблоками. Кладем в ячейку с координатами [0][0] два яблока, [0][1] — три яблока, [0][2] — одно яблоко и так далее до координат ячейки с индексом [4][4]. Что мы сделали? Правильно, инициализировали массив! В коде это будет выглядеть следующим образом:

#include<iostream> // Стандартная библиотека ввода вывода
#include<iomanip>// Библиотека манипуляторов для форматирования потока
#define ROWS 5      // Обозначаем длину строки нашего контейнера(массива) для яблок
#define COLUMNS 5   // Обозначаем длину столбца нашего контейнера(массива) для яблок
using namespace std; // используем стандартное пространство имен библиотеки iostream

int main(int argc, char* argv[])
{
	// Русский язык в консольном приложении
	setlocale(LC_ALL, "Rus");
	// наш контейнер с яблоками в каждой из
	// секций которой лежит определенное количество яблок
	int apples[ROWS][COLUMNS] = {
									{ 2, 3, 1, 1, 0 },
									{ 0, 1, 2, 2, 0 },
									{ 1, 1, 1, 1, 1 },
									{ 3, 4, 1, 2, 3 },
									{ 2, 2, 0, 2, 1 }
	};

	cout << "Выводим массив на экран: " << endl;
	// Это цикл, в котором мы идем и заглядываем в каждую секцию
	// по пересечениям строк и столбцов
	// для этого необходим вложенный цикл for в основной цикл
	// после чего печатаем количество каждой секции на экран
	// строк у нас 5, это макрос ROWS
	// столбцов у нас 5, это макрос COLUMNS
	// setw(4) это манипулятор для форматирование строки на экране, 4 - это примерно
	// 4 пробела между символами.
	for (size_t i = 0; i < ROWS; i++) {
		for (size_t j = 0; j < COLUMNS; j++) {
			cout << setw(4) << apples[i][j];
		}
		cout << endl;
	}
	cout << endl;
	system("pause"); // Задержка.
	return 0;
}


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

Как и в одномерные массивы по ходу написания программы и ее исполнения мы можем изменять количество яблок в секциях контейнера нашего двумерного массива, например в ячейку с индексом[0][2] поместить восемь яблок, а в [2][4] сто яблок (размер каждой секции зависит от типа контейнера, он у нас int, а в C++ размер этого типа равен от -2 147 483 648 до 2 147 483 648). А вот размер самого контейнера и количества ячеек ( строки и колонки) мы пока изменять не можем. Для этой цели служит отдельный вид массивов, именуемый — динамическим.
В массив мы можем записать вещественные числа, символы и строки:
#include<iostream> // Стандартная библиотека ввода вывода
#include<iomanip>// Библиотека манипуляторов для форматирования потока

#define ROWS 3      // Обозначаем длину строки нашего контейнера(массива) для яблок
#define COLUMNS 3   // Обозначаем длину столбца нашего контейнера(массива) для яблок
using namespace std; // используем стандартное пространство имен библиотеки iostream

int main(int argc, char* argv[])
{
	// Русский язык в консольном приложении
	setlocale(LC_ALL, "Rus");
	// наш контейнер с яблоками в каждой из
	// секций которой лежит определенное количсетво яблок
	// Можно и без указания размера при инициализации,
	// компилятор автоматически создаст массив с необходимым размером
	int apples[][COLUMNS] = {
								{ 2, 1, 3 },
								{ 100, 21, 32 }
	};

	char chars[ROWS][COLUMNS] = {
									{ 'a', 'b', 'c' },
									{ 'd', 'e', 'f' }
	};

	float reals[ROWS][COLUMNS] = {
									{ 2.1, 1.3, 3.4 },
									{ 6.8, 0.2, 8.3 }
	};

	double doubleReals[ROWS][COLUMNS] = {
										{ 2.14, 1.333, 3.45 },
										{ 6.882, 0.223, 8.123}
	};
	string strings[ROWS][COLUMNS] = {
										{ "Вася", "Иван", "Петя" },
										{ "Вадим", "Curtis", "Gucci Mane"},
	};
	return 0;
}


Попробуем теперь решить несколько типовых академических задач.  Для начала заполним двумерный массив вручную. Для этого мы объявляем необходимый тип массива, его размерность (количество строк и столбцов) и во вложенном цикле вводим с клавиатуры значения до тех пор, пока не заполним весь массив согласно его размерности:
#include<iostream> // Стандартная библиотека ввода вывода
#include<iomanip>// Библиотека манипуляторов для форматирования потока

#define ROWS 5      // Обозначаем длину строки нашего контейнера(массива) для яблок
#define COLUMNS 5   // Обозначаем длину столбца нашего контейнера(массива) для яблок
using namespace std; // используем стандартное пространство имен библиотеки iostream

int main(int argc, char* argv[])
{
	// Русский язык в консольном приложении
	setlocale(LC_ALL, "Rus");
	// наш контейнер с яблоками в каждой из
	// секций которой лежит определенное количество яблок
	int apples[ROWS][COLUMNS];

	cout << "Введите числа, что бы заполнить массив: " << endl;
	// Это цикл, в котором мы заполняем наш двумерный массив вручную
	// для этого необходим вложить еще один цикл for в основной цикл

	for (size_t i = 0; i < ROWS; i++)
	{
		for (size_t j = 0; j < COLUMNS; j++)
		{
			cin >> apples[i][j];
		}
	}
	cout << endl;

	// Печатаем наш заполненый массив
	cout << "Выводим массив на экран: " << endl;
	for (size_t i = 0; i < ROWS; i++) {
		for (size_t j = 0; j < COLUMNS; j++) {
			cout << setw(4) << apples[i][j];
		}
		cout << endl;
	}
	cout << endl;
	system("pause"); // Задержка.
	return 0;
}


Давайте теперь попробуем заполнить массив случайными числами от 0 до 10. Для этого мы будем использовать знакомую из предыдущей статьи технику. Подключим header time.h  или  ctime:
#include<iostream> // Стандартная библиотека ввода вывода
#include<iomanip>// Библиотека манипуляторов для форматирования потока
#include<time.h> // Стандартная библиотека ввода вывода

#define ROWS 5      // Обозначаем длину строки нашего контейнера(массива) для яблок
#define COLUMNS 5   // Обозначаем длину столбца нашего контейнера(массива) для яблок
using namespace std; // используем стандартное пространство имен библиотеки iostream

int main(int argc, char* argv[])
{
	// Русский язык в консольном приложении
	setlocale(LC_ALL, "Rus");
	// наш контейнер с яблоками в каждой из
	// секций которой лежит определенное количество яблок
	int apples[ROWS][COLUMNS];

	cout << "Заполнение массива случайными числами от 1 до 10: " << endl;
	// Это цикл, в котором мы вручную заполняем наш двумерный массив
	// для этого необходим вложить еще один цикл for в основной цикл

	for (size_t i = 0; i < ROWS; i++) {
		for (size_t j = 0; j < COLUMNS; j++) {
			apples[i][j] = rand() % 11;
		}
	}

	// Печатаем наш заполненый массив
	cout << "Выводим массив на экран : " << endl;
	for (size_t i = 0; i < ROWS; i++) {
		for (size_t j = 0; j < COLUMNS; j++) {
			cout << setw(4) << apples[i][j];
		}
		cout << endl;
	}
	cout << endl;
	system("pause"); // Задержка.
	return 0;
}


И получаем результат (у вас результат может отличаться, функция rand(); может сгенерировать другие значения).:

Заполнить случайными числами наш двумерный массив позволила функция rand() % 11; Но в этом примере существует такая же проблема как и в случае с примером, когда мы заполняли одномерный массив случайными числами. Данный код генерирует случайные числа только один раз. При следующих запусках программы, в наш двумерный массив будут записаны те же случайные числа, что и в самый первый раз. Что бы уййти от этой проблемы, необходимо применить специальную функцию srand();.
Она на позволяет  устанавливать начало последовательности, генерируемой функцией rand() (функция rand() возвращает псевдослучайные числа). Функция srand() позволяет запускать программу несколько раз с различными последователь­ностями псевдослучайных чисел.
Добавим необходимую функцию в наш код:
#include<iostream> // Стандартная библиотека ввода вывода
#include<iomanip>// Библиотека манипуляторов для форматирования потока
#include<time.h> // Стандартная библиотека ввода вывода

#define ROWS 5      // Обозначаем длину строки нашего контейнера(массива) для яблок
#define COLUMNS 5   // Обозначаем длину столбца нашего контейнера(массива) для яблок
using namespace std; // используем стандартное пространство имен библиотеки iostream

int main(int argc, char* argv[])
{
	// Русский язык в консольном приложении
	setlocale(LC_ALL, "Rus");
	srand(time(NULL)); //  устанавливает в качестве базы текущее время. Этот прием часто используется для того,
	// чтобы при разных запусках генератора псевдослучайных чисел была всякий раз разная база и,
	// соответственно, разный ряд получаемых значений.

	// наш контейнер с яблоками в каждой из
	// секций которой лежит определенное количество яблок
	int apples[ROWS][COLUMNS];

	cout << "Заполнение массива случайными числами от 0 до 10: " << endl;
	// Это цикл, в котором мы вручную заполняем наш двумерный массив
	// для этого необходим вложить еще один цикл for в основной цикл

	for (size_t i = 0; i < ROWS; i++) {

		for (size_t j = 0; j < COLUMNS; j++) {
			apples[i][j] = rand() % 11;
		}
	}

	// Печатаем наш заполненый массив
	cout << "Выводим массив на экран : " << endl;
	for (size_t i = 0; i < ROWS; i++) {

		for (size_t j = 0; j < COLUMNS; j++) {
			cout << setw(4) << apples[i][j];
		}
		cout << endl;
	}
	cout << endl;
	system("pause"); // Задержка.
	return 0;
}


В этом случае, при каждом запуске нашей программы, у нас в массиве будут разные случайные числа.
Давайте мы теперь попробуем заполнить контейнер случайным количеством яблок и найдем, сколько ячеек, в которых находится четное количество яблок (наш двумерный массив заполним случайными числами и посчитаем все четные элементы). Для этого необходимо завести отдельную переменную и в отдельном вложенном цикле for проделать операцию с остатком от деления на 2 и проверить также на ноль.
for (int i = 0; i < ROWS; i++)
{
for (int j = 0; j < COLUMNS; j++)
{
if (apples[i][j] % 2 == 0 && apples[i][j] != 0)
{
counter++;
}
}
}



Запустим и увидим результат (у вас результат может отличаться, так как если вы помните, мы используем функцию srand();):
Исходный текст программы:

#include<iostream> // Стандартная библиотека ввода вывода
#include<iomanip>// Библиотека манипуляторов для форматирования потока
#include<time.h> // Стандартная библиотека ввода вывода

#define ROWS 5      // Обозначаем длину строки нашего контейнера(массива) для яблок
#define COLUMNS 5   // Обозначаем длину столбца нашего контейнера(массива) для яблок
using namespace std; // используем стандартное пространство имен библиотеки iostream

int main(int argc, char* argv[])
{
	// Русский язык в консольном приложении
	setlocale(LC_ALL, "Rus");
	srand(time(NULL)); //  устанавливает в качестве базы текущее время. Этот прием часто используется для того,
	// чтобы при разных запусках генератора псевдослучайных чисел была всякий раз разная база и,
	// соответственно, разный ряд получаемых значений.

	// наш контейнер с яблоками в каждой из
	// секций которой лежит определенное количество яблок
	int apples[ROWS][COLUMNS];
	int counter = 0;

	cout << "Заполнение массива случайными числами от 0 до 10: " << endl;
	// Это цикл, в котором мы вручную заполняем наш двумерный массив
	// для этого необходим вложить еще один цикл for в основной цикл

	for (size_t i = 0; i < ROWS; i++) {

		for (size_t j = 0; j < COLUMNS; j++) {
			apples[i][j] = rand() % 11;
		}
	}

	// Печатаем наш заполненый массив
	cout << "Выводим массив на экран : " << endl;
	for (size_t i = 0; i < ROWS; i++) {

		for (size_t j = 0; j < COLUMNS; j++) {
			cout << setw(4) << apples[i][j];
		}
		cout << endl;
	}
	cout << endl;

	for (int i = 0; i < ROWS; i++)
	{
		for (int j = 0; j < COLUMNS; j++)
		{
			if (apples[i][j] % 2 == 0 && apples[i][j] != 0)
			{
				counter++;
			}
		}
	}

	cout << "Количество четных элементов в массиве : " << counter << endl; 
	// Задержка.
	system("pause");
	return 0;
}


Давайте теперь попробуем подсчитать среднее арифметическое содержимого нашего контейнера с яблоками (среднее арифметическое всех элементов двумерного массива). Для этого нам необходимо завести отдельную переменную, в которую будем складывать все яблоки (сумму всех элементов массива), после чего, полученную переменную разделим на количество элементов в массиве (а это у нас размерность массива).
#include<iostream> // Стандартная библиотека ввода вывода
#include<iomanip>// Библиотека манипуляторов для форматирования потока
#include<time.h> // Стандартная библиотека ввода вывода

#define ROWS 5      // Обозначаем длину строки нашего контейнера(массива) для яблок
#define COLUMNS 5   // Обозначаем длину столбца нашего контейнера(массива) для яблок
using namespace std; // используем стандартное пространство имен библиотеки iostream

int main(int argc, char* argv[])
{
	// Русский язык в консольном приложении
	setlocale(LC_ALL, "Rus");
	srand(time(NULL)); //  устанавливает в качестве базы текущее время. Этот прием часто используется для того,
	// чтобы при разных запусках генератора псевдослучайных чисел была всякий раз разная база и,
	// соответственно, разный ряд получаемых значений.

	// наш контейнер с яблоками в каждой из
	// секций которой лежит определенное количество яблок
	int apples[ROWS][COLUMNS];
	float buffer = 0; // наша переменная, куда мы будем складывать сумму наших яблок

	cout << "Заполнение массива случайными числами от 0 до 10: " << endl;
	// Это цикл, в котором мы вручную заполняем наш двумерный массив
	// для этого необходим вложить еще один цикл for в основной цикл

	for (size_t i = 0; i < ROWS; i++) {
		for (size_t j = 0; j < COLUMNS; j++) {
			apples[i][j] = rand() % 11;
		}
	}

	// Печатаем наш заполненый массив
	cout << "Выводим массив на экран : " << endl;
	for (size_t i = 0; i < ROWS; i++) {
		for (size_t j = 0; j < COLUMNS; j++) {
			cout << setw(4) << apples[i][j];
		}
		cout << endl;
	}
	cout << endl;

	for (int i = 0; i < ROWS; i++) {
		for (int j = 0; j < COLUMNS; j++) {
			buffer += apples[i][j];
		}
	}

	cout << "Среднее арифметическое массива : " << buffer / (ROWS * COLUMNS) << endl;
	// Задержка.
	system("pause");
	return 0;
}


Получаем результат (у вас результат может отличаться, так как если вы помните, мы используем функцию srand();).

Одна из часто встречаемых задач — программа, которая будет показывать пользователю максимальное количество яблок на каждой из полочек (имеется ввиду максимальное значение элемента в каждой строке):
#include<iostream> // Стандартная библиотека ввода вывода
#include<iomanip>// Библиотека манипуляторов для форматирования потока
#include<time.h> // Стандартная библиотека ввода вывода

#define ROWS 5      // Обозначаем длину строки нашего контейнера(массива) для яблок
#define COLUMNS 5   // Обозначаем длину столбца нашего контейнера(массива) для яблок
using namespace std; // используем стандартное пространство имен библиотеки iostream

int main(int argc, char* argv[])
{
	// Русский язык в консольном приложении
	setlocale(LC_ALL, "Rus");
	srand(time(NULL)); //  устанавливает в качестве базы текущее время. Этот прием часто используется для того,
	// чтобы при разных запусках генератора псевдослучайных чисел была всякий раз разная база и,
	// соответственно, разный ряд получаемых значений.

	// наш контейнер с яблоками в каждой из
	// секций которой лежит определенное количество яблок
	int apples[ROWS][COLUMNS];
	int MAS_REZ[ROWS];
	int max;
	cout << "Заполнение массива случайными числами от 0 до 10: " << endl;
	// Это цикл, в котором мы вручную заполняем наш двумерный массив
	// для этого необходим вложить еще один цикл for в основной цикл

	for (size_t i = 0; i < ROWS; i++) {
		for (size_t j = 0; j < COLUMNS; j++) {
			apples[i][j] = rand() % 120;
		}
	}

	// Печатаем наш заполненый массив
	cout << "Выводим массив на экран : " << endl;
	for (size_t i = 0; i < ROWS; i++) {
		for (size_t j = 0; j < COLUMNS; j++) {
			cout << setw(4) << apples[i][j];
		}
		cout << endl;
	}
	cout << endl;

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

	for (size_t i = 0; i < ROWS; i++) {
		max = apples[i][0];

		for (size_t j = 0; j < COLUMNS; j++) {
			if (apples[i][j] > max)
			{
				max = apples[i][j];
			}
		}
		cout << "Максимальный элемент строки в матрице apples : " << max << endl;
	}

	// Задержка.
	system("pause");
	return 0;
}


И вот что получаем на выходе программы (у вас результат может отличаться, так как если вы помните, мы используем функцию srand();).:

Следующая задача будет состоять в том, что бы найти максимальное количество яблок в каждом вертикально расположенном столбце нашего контейнера.
#include<iostream> // Стандартная библиотека ввода вывода
#include<iomanip>// Библиотека манипуляторов для форматирования потока
#include<time.h> // Стандартная библиотека ввода вывода

#define ROWS 5      // Обозначаем длину строки нашего контейнера(массива) для яблок
#define COLUMNS 5   // Обозначаем длину столбца нашего контейнера(массива) для яблок
using namespace std; // используем стандартное пространство имен библиотеки iostream

int main(int argc, char* argv[])
{
	// Русский язык в консольном приложении
	setlocale(LC_ALL, "Rus");
	srand(time(NULL)); //  устанавливает в качестве базы текущее время. Этот прием часто используется для того,
	// чтобы при разных запусках генератора псевдослучайных чисел была всякий раз разная база и,
	// соответственно, разный ряд получаемых значений.

	int apples[ROWS][COLUMNS];   // наш контейнер с яблоками в каждой из
	// секций которой лежит определенное количество яблок

	//Заполняем массив случайными числами (случайным количеством яблок в каждой ячейки)
	for (int i = 0; i < ROWS; i++) {
		for (int j = 0; j < COLUMNS; j++) {
			apples[i][j] = rand() % 120;
		}
	}
	// Печатаем наш массив на экран пользователю
	for (int i = 0; i < ROWS; i++) {
		for (int j = 0; j < COLUMNS; j++) {
			cout << setw(4) << apples[i][j];
		}

		cout << endl;
	}
	cout << endl;

	//Запускаем цикл сравнения, в котором будем искать максимальное количество яблок в столбцах
	int maxValue;

	//Запускаем цикл сравнения
	for (int i = 0; i < 5; i++)
	{
		//Определяем переменную внутри цикла специально, чтобы при переходе на следующий стобик(т.е. новую итеррацию цикла)- она обнулялась
		int maxValue = 0;
		//Пробегаем циклом по каждому элементу столбика, каждый раз сравниваем исходный элемент со следующим, и с максимальным на данный момент. Если проверяемый
		//элемент больше последующего и больше максимального - то пересохраняем это значение в переменную
		for (int j = 0; j < ROWS; j++)
		{
			if ((apples[j][i] > apples[j + 1][i]) && (apples[j][i] > maxValue))
			{
				maxValue = apples[j][i];
			}
		}
		//Выводим на экран
		cout << "Элемент " << i + 1 << " максимальный в столбце: " << maxValue << endl;
	}

    // Задержка.
	system("pause");
	return 0;
}


После компиляции программы посмотрим результат (как вы уже понимаете, результаты в вашем случае могут быть другими):

Ффух, идем дальше. И я приведу пример очередной задачки, которая часто может встречаться на тернистом пути программиста. Среднее арифметическое мы уже находили, правда во всем нашем двумерном массиве. Давайте теперь попробуем найти среднее арифметическое каждой строки, после чего все эти числа поместить в одномерный массив.
#include<iostream> // Стандартная библиотека ввода вывода
#include<iomanip>// Библиотека манипуляторов для форматирования потока
#include<time.h> // Стандартная библиотека ввода вывода

#define ROWS 5      // Обозначаем длину строки нашего контейнера(массива) для яблок
#define COLUMNS 5   // Обозначаем длину столбца нашего контейнера(массива) для яблок
#define SIZE 5
using namespace std; // используем стандартное пространство имен библиотеки iostream

int main(int argc, char* argv[])
{
	// Русский язык в консольном приложении
	setlocale(LC_ALL, "Rus");
	srand(time(NULL)); //  устанавливает в качестве базы текущее время. Этот прием часто используется для того,
	// чтобы при разных запусках генератора псевдослучайных чисел была всякий раз разная база и,
	// соответственно, разный ряд получаемых значений.

	int apples[ROWS][COLUMNS];   // наш контейнер с яблоками в каждой из
	// секций которой лежит определенное количество яблок
	float buffer, averageApples[ROWS];
	//Заполняем массив случайными числами (случайным количеством яблок в каждой ячейки)
	for (size_t i = 0; i < ROWS; i++) {

		for (int j = 0; j < COLUMNS; j++) {
			apples[i][j] = rand() % 15;
		}

	}
	// Печатаем наш массив на экран пользователю
	for (size_t i = 0; i < ROWS; i++) {

		for (size_t j = 0; j < COLUMNS; j++) {
			cout << setw(4) << apples[i][j];
		}

		cout << endl;
	}
	cout << endl;

	//Запускаем цикл в котором будем искать среднее арифметическое
	int maxValue;

	for (size_t i = 0; i < ROWS; i++) {

		buffer = 0;
		for (size_t j = 0; j < COLUMNS; j++) {

			buffer += apples[i][j];
		}

		buffer = buffer / ROWS;
		// Заполняем наш одномерный массив полученными значениями ср. арифметического
		averageApples[i] = buffer;
		cout << "Среднее значение " << i << " строки: " << buffer << endl;
	}

	cout << "nОдномерный массив со средними арифметическими каждой строкиn"  << endl;
	// Выводим на экран наш одномерныый массив
	for (size_t i = 0; i < SIZE; i++) 
		cout << averageApples[i] << setw(2);

	system("pause");
	return 0;
}



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

А давайте теперь попробуем поработать с диагоналями матрицы! В матрице существует главная и побочная диагональ. На рисунке ниже, в контейнере с права зеленым показана линия главной диагонали. Соответственно справа — побочная диагональ.

Очень часто встречаются задачи, где необходимо перебирать элементы диагоналей, ниже или выше этих диагоналей и тд. Рассмотрим такой вариант задачи:  «Создайте двумерный массив 5*5. Метод заполнения произвольный.
 Выведите его. Все элементы главной диагонали занесите в одномерный массив и выведите его».
#include<iostream> // Стандартная библиотека ввода вывода
#include<iomanip>// Библиотека манипуляторов для форматирования потока
#include<time.h> // Стандартная библиотека ввода вывода

#define ROWS 5      // Обозначаем длину строки нашего контейнера(массива) для яблок
#define COLUMNS 5   // Обозначаем длину столбца нашего контейнера(массива) для яблок
#define SIZE 5
using namespace std; // используем стандартное пространство имен библиотеки iostream

int main(int argc, char* argv[])
{
	// Русский язык в консольном приложении
	setlocale(LC_ALL, "Rus");
	srand(time(NULL)); //  устанавливает в качестве базы текущее время. Этот прием часто используется для того,
	// чтобы при разных запусках генератора псевдослучайных чисел была всякий раз разная база и,
	// соответственно, разный ряд получаемых значений.

	int apples[ROWS][COLUMNS];   // наш контейнер с яблоками в каждой из
	// секций которой лежит определенное количество яблок
	int mainDiagonal[SIZE];      // одномерный массив, куда мы занесем все элементы главной диагонали матрицы apples
	//Заполняем массив случайными числами (случайным количеством яблок в каждой ячейки)
	for (size_t i = 0; i < ROWS; i++) {

		for (int j = 0; j < COLUMNS; j++) {
			apples[i][j] = rand() % 15;
		}

	}
	// Печатаем наш массив на экран пользователю
	cout << "Текущий массив : " << endl;

	for (size_t i = 0; i < ROWS; i++) {

		for (size_t j = 0; j < COLUMNS; j++) {
			cout << setw(4) << apples[i][j];
		}

		cout << endl;
	}
	cout << endl;

	//Запускаем цикл в котором будем искать элементы главной диагонали
	for (size_t i = 0; i < ROWS; i++) {

		for (size_t j = 0; j < i + 1; j++) {

			mainDiagonal[i] = apples[i][j];
		}
	}
	cout << endl;
	cout << "Массив с элементами главной диагонали" << endl;

	for (size_t i = 0; i < SIZE; i++) {

		cout << mainDiagonal[i] << setw(4);
	}

	// Задержка.
	system("pause > NULL");
	return 0;
}



Запустим нашу программу и посмотрим результат:

Все верно, в одномерный массив записались элементы главной диагонали нашего двумерного массива с «яблоками».
А теперь найдем все элементы побочной диагонали.
#include<iostream> // Стандартная библиотека ввода вывода
#include<iomanip>// Библиотека манипуляторов для форматирования потока
#include<time.h> // Стандартная библиотека ввода вывода

#define ROWS 5      // Обозначаем длину строки нашего контейнера(массива) для яблок
#define COLUMNS 5   // Обозначаем длину столбца нашего контейнера(массива) для яблок
#define SIZE 5
using namespace std; // используем стандартное пространство имен библиотеки iostream

int main(int argc, char* argv[])
{
	// Русский язык в консольном приложении
	setlocale(LC_ALL, "Rus");
	srand(time(NULL)); //  устанавливает в качестве базы текущее время. Этот прием часто используется для того,
	// чтобы при разных запусках генератора псевдослучайных чисел была всякий раз разная база и,
	// соответственно, разный ряд получаемых значений.

	int apples[ROWS][COLUMNS];   // наш контейнер с яблоками в каждой из
	// секций которой лежит определенное количество яблок
	int sideDiagonal[SIZE];      // одномерный массив, куда мы занесем все элементы главной диагонали матрицы apples
	//Заполняем массив случайными числами (случайным количеством яблок в каждой ячейки)
	for (size_t i = 0; i < ROWS; i++) {
		for (int j = 0; j < COLUMNS; j++) {
			apples[i][j] = rand() % 15;
		}
	}
	// Печатаем наш массив на экран пользователю
	cout << "Текущий массив : " << endl;

	for (size_t i = 0; i < ROWS; i++) {
		for (size_t j = 0; j < COLUMNS; j++) {
			cout << setw(4) << apples[i][j];
		}

		cout << endl;
	}
	cout << endl;

	//Запускаем цикл в котором будем искать элементы побочной диагонали
	for (size_t i = 0; i < ROWS; i++) {
		for (size_t j = 0; j < COLUMNS; j++) {
			if (j == ROWS - (i + 1)) {
				sideDiagonal[i] = apples[i][j];
			}
		}
	}
	cout << endl;
	cout << "Массив с элементами побочной диагонали" << endl;

	for (size_t i = 0; i < SIZE; i++) {
		cout << sideDiagonal[i] << setw(4);
	}

	// Задержка.
	system("pause > NULL");
	return 0;
}




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


В первом цикле мы бегаем по строкам двумерного массива;
Во втором (вложенном цикле for) мы бегаем по столбцам;
Элементы на главной диагонали — row = col;
Элементы ниже главной диагонали — col > row;
Элементы выше главной диагонали — col < row;
Элементы на побочной диагонали — col = Rows — row;
Элементы ниже побочной диагонали —  col > Rows — row;
Элементы выше побочной диагонали — col < Rows — row;

На этой ноте завершаю эту статью. Мы еще вернемся к массивам и матрицам. Но только после того, как научимся оперировать непосредственно с памятью и пощупаем указатели. Так что следующий этап у нас, да да — указатели =) До встречи!