На этой странице относительно подробно рассказывается о статических и динамических массивах. Краткое изложение основных моментов и описание методов поиска ошибок доступны при нажатии на кнопки выше. Двумерные массивы описаны на этой странице.
Массив – это линейно упорядоченная совокупность однотипных элементов. Массив определяется типом элементов (int, double, ...) и длиной. Доступ к элементам осуществляется по индексу – порядковому номеру элемента массива. Логически первый элемент массива имеет индекс ноль. В языке Си существуют статические массивы, число элементов в которых должно быть известно в момент компиляции программы, и динамические массивы, размер которых задается в процессе выполнения программы, то есть может зависеть от входных данных. Эти два типа отличаются только методом создания массива, поэтому сначала рассмотрим статические массивы.
Объявление статического массива отличается от объявления обычной переменной только указанием количества элементов массива. Например, следующее объявление означает, что именем points называется массив из 100 действительных чисел.
double points[100];double points[100];
int students[100];#define NPOINTS 100
#define NSTUDENTS 100
...
double points[NPOINTS];
int students[NSTUDENTS];double points[] = {1.0, 3.14, -1.2, 12.65};
Для доступа к элементу массива достаточно знать его имя и
порядковый номер элемента. В языке Си элементы массива
индексируются начиная с нуля, то есть в массиве
из двух элементов корректными являются индексы 0 и 1. Если массив
имеет имя array, то его k-й элемент записывается
как array[k]. Это выражение может использоваться как
для получения значения элемента массива, так и для его изменения,
если оно стоит в левой части оператора присваивания. Рассмотрим
для примера следующую программу.
#define NPOINTS 100
int main() {
double points[NPOINTS];
int k;
points[0] = 0.1;
for(k=1; k < NPOINTS; k++) {
points[k] = 0.1 + points[k-1];
}
return 0;
}Пример работы с массивом, который задан с начальными значениями:
int main() {
double points[] = {1.0, 3.14, -1.2, 12.65};
int k;
int npoints = sizeof(points)/sizeof(points[0]);
for(k=0; k < npoints; k++) {
printf("points[%d] = %lf\n", k, points[k]);
}
return 0;
} Типичная ошибка при работе с массивами состоит в указании неправильного индекса. Если в приведенной выше программе переменная цикла k будет пробегать значения от 0 до npoints включительно, то поведение программы, вообще говоря, может быть любым. Наиболее вероятным поведением является вывод на экран какого-то значения, но может возникнуть и критическая ошибка, которая приведет к аварийной остановке программы.
В памяти ЭВМ элементы массива записаны последовательно без пропусков. Имя массива является указателем на его начальный элемент (с индексом 0). Поскольку в массиве все элементы имеют одинаковый тип, то зная адрес начала массива (A), размер одного элемента (size) и индекс k можно вычислить адрес размещения k-ого элемента: A + k*size. Если требуется получить значение k-ого элемента массива, то достаточно выполнить одно умножение (k*size), одно сложение (A + k*size) и загрузить значение из памяти по только что вычисленному адресу. Таким образом, обращение к элементу массива очень эффективно и сложность этой операции не зависит от величины индекса k: получение (или изменение) значения нулевого элемента столь же эффективно, как и миллионного.
Хорошо, адрес начала массива мы знаем — это его имя,
индекс нам известен, но как узнать size (размер одного
элемента)? Чуть ниже мы узнаем как это сделать, но для работы с
указателями на элементы массива это не требуется! В языке
Си к указателям можно прибавлять целые
числа. Например, если есть
указатель double *a;, то значением
выражения a+9 будет адрес десятого (еще раз
вспомним, что массивы индексируются с нуля!) элемента массива,
который начинается с адреса a. Компилятор сам
понимает, что a является указателем на double и
прибавляет нужное значение.
Обратной стороной последовательно хранения элементов в памяти является сложность вставки нового значения с сохранением порядка следования элементов. Например, если в массив нужно добавить новое значение по индексу 0, то чтобы "освободить" место все элементы массива придется сдвинуть на одну позицию. Ясно, что сложность этой операции зависит от длины массива. Чем больше длина, тем дольше выполняется это действие.
Функция может получать на вход массив. В действительности в функцию передается адрес начала массива и его длина. Прототип функции может быть оформлен либо так:
int print_array(double x[], int len);int print_array(double *x, int len);Рассмотрим возможную реализацию функции распечатывания массива.
#include <stdio.h>
int print_array(double x[], int len) {
int k;
for(k = 0; k < len; k++) {
printf("x[%d] = %lf\n", k, x[k]);
}
return 0;
}При вызове функции в качестве аргумента нужно передавать имя массива и его длину.
int main() {
double points[] = {1.0, 3.14, -1.2, 12.65};
int npoints = sizeof(points)/sizeof(points[0]);
print_array(points, npoints);
return 0;
}x[k]=0;), то изменятся значения и в
массиве points функции main. Элементы массива при вызове функций
не копируются! Функция получает на вход адрес памяти, где
записаны элементы массива. Эта память "общая" для вызывающей и
вызываемой функции.
Статические массивы имеют одно существенное ограничение: размер массива должен быть известен в момент компиляции программы. В большинстве задач размер данных становится известным только в момент выполнения программы. Например, вы написали программу для обработки списка друзей или подписчиков в социальной сети. У одного пользователя друзей мало, а у другого — очень много. Какое значение выбрать для длины массива друзей? 200? 1000? Миллион? Если константа будет очень большой, чтобы "заведомо" (посмотрите как росло число пользователей Интернет) устраивать всех пользователей, то для подавляющего числа пользователей это приведет к излишним затратам памяти. Захотите ли Вы поставить на свой телефон программу, которая при запуске займет всю его память с сообщением: "А вдруг у тебя миллион друзей. Нет? Всего 12?! Неплохо, прямо как у Oушена! А y Трампа миллион..."? [Друзей не должно и не может быть так много, но это к делу не относится.] Чтобы избежать таких ситуаций нужно уметь выделять минимально необходимое количество памяти.
Динамические массивы — это массивы, память для хранения которых выделяется в момент выполнения программы. Программист на языке Си отвечает за:
Стандартная библиотека языка Си содержит несколько функций для
работы с динамической памятью. Нам понадобятся
две: malloc
(memory allocation —
выделение памяти) и free (освобождение). Для
использования этих удивительных функций нужно в программе
подключить заголовочный
файл <stdlib.h>. Пример программы приведен
ниже. Сначала посмотрим, что делают эти функции.
void *malloc(size_t size); size — беззнаковое целое число, размер запрашиваемой памяти в байтах.
void * — это "абстрактный"
указатель на память, который может быть приведен к
указателю на любой тип. Функция malloc не может сразу возвращать
указатель нужного типа, так как она используется для создания
разных массивов, а в прототипе нужно указать конкретный тип
возвращаемого значения.
Для выделения памяти под массив из n элементов
типа T, где в T могут быть стандартные
типы int, double и т.п., необходимо
знать размер значения T в байтах. Для определения этой величины
в языке Си есть специальный оператор sizeof,
который в момент компиляции программы вычисляет нужное
значение. Например, массив из n целых чисел будет занимать
n*sizeof(int) байт памяти.
Таким образом, для создания динамического массива некоторого типа, например с массива целых чисел, нужно использовать команду вида:
int length;
int *points;
// ... получили значение length (длина массива)
points = (int *)malloc(length * sizeof(int));double,
то int заменяется на нужное имя (double)
в трех местах (кроме первой строки, так как длина массива всегда
является целым числом).
Функция free позволяет освободить область памяти, которая ранее была выделена программе при вызове malloc.
void free(void *ptr);
ptr — указатель, который был получен в результат вызова malloc.
В качестве аргумента функции free может использоваться только тот адрес, который был получен в результате вызова malloc. Нельзя создать статический массив и "освободить" его функцией free. Адрес может быть освобожден только один раз. Если два раза подряд вызвать функцию free с одним и тем же аргументом, то это приведет к аварийному завершению программы.
В качестве иллюстрации описанных методов рассмотрим программу, которая динамически выделяет память под массив и считывает его.
#include <stdio.h>
#include <stdlib.h>
int main() {
int npoints;
double *points;
int k;
scanf("%d", &npoints); /* npoints получает значение в момент выполнения программы */
points = (double *)malloc(npoints*sizeof(double));
/* Выдели память для хранения npoints элементов, каждый размера sizeof(double) */
if(points == NULL) {
printf("Произошла ошибка. Запросили слишком много памяти??\n");
return -1;
}
/* Считываем данные с использованием адресной арифметики */
k = 0;
while(k < npoints && scanf("%lf", points+k) == 1) {
k++;
}
/* Работаем с points как с обычным массивом */
/* Например, вызываем функцию print_array(points, npoints) */
free(points); /* Освободили память */
return 0;
}
Иногда бывает удобно сделать функцию, которая возвращает динамически
созданный массив. Примером может служить функция считывания
массива из файла. Такая функция может получать на вход файловую
переменную (FILE *) и должна вернуть в вызывающую
функцию массив значений. Например, массив действительнах
чисел. Попробуем ее реализовать.
Во-первых, нужно понять, какой прототип должна иметь такая функция. Она
должна вернуть два значения: адрес выделенной памяти и длину
массива. Как мы уже знаем, несколько значений можно вернуть
используя указатели. Длина массива имеет
тип int. Значит параметр функции будет иметь
тип int * (адрес, по которому нужно записать
значение). Массив — это адрес нулевого элемента, то
есть double *. Значит параметр будет иметь
тип double ** — "указатель на указатель". Мы
должны передать адрес (одна звездочка), по которому нужно записать
результат вызова malloc, который имеет тип double *. В результате получаем следующий прототип:
int read_array(FILE *input, double **array, int *length);int) может
быть кодом ошибки. Если функция вернет 0, то это означает успешное
выполнение. Любое ненулевое значение означает ошибку.
Теперь можно рассмотреть структуру тела функции (для наглядности в приведенном ниже коде отсутствуют проверки успешности считывания и корректности данных).
int read_array(FILE *input, double **array, int *length) {
double *arr;
int arr_length, k;
/* Считываем массив: сначала длину, потом элементы */
fscanf("%d", &arr_length);
arr = (double *)malloc(arr_length * sizeof(double));
for(k = 0; k < arr_length; k++)
fscanf("%lf", arr + k);
/* Копируем результат по заданным адресам */
*length = arr_length;
*array = arr;
return 0;
}