П усть нам необходимо работать с большим количеством однотипных данных. Например, у нас есть тысяча измерений координаты маятника с каким-то шагом по времени. Создавать 1000 переменных для хранения всех значений очень. обременительно. Вместо этого множество однотипных данных можно объединить под одним именем и обращаться к каждому конкретному элементу по его порядковому номеру.
Массив в си определяется следующим образом
[];
Например,
int a[100];
Мы получим массив с именем a, который содержит сто элементов типа int. Как и в случае с переменными, массив содержит мусор.
Для получения доступа до первого элемента, в квадратных скобках пишем его номер (индекс). Например
#include #include void main()
Первый элемент имеет порядковый номер 0. Важно понимать, почему. В дальнейшем будем представлять память компьютера в виде ленты. Имя массива — это указатель на адрес памяти, где располагаются элементы массива.
Язык Си для начинающих / #3 — Массивы данных
Индекс массива указывает, на сколько байт необходимо сместиться относительно начала массива, чтобы получить доступ до нужно элемента. Например, если массив A имеет тип int, то A[10] означает, что мы сместились на 10*sizeof(int) байт относительно начала. Первый элемент находится в самом начале и у него смещение 0*sizeof(int) .
В си массив не хранит своего размера и не проверяет индекс массива на корректность. Это значит, что можно выйти за пределы массива и обратиться к памяти, находящейся дальше последнего элемента массива (или ближе).
Начальная инициализация массива.
Н апишем простую программу. Создадим массив, после чего найдём его максимальный элемент.
#include #include void main() < int a[10] = ; unsigned i; int max; max = a[0]; for (i = 1; i max) < max = a[i]; >> printf(«max element is %d», max); getch(); >
Разберём пример. Сначала мы создаём массив и инициализируем его при создании. После этого присваиваем максимальному найденному элементу значение первого элемента массива.
max = a[0];
После чего проходим по массиву. Так как мы уже просмотрели первый элемент (у него индекс 1), то нет смысла снова его просматривать.
Тот же пример, только теперь пользователь вводит значения
#include #include void main() < int a[10]; unsigned i; int max; printf(«Enter 10 numbersn»); for (i = 0; imax = a[0]; for (i = 1; i max) < max = a[i]; >> printf(«max element is %d», max); getch(); >
В том случае, если при инициализации указано меньше значений, чем размер массива, остальные элементы заполняются нулями.
#include #include void main() < int a[10] = ; unsigned i; for (i = 0; i getch(); >
Если необходимо заполнить весь массив нулями, тогда пишем
int a[10] = ;
Можно не задавать размер массива явно, например
Создание и заполение массива на Си
int a[] = ;
массив будет иметь размер 3
Размер массива
М ассив в си должен иметь константный размер. Это значит, что невозможно, например, запросить у пользователя размер, а потом задать этот размер массиву.
printf(«Enter length of array «); scanf(«%d»,
Создание динамических массивов будет рассмотрено дальше, при работе с указателями и памятью
В некоторых случаях можно узнать размер массива с помощью функции sizeof.
#include #include void main() < int A[57]; //sizeof возвращает размер всего массива в байтах //Для определения количества элементов необходимо //разделить размер массива на размер его элемента int size = sizeof(A) / sizeof(int); printf(«Size of array equals to %d», size); getch(); >
Но это вряд ли будет полезным. При передаче массива в качестве аргумента функции будет передаваться указатель, поэтому размер массива будет невозможно узнать.
Статические массивы удобны, когда заранее известно число элементов. Они предоставляют быстрый, но небезопасный доступ до элементов.
Переполнение массива
П ускай у вас есть такой код
int A[10]; int i; for (i=0; i
- 1. Используйте тип size_t для индексирования. Он обезопасит вас от отрицательных значений и его всегда хватит для массива любого размера.
- 2. Помните, что массив начинается с нуля.
- 3. Последний элемент массива имеет индекс (размер массива — 1)
Примеры
Т еперь несколько типичных примеров работы с массивами
1. Переворачиваем массив.
#include #include //Это макрос. SIZE в коде будет заменено на 10u #define SIZE 10u void main() < int A[SIZE] = ; unsigned i, j; //счётчики unsigned half; //середина массива unsigned tmp; //временная переменная для обмена значениями half = SIZE / 2; //Один счётчик идёт слева напрво, другой справа налево for (i = 0, j = SIZE — 1; i < half; i++, j—) < tmp = A[i]; A[i] = A[j]; A[j] = tmp; >for (i = 0; i < SIZE; i++) < printf(«%d «, A[i]); >getch(); >
Здесь незнакомая для вас конструкция
#define SIZE 10u
макрос. Во всём коде препроцессор автоматически заменит все вхождения SIZE на 10u.
2. Удаление элемента, выбранного пользователем.
#include #include #define SIZE 10u void main() < int A[SIZE] = ; unsigned i; //счётчик int index; //индекс, введённый пользователем //Выводим массив for (i = 0; i < SIZE; i++) < printf(«(%d)=%d «, i, A[i]); >//Просим пользователя ввести валидный индекс while (1) < printf(«nEnter index of element to delete «); scanf(«%d», if (index >0 index < SIZE) < break; >> //Копируем следующий элемент массива на место удаляемого //и так до конца for (i = index; i < SIZE-1; i++) < A[i] = A[i+1]; >//Выводим результат for (i = 0; i < SIZE-1; i++) < printf(«(%d)=%d «, i, A[i]); >getch(); >
Удаление элемента в данном случае, конечно, не происходит. Массив остаётся того же размера, что и раньше. Мы просто затираем удаляемый элемент следующим за ним и выводим SIZE-1 элементов.
3. Пользователь вводит значения в массив. После этого вывести все разные значения, которые он ввёл.
Пусть пользователь вводит конечное число элементов, допустим 10. Тогда заранее известно, что всего различных значений будет не более 10. Каждый раз, когда пользователь вводит число будем проходить по массиву и проверять, было ли такое число введено.
#include #include #define SIZE 10u void main() < int A[SIZE] = ; unsigned i, j; int counter = 1; //сколько разных чисел введено. Как минимум одно. int input; int wasntFound; //флаг, что введённое число не было найдено //Вводим первое число. Оно ещё не встречалось. printf(«0. «); scanf(«%d», for (i = 1; i < SIZE; i++) < printf(«%d. «, i); scanf(«%d», wasntFound = 1; //Проверяем, встречалось ли такое число.
Если да, //то выставляем флаг и выходим из цикла for (j = 0; j > //Если флаг был поднят, то заносим число в массив if (wasntFound) < A[counter] = input; counter++; >> for (i = 0; i < counter; i++) < printf(«%d «, A[i]); >getch(); >
4. Пользователь вводит число — количество измерений (от 2 до 10). После этого вводит все измерения. Программа выдаёт среднее значение, дисперсию, погрешность.
#include #include #include #define SIZE 20u void main() < //Коэффициенты Стьюдента идут, начиная с двух измерений const float student[9] = ; float A[SIZE]; unsigned i; unsigned limit; float tmp; float sum = .0f; float mean; float disp; float absError; float relError; do < printf(«Enter number of measurements «); scanf(«%u», if (limit >1 limit < 11) < break; >> while(1); for (i = 0; i < limit; i++) < printf(«#%d: «, i); scanf(«%f», sum += A[i]; >mean = sum / (float)limit; sum = .0f; for (i = 0; i < limit; i++) < tmp = A[i] — mean; sum += tmp * tmp; >disp = sum / (float)limit; absError = student[limit — 2] * sqrt(sum / (float)(limit — 1)); relError = absError / mean * 100; printf(«Mean = %.6fn», mean); printf(«Dispertion = %.6fn», disp); printf(«Abs. Error = %.6fn», absError); printf(«Rel. Error = %.4f%», relError); getch(); >
5. Сортировка массива пузырьком
#include #include #define SIZE 10 #define false 0 #define true !false void main() < float a[] = ; float tmp; unsigned i, j; char flag; //Выводи массив for (i = 0; i < SIZE; i++) < printf(«%.3f «, a[i]); >printf(«n»); //Пока массив не отсортирован do < flag = false; //Проходим по массиву. Если следующий элемент больше предыдущего, то //меняем их местами и по новой проверяем массив for (i = 1; i < SIZE; i++) < if (a[i] >a[i — 1]) < tmp = a[i]; a[i] = a[i — 1]; a[i — 1] = tmp; flag = true; >> > while(flag == true); //Выводим отсортированный массив for (i = 0; i < SIZE; i++) < printf(«%.3f «, a[i]); >getch(); >
6. Перемешаем массив. Воспользуемся для этого алгоритмом Fisher-Yates:
Для i от N-1 до 1 выбираем случайное число j в пределах от 0 до i и меняем местами i-й и j-й элементы.
#include #include #include #include void main() < //Сегодня вместо макроса я решил использовать константу const int SIZE = 20; //Размер массива должен быть задан явно, как «константное выражение» int A[20] = < 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0>; int i, rnd; int tmp; //Инициализируем генератор псевдослучайных чисел //В качестве начального числа берём системное время srand(time(NULL)); //Алгоритм Дюрштенфельда, модифицированный алгоритма Фишера-Ятса //Элементарный алгоритм, записать который легче, чем выучить название for (i = SIZE — 1; i > 0; i—) < rnd = rand() % i; //Случайное число в пределе от 0 до i tmp = A[i]; A[i] = A[rnd]; A[rnd] = tmp; >for (i = 0; i < SIZE; i++) < printf(«%d «, A[i]); >getch(); >
Всё ещё не понятно? – пиши вопросы на ящик
Источник: learnc.info
Массивы в C (часть 1)
Массивы — очень полезные сущности, особенно в тех случаях, когда необходимо под одним именем объединить группы переменных одного и того же типа, обращаться к таким переменным можно через целочисленный индекс. Например, всем известная игра крестики нолики может быть представлена в виде массива. Размер поля — 3*3 клетки (левая верхняя ячейка может быть нулевым элементом, а правая нижняя клетка 8-м элементом массива). На самом деле, массивы — это самый эффективный способ для хранения большого количества однотипной информации под одним и тем же названием. Массивы могут иметь абсолютно любой тип данных, включая структуры и классы.
Массив можно представить как набор ячеек:
Каждая пара квадратных скобочек — это элемент массива, в каждом элементе массива можно хранить отдельное значение.
Пора приступить к изучению синтаксиса объявления массива:
int instanceArray[10]; // мы объявили массив
Одномерные массивы
Массив – это простейший составной тип данных. Когда мы обсуждали переменные, у нас была хорошая аналогия с коробкой. Вернёмся к ней. Если переменная – это один ящик, то массив – это несколько пронумерованных одинаковых ящиков, которые имеют одно и то же имя, а различаются между собой только порядковым номером.
Рис.1 Переменные и массивы. Аналогия с коробками.
На картинке выше изображено три массива:
- целочисленный массив из 8 элементов с именем arr_int
- вещественный массив из 11 элементов с именем arr_float
- символьный массив из 6 элементов с именем arr_char
У массива, как и у переменной, имеются свои имя и тип данных. Кроме того, у массива ещё есть одна дополнительная характеристика – размер массива. Размер массива – количество элементов, которые могут в нём храниться. В нашей аналогии с коробочками это количество коробок.
Нумерация элементов массива начинается с нуля, а не с единицы.
Объявление и инициализация массива
Объявление массива очень похоже на объявление переменной. Отличие лишь в том, что следует дополнительно указать размер массива в квадратных скобках. Вот несколько примеров:
int arr_int[8]; double arr_float[11]; float number[2000];
На имя массива накладываются ограничения, аналогичные тем, которые накладываются на имя переменной.
Правило именования массивов
Имя массива – любая последовательность символов, цифр и знака нижнего подчеркивания «_», которая начинается с буквы. Регистр букв важен.
Вот ещё несколько примеров объявления массивов:
int grades[50], order[10]; double prices[500];
Массиву, как и любой переменной, можно присвоить начальные значения при объявлении. Если элементам массива не присвоить никакого значения, то в них будет храниться мусор, как и в обычных переменных.
int arr_int[5] = ; double arr_float[11] = ;
Если нужно присвоить нулевые значения всем элементам массива, то можно сделать вот так:
double arr[50] = ;
Работа с отдельными элементами массива
Чтобы обратиться к отдельному элементу массива, необходимо написать его имя и порядковый номер в квадратных скобках. Не забывайте, что нумерация начинается с нуля, а не с единицы.
Давайте, например, выведем элементы массива из пяти элементов на экран.
#include int main(void)< int arr[5] = ; printf(«%d %d %d %d %dn»,arr[0], arr[1], arr[2], arr[3], arr[4]); return(0); >
Конечно, если массив будет очень большой, то выводить его поэлементно подобным образом то ещё удовольствие. Да и с маленькими массивами так никто не делает. Лучше и правильнее использовать циклы. Например:
#include int main(void)< int arr[100] = ; for(int i = 0; i < 100; i = i + 1)< arr[i] = 2*i; >for(int i = 0; i < 100; i = i + 1)< printf(«%dt»,arr[i]); >return(0); >
Программа в первом цикле сохраняет в массив первую сотню чётных чисел, а во втором цикле выводит их на экран.
Вооружившись новыми инструментами, давайте перепишем нашу программу из начала урока так, чтобы она использовала массив для хранения статистики выпадения случайных чисел.
#include #include #include int main(void) < srand(time(NULL)); int count[3] = ; int rand_number; for (int i = 0; i < 100000; i = i + 1)< rand_number = rand()%3; count[rand_number] = count[rand_number] + 1; >for(int i = 0; i < 3; i = i + 1)< printf(«%d — %dn», i, count[i]); >return 0; >
Обратите внимание на приём, который используется в этой программе.
В нулевом элементе массива хранится количество выпадений числа 0 , в первом элементе – количество выпадений числа 1 , во втором элементе – числа 2 . То есть само сгенерированное число позволяет определить, к какому элементу массива необходимо добавить единичку. Поэтому необходимость в операторе выбора switch отпадает. Удобно, не так ли?
Сохрани в закладки или поддержи проект.
Практика
Решите предложенные задачи:
Для удобства работы сразу переходите в полноэкранный режим
Дополнительные материалы
- пока нет
Самый крупный донат:
Аноним с карты * 1728 485 руб
Аноним с карты * 1339 291 руб
Оставить комментарий
Чтобы код красиво отображался на странице заключайте его в теги [code] здесь писать код [/code]
Комментарии
Алекс 23.12.2017 в 19:15
>> вещественный массив из 11 элементов с именем arr_double
arr_float же XD
KaDeaT
Так точно! Поправил. Спасибо! )
JJJ 05.01.2018 в 22:37
Очень не хватает примеров задач, никак не могу понять, как можно решить даже самую первую задачу
#include
int main() int i,a,b,s,d,c,;
scanf(«%d%d%d%d%d%d», a,s,c);
int arr[i] = < a,b,s,d,c >;/считается недопустимым а как с помощью циклов я понять не могу
printf(«%d %d %d %d %d», c, d, s, b, a);
return 0;
>
KaDeaT
0. Создать массив из 100 элементов. Например, с именем arr. 100 — ‘то максимальный размер массива, который может быть в задачах.
1. Считать в целочисленную переменную, например, с именем N, количество чисел в массиве (длину массива).
2. Далее запустить цикл for от 0 до N. В теле цикла считывать число в очередной элемент массива, например, scanf(«%d»,
Всё. Теперь все данные, которые поступали на вход у вас хранятся в массиве.
не_робот 18.05.2019 в 12:32
Примеров мало, вообще не понятно с какой стороны подступиться к первой же задаче.
В вашем комментарии «1. Считать в целочисленную переменную, например, с именем N, количество чисел в массиве (длину массива).» всё здорово, кроме примера которого нет, для наглядности можно было его показать
Анатолий 06.05.2021 в 00:08
По листингу 6 — «Программа в первом цикле сохраняет в массив первую сотню чётных чисел, а во втором цикле выводит их на экран.»
На самом деле сохраняет первые две сотни четных чисел
Элай 25.08.2021 в 09:05
Не понимаю как работает код в листинге 7
Алеша 18.12.2021 в 20:00
Не бро, не похвалю твои уроки, новички не очень поймут , какой то ты странный и задачи странные, лучше уж видеоуроки на ютубе или Udemy
KaDeaT
Задачи — топ! =)
Но у каждого свой путь, конечно!
Руслан 05.05.2022 в 14:39
Листинг 6. 2*0 == 0 — это особенность Си?
Valeriy 20.06.2023 в 21:27
Задача проверку палиндромного массива. Не понимаю, почему не принимается ответ. Тестирую в визуал студио
Работает как в условии вроде
#include
int main(void)
int size;
int count = 0;
int out = 0;
scanf(«%d»,
int array[size — 1];
while (count < size)
scanf(«%d»,
count++;
>
count = 0;
while (count < size / 2)
if (array[count] == array[size — 1 — count])
out = 1;
>
else
out = 0;
break;
>
count++;
>
if (out == 1)
printf(«YES»);
else
printf(«NO»);
return 0;
>
Valeriy 21.06.2023 в 19:16
Разделить массив на две части, поместив в первую элементы, большие среднего арифметического массива, а во вторую — меньшие.
задача решается, но не принимается системой
#include
main(void)
int size=0, count = 0;
float average = 0,sum=0;
scanf(«%d»,
int array[size];
int res[size];
int begin_count;
int end_count;
while (count < size)
scanf(«%d»,
count++;
>
count = 0;
while (count < size)
sum += array[count];
count++;
>
average = sum / size;
// printf(«AverAGE: %.2f n», average );
count = 0;
begin_count=0;
end_count=(size/2);
while (count if (array[count] > average )
res[begin_count] = array[count];
// printf(«Begin Count — %d! Adding there %dn», begin_count, array[count]);
begin_count++;
>
else
res[end_count] = array[count];
// printf(«End Count — %d! Adding there %dn», end_count, array[count]);
end_count++;
>
count++;
>
count = 0;
while (count < size)
printf(«%d «, res[count]);
count++;
>
return 0;
>
Valeriy 21.06.2023 в 21:40
В заданном массиве поменять местами наибольший и наименьший элементы.
задача решается, но не принимается системой
#include
main(void)
int size, count;
int temp, min,max;
int min_position =0, max_position=0;
scanf(«%d»,
int array[size];
min = array[0];max = array[0];count =0;
while (count < size)
scanf(«%d»,
if (array[count] < min)
min = array[count];
min_position= count;
>
if (array[count] > max)
< max = array[count];
max_position = count ;
>
count++;
>
temp = array[min_position];
array[min_position] = array[max_position];
array[max_position] = temp;
count = 0;
while (count < size)
printf(«%d «, array[count]);
count++;
>
return 0;
>
Источник: youngcoder.ru