Как найти максимальный размер массива

Всем привет, продолжу рубрику для начинающих. В первой части цикла я привел ряд популярных задач по С++. Во втором цикле я немного сменю формат и постараюсь более доступно объяснить материал. Поговорим мы в этот раз о таком мистическом элементе программирования как массив. По ходу описания теории , приведу примеры и типовые задачи, которые дают на лабораторных работах и контрольных в колледжах и институтах. Наверное нет популярнее вопроса у новичков: «Как найти минимальный и/или максимальный размер массива». Что же, вы скоро узнаете, как это сделать на примере написанной программы. Все программы я написал в среде Visual Studio 2015, вы можете использовать любой другой инструмент, например Code::Blocks или онлайн компиляторы.

Итак, что такое массив, это такой контейнер или коробочка в которую можно записывать переменные, литералы и значения. Допустим у нас есть яблоки, яблоки нам необходимо поместить в коробочку с секциями. В каждую секцию мы положим столько, сколько необходимо. Количество яблок в каждой секции — целое, т.е 1,2,5, 17 и тд. Покусанное яблоко или половинку мы в контейнер не помещаем. Соответственно тип нашего массива будет целочисленным — int. С++ строго типизированный язык программирования, поэтому мы не можем в целочисленный массив записать вещественное число (float или double) или символ (char).

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

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


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

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

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





  


                       
  




Теперь можно дать определение массиву. Что нам говорит по этому поводу Википедия:
Массив (в некоторых языках программирования также таблица, ряд, матрица) — тип или структура данных в виде набора компонентов (элементов массива), расположенных в памяти непосредственно друг за другом. При этом доступ к отдельным элементам массива осуществляется с помощью индексации, то есть через ссылку на массив с указанием номера (индекса) нужного элемента. За счёт этого, в отличие от списка, массив является структурой данных, пригодной для осуществления произвольного доступа к её ячейкам.
Очень удобно не правда-ли? Допустим нам нужно отдать тете Маше три яблока, а секции 2, 3, 4, 5, 6 зарезервированы для других людей. Значит мы можем взять яблоки из 0 и 1 секции, сложить их вместе, и отдать тете Маше.
#include<iostream> // Стандартная библиотека ввода вывода
#include<iomanip>// Библиотека манипуляторов для форматирования потока


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

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

	sumOfAplles = apples[0] + apples[1];
	cout << "Отдаем тете Маше " << sumOfAplles << " яблока" << endl;
	// Можно и так, без дополнительной переменной
	// cout << "Отдаем тете Маше " << apples[0] + apples[1] << " яблока" << endl;
	system("pause"); // Задержка.
	return 0;
}


По ходу написания программы мы можем изменять количество яблок в секциях контейнера, например в нулевую секцию поместить восемь яблок, а в четвертую сто яблок (размер каждой секции зависит от типа контейнера, он у нас int, а в C++ размер этого типа равен от -2 147 483 648 до 2 147 483 648). А вот размер контейнера(SIZE) мы изменять уже не сможем, для этой цели в языке С++ служат динамические массивы, позже мы о них поговорим.

В массив мы можем записать вещественные числа, символы и строки:
int main(int argc, char* argv[])
{
	// Русский язык в консольном приложении
	setlocale(LC_ALL, "Rus");
	// наш контейнер с яблоками в каждой из
	// секций которой лежит определенное количсетво яблок
	int apples[SIZE] = { 2, 1, 3, 6, 0, 8, 4 };
	// Можно и без указания размера при инициализации,
	// компилятор автоматически создаст массив с необходимым размером
	int apple[] = { 2, 1, 3, 6, 0, 8, 4 };
	char chars[SIZE] = { 'a', 'b', 'c', 'd', 'e', 'f', 'g' };
	float reals[SIZE] = { 2.1, 1.3, 3.4, 6.8, 0.2, 8.3, 4.9 };
	double doubleReals[SIZE] = { 2.14, 1.333, 3.45, 6.882, 0.223, 8.123, 4.999 };;
	string strings[SIZE] = {
	"Vasya", "Ivan", "Petya", "Sergey",
	"Vadim", "Curtis", "Gucci Mane"
	};
	return 0;
}


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



  


                       
  




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

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

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

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

		cout << "Введите количество яблок в каждой секции" << endl;
		cin >> apples[i];
		cout << "apples[" << i << "]= " << apples[i] << endl;
	}
	
	cout << "Выводим полученный массив" << endl;

	for (size_t i = 0; i < SIZE; i++)	{
		cout << apples[i] << setw(2);
	}
	cout << endl;

	system("pause");
	return 0;
}


Все, теперь мы умеем сами заполнять одномерный массив с клавиатуры. Имейте ввиду, что вводить необходимо только целые числа. Если вы введете символ или вещественное число — будет ошибка во время исполнения программы. В данном примере нет обработки такой ошибки, так как это совсем другая тема. Теперь заполним наш массив числами от 0 до 6, нам необходимо заменить строку
cin >> apples[i];
на
 apples[i] = i;:
#include<iostream> // Стандартная библиотека ввода вывода
#include<iomanip>// Библиотека манипуляторов для форматирования потока

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

int main(int argc, char* argv[])
{
	// Русский язык в консольном приложении
	setlocale(LC_ALL, "Rus");
	// наш контейнер с яблоками в каждой из
	// секций которой лежит определенное количество яблок
	int apples[SIZE];
	cout << "Количество яблок в каждой секции" << endl;
	// При каждой итерации мы записываем значение переменной i
	// в ячейку массива, изначально i у нас 0
	// поэтому в первую ячейку массива запишется 0,
	// а дальше все так же, только i+1
	for (size_t i = 0; i < SIZE; i++) {
		apples[i] = i;
		cout << "apples[" << i << "]= " << apples[i] << endl;
	}   system("pause");
	return 0;
}


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

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

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

	for (size_t i = 0; i < SIZE; i++) {
		// Заполняем случайными числами от 0 до 20
		apples[i] = rand() % 20;
		cout << "apples[" << i << "] = " << apples[i] << endl;
	}
	system("pause");
	return 0;
}



Получим вот такой результат:




  


                       
  




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

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

int main(int argc, char* argv[])
{
	// Русский язык в консольном приложении
	setlocale(LC_ALL, "Rus");
	// количество секунд, прошедших с 00:00:00 1970 года,
	// их можно преобразовывать в разные части времени с помощью остальных функций из time.h
	srand(time(NULL));
	// наш контейнер с яблоками в каждой из
	// секций которой лежит определенное количество яблок
	int apples[SIZE];
	cout << "Количество яблок в каждой секции" << endl;
	// При каждой итерации мы записываем случайное значение
	// в ячейку массива
	for (size_t i = 0; i < SIZE; i++) {
		// Заполняем случайными числами от 0 до 20
		apples[i] = rand() % 20;
		cout << "apples[" << i << "]= " << apples[i] << endl;
	}
	system("pause");
	return 0;
}


Теперь при каждом запуске программы генерируются различные числа в заданном диапазоне.
А что, если нам необходимо заполнить массив отрицательными числами, например от -20 до 0? В этом случае в нашей программе изменим строку
apples[i] = rand() % 20;
на
apples[i] = rand() % 20 + (-19);
и наш массив заполнится отрицательными числами в заданном диапазоне.



  


                       
  




Вот и подошли мы к концу статьи, и в этой части мы найдем эти злополучные максимум и минимум в нашем массиве. За основу мы возьмем нашу программу с яблочками. Как мы видим, в нашем массиве
int apples[SIZE] = { 2, 1, 3, 6, 0, 8, 4 };
минимальный элемент это ноль, находящийся в ячейке под номером четыре (apples[4]), а максимальный равен восьми, находящийся в ячейке массива под номером 5 (apples[5]).
#include<iostream> // Стандартная библиотека ввода вывода
#include<iomanip>// Библиотека манипуляторов для форматирования потока
#include<time.h> // Библиотека времени

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

int main(int argc, char* argv[])
{
	//Русский язык в консольном приложении
	setlocale(LC_ALL, "Rus");
	// наш контейнер с яблоками в каждой из
	// секций которой лежит определенное количество яблок
	int apples[SIZE] = { 2, 1, 3, 6, 0, 8, 4 };
	// Для удобства заводим две новые переменные
	int min = apples[0], max = apples[0];
	for (size_t i = 0; i < SIZE; i++) {
		if (apples[i] < min) {
			min = apples[i];
		}
	}
	cout << "Минимальный элемент массива равен " << min << endl;

	for (size_t i = 0; i < SIZE; i++) {
		if (apples[i] > max) {
			max = apples[i];
		}
	}

	cout << "Максимальный элемент массива равен " << max << endl;
	system("pause"); // Задержка.
	return 0;
}


Что мы тут сделали, мы объявили две целочисленные переменные min и max и присвоили им первый элемент массива. А дальше мы бегаем по циклам и сравниваем элемент массива с первым элементом в массиве. В случае с минимальным значением, проверяем текущий элемент массива с нулевым индексом массива и если он меньше, записываем текущий индекс массива в переменную min. То же самое, только наоборот, с поиском максимального значения. Если текущий элемент массива больше первого элемента массива с нулевым индексом, то мы записываем значение в переменную max.
В следующий раз поговорим о двумерных массивах или, как их еще часто называют, матрицах. Продолжение следует…