13. Массивы и указатели
Между массивами и указателями существует очень тесная связь, поэтому обычно их рассматривают вместе. Но, прежде чем исследовать эту связь, давайте проверим наши знания о массивах и пополним их, а уж после этого перейдем к изучению связи между массивами и указателями.
Вы уже знаете, что массив представляет собой группу элементов одного типа. Когда нам требуется для работы массив, мы сообщаем об этом компилятору при помощи операторов описания. Для создания массива компилятору необходимо знать тип данных и требуемый класс памяти, т. е. то же самое, что и для простой переменной (называемой «скалярной»). Кроме того, должно быть известно, сколько элементов имеет массив. Массивы могут иметь те же типы данных и классы памяти, что и простые переменные, и к ним применим тот же принцип умолчания. Рассмотрим примеры, различных описаний массивов:
/* несколько описаний массивов */
int temp [365]; /* внешний массив из 365 целых чисел */
main ()
{
float rain [365]; /* автоматический массив из 365 чисел типа
float */
static char code [12]; /* статический массив из 12 символов */
extern temp[]; /* внешний массив; размер указан выше */
}
Как уже упоминалось, квадратные скобки ([]) говорят о том, что temp и все остальные идентификаторы являются именами массивов, а число, заключенное в скобки, указывает количество элементов массива. Отдельный элемент массива определяется при помощи его номера, называемого также индексом. Нумерация элементов начинается с нуля, поэтому temp[0] является первым, а temp[364] последним 365-элементом массива temp.
Но все это вам уже должно быть известно, поэтому изучим что-нибудь новое.
Для хранения данных, необходимых программе, часто используют массивы. Например, в массиве из 12 элементов можно хранить информацию о количестве дней каждого месяца. В подобных случаях желательно иметь удобный способ инициализации массива перед началом работы программы. Такая возможность, вообще говоря, существует, но только для статической и внешней памяти. Давайте посмотрим, как она используется.
Мы знаем, что скалярные переменные можно инициализировать в описании типа при помощи таких выражений, как, например:
int fix = 1;
float flax = PI*2;
при этом предполагается, что PI — ранее введенное макроопределение. Можем ли мы делать что-либо подобное с массивом? Ответ не однозначен: и да, и нет.
Внешние и статические массивы можно инициализировать. Автоматические и регистровые массивы инициализировать нельзя.
Прежде чем попытаться инициализировать массив, давайте посмотрим, что там находится, если мы в него ничего не записали.
/* проверка содержимого массива */
main ()
{
int fuzzy[2]; /* автоматический массив */
static int wuzzy[2]; /* статический массив */
printf(" %d %d\n" , fuzzy[1], wuzzy[1];
}
Программа напечатает
525 0
Полученный результат иллюстрирует следующее правило:
Если ничего не засылать в массив перед началом работы с ним, то внешние и статические массивы инициализируются нулем, а автоматические и статические массивы содержат какой-то «мусор», оставшийся в этой части памяти.
Прекрасно! Теперь мы знаем, что нужно предпринять для обнуления статического или внешнего массива — просто ничего не делать. Но как быть, если нам нужны некоторые значения, отличные от нуля, например количество дней в каждом месяце. В этом случае мы можем делать так:
/* дни месяца */
int days[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
main ()
{
int index;
extern int days[]; /* необязательное описание */
for (index = 0; index < 12; index++)
printf(" Месяц %d имеет %d дней.\n", index + 1, days [index]);
}
Результат:
Месяц 1 имеет 31 дней
Месяц 2 имеет 28 дней
Месяц 3 имеет 31 дней
Месяц 4 имеет 30 дней
Месяц 5 имеет 31 дней
Месяц 6 имеет 30 дней
Месяц 7 имеет 31 дней
Месяц 8 имеет 31 дней
Месяц 9 имеет 30 дней
Месяц 10 имеет 31 дней
Месяц 11 имеет 30 дней
Месяц 12 имеет 31 дней
Программа не совсем корректна, поскольку она выдает неправильный результат для второго месяца каждого четвертого года.
Определив массив days[] вне тела функции, мы тем самым сделали его внешним. Мы инициировали его списком, заключенным в скобки, используя при этом запятые для разделения элементов списка.
Количество элементов в списке должно соответствовать размеру массива. А что будет, если мы ошиблись в подсчете? Попробуйте переписать последний пример, используя список, который короче, чем нужно (на два элемента):
/* дни месяца */
int days[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31};
main ()
{
int index;
extern int days[]; /* необязательное описание */
for (index = 0; index < 12; index++ )
printf(" Месяц %d имеет %d дней\n", index + 1, days [index]);
}
В этом случае результат оказывается иным:
Месяц 1 имеет 31 дней
Месяц 2 имеет 28 дней
Месяц 3 имеет 31 дней
Месяц 4 имеет 30 дней
Месяц 5 имеет 31 дней
Месяц 6 имеет 30 дней
Месяц 7 имеет 31 дней
Месяц 8 имеет 31 дней
Месяц 9 имеет 30 дней
Месяц 10 имеет 31 дней
Месяц 11 имеет 0 дней
Месяц 12 имеет 0 дней
Можно видеть, что у компилятора не возникло никаких проблем: просто, когда он исчерпал весь список с исходными данными, то стал присваивать всем остальным элементам массива нулевые значения.
Однако в случае излишне большого списка компилятор будет также не столь «великодушен» к вам, поскольку посчитает выявленную избыточность ошибкой. Поэтому нет никакой необходимости заранее подвергать себя «насмешкам» компилятора. Надо просто выделить массив, размер которого будет достаточен для размещения списка:
/* дни месяца */
int days[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31};
main ()
{
int index;
extern int days[]; /* необязательное описание */
for (index = 0; index < sizeof days/(sizeof (int)); index++ )
printf(" Месяц %d имеет %d дней\n" , index + 1, days [index]);
}
К этой программе следует сделать два существенных замечания.
Первое: если вы используете пустые скобки для инициализации массива, то компилятор сам определит количество элементов в списке и выделит для него массив нужного размера.
Второе: оно касается добавления, сделанного в управляющем операторе for. He полагаясь (вполне обоснованно) на свои вычислительные способности, мы возложили задачу подсчета размера массива на компилятор. Оператор sizeof определяет размер в байтах объекта или типа, следующего за ним. В нашей вычислительной системе размер каждого элемента типа int равен двум байтам, поэтому для получения количества элементов массива мы делим общее число байтов, занимаемое массивом, на 2. Однако в других системах элемент типа int может иметь иной размер. Поэтому в общем случае выполняется деление на значение переменной sizeof (для элемента типа int).
Ниже приведены результаты работы нашей программы:
Месяц 1 имеет 31 дней
Месяц 2 имеет 28 дней
Месяц 3 имеет 31 дней
Месяц 4 имеет 30 дней
Месяц 5 имеет 31 дней
Месяц 6 имеет 30 дней
Месяц 7 имеет 31 дней
Месяц 8 имеет 31 дней
Месяц 9 имеет 30 дней
Месяц 10 имеет 31 дней
Ну вот, теперь мы получаем точно 10 значений. Наш метод, позволяющий программе самой находить размер массива, не позволил нам напечатать конец массива.
Существует и более короткий способ инициализации массивов, но поскольку он применим только к символьным строкам, мы рассмотрим его в следующей главе.
В заключение мы покажем, что можно присваивать значения элементам массива, относящегося к любому классу памяти. Например, в приведенном ниже фрагменте программы присваиваются четные числа элементам автоматического массива:
/* присваивание значений массиву */
main ()
{
int counter, evens [50];
for (counter = 0; counter < 50; counter++)
evens [counter] = 2 * counter;
...
}
Указатели позволяют нам работать с символическими адресами. Поскольку в реализуемых аппаратно командах вычислительной машины интенсивно используются адреса, указатели предоставляют возможность применять адреса примерно так, как это делается в самой машине, и тем самым повышать эффективность программ. В частности, указатели позволяют эффективно организовать работу с массивами. Действительно, как мы могли убедиться, наше обозначение массива представляет собой просто скрытую форму использования указателей.
Например, имя массива определяет также его первый элемент,
т.е. если flizny[] — массив, то
flizny == &flizny[0]
и обe части равенства определяют адрес первого элемента массива. (Вспомним, что операция & выдает адрес.) Оба обозначения являются константами типа указатель, поскольку они не изменяются на протяжении всей программы. Однако их можно присваивать (как значения) переменной типа указатель и изменять значение переменной, как показано в нижеследующем примере. Посмотрите, что происходит со значением указателя, если к нему прибавить число.
/* прибавление к указателю */
main ()
{
int dates[4], *pti, index;
float bills [4], *ptf;
pti = dates; /* присваивает адрес указателю массива */
ptf = bills;
for (index = 0; index < 4; index++ )
printf(“ указатели + %d: %10 u %10u\n", index, pti + index, ptf + index);
}
Вот результат
указатели + 0: 56014 56026
указатели + 1: 56016 56030
указатели + 2: 56018 56034
указатели + 3: 56020 56038
Первая напечатанная строка содержит начальные адреса двух массивов, а следующая строка — результат прибавления единицы к адресу и т. д. Почему так получается?
56014 + 1 = 56016?
56026 + 1 = 56030?
Не знаете, что сказать? В нашей системе единицей адресации является байт, но тип int использует два байта, а тип float — четыре. Что произойдет, если вы скажете: «прибавить единицу к указателю?» Компилятор языка Си добавит единицу памяти. Для массивов это означает, что мы перейдем к адресу следующего элемента, а не следующего байта. Вот почему мы должны специально оговаривать тип объекта, на который ссылается указатель; одного адреса здесь недостаточно, так как машина должна знать, сколько байтов потребуется для запоминания объекта. (Это справедливо также для указателей на скалярные переменные; иными словами, при помощи операции *pt нельзя получить значение.)
Благодаря тому, что компилятор языка Си умеет это делать, мы имеем следующие равенства:
dates + 2 == &dates[2] /* один и тот же адрес */
*(dates + 2) == dates[2] /* одно и то же значение */
Эти соотношения суммируют тесную связь между массивами и указателями. Они показывают, что можно использовать указатель для определения отдельного элемента массива, а также для получения его значения. По существу мы имеем два различных обозначения для одного и того же. Действительно, компилятор превращает обозначение массива в указатели, поэтому метод указателей более предпочтителен.
Между прочим, постарайтесь различать выражения * (dates + 2), и *dates + 2. Операция (*) имеет более высокий приоритет, чем +, поэтому последнее выражение означает
(* dates) + 2:
*(dates + 2) /* значение 3-го элемента массива dates */
*dates + 2 /* 2 добавляется к значению 1-го элемента массива */
Связь между массивами и указателями часто позволяет нам применять оба подхода при создании программ. Одним из примеров этого является функция с массивом в качестве аргумента.
Массивы можно использовать в программе двояко. Во-первых, их можно описать в теле функции. Во-вторых, они могут быть аргументами функции. Все, что было сказано в этой главе о массивах, относится к первому их применению; теперь рассмотрим массивы в качестве аргументов.
Об этом уже говорилось в гл. 10. Сейчас, когда мы познакомились с указателями, можно заняться более глубоким изучением массивов-аргументов. Давайте проанализируем скелет программы, обращая внимание на описания:
/* массив-аргумент */
main ()
{
int ages [50]; /* массив из 50 элементов */
convert(ages);
…
}
convert (years)
int years []; /* каков размер массива? */
{
…
}
Очевидно, что массив ages состоит из 50 элементов. А что можно сказать о массиве years? Оказывается, в программе нет такого массива. Описатель
int years[];
создает не массив, а указатель на него. Посмотрим, почему это так.
Вот вызов нашей функции:
convert(ages);
ages — аргумент функции convert. Вы помните, что имя ages является указателем на первый элемент массива, состоящего из 50 элементов. Таким образом, оператор вызова функции передает ей указатель, т. е. адрес функции convert (). Это значит, что аргумент функции является указателем, и мы можем написать функцию convert () следующим образом:
convert (уears)
int *years;
{
}
Действительно, операторы
int years [];
int *years;
синонимы. Оба они объявляют переменную years указателем массива целых чисел. Однако главное их отличие состоит в том, что первый из них напоминает нам, что указатель years ссылается на массив.
Как теперь связать его с массивом ages? Вспомним, что при использовании указателя в качестве аргумента, функция взаимодействует с соответствующей переменной в вызывающей программе, т.е. операторы, использующие указатель years в функции convert (), фактически работают с массивом ages, находящимся в теле функции main ().
Посмотрим, как работает этот механизм. Во-первых, вызов функции инициализирует указатель years, ссылаясь на ages[0]. Теперь предположим, что где-то внутри функции convert () есть выражение years [3]. Как вы видели в предыдущем разделе, оно аналогично «(years + 3). Однако если years указывает на ages[0], то years + 3 ссылается на ages[3]. Это приводит к тому, что *(years + 3) означает ages[3]. Если внимательно проследить данную цепочку, то мы увидим, что years [3] аналогично «(years + 3), которое в свою очередь совпадает с ages[3]. Что и требовалось доказать, т. е. операции над указателем years приводят к тем же результатам, что и операции над массивом ages. Короче говоря, когда имя массива применяется в качестве аргумента, функции передается указатель. Затем функция использует этот указатель для выполнения изменений в исходном массиве, принадлежащем программе, вызвавшей функцию. Рассмотрим пример.
Попробуем написать функцию, использующую массивы, а затем перепишем ее, применяя указатели.
Рассмотрим простую функцию, которая находит (или пытается найти) среднее значение массива целых чисел. На входе функции мы имеем имя массива и количество элементов. На выходе получаем среднее значение, которое передается при помощи оператора return. Оператор вызова функции может выглядеть следующим образом:
/* X54.C */
#include <stdio.h>
void main(void)
{
int n = 9,i;
int array[] = {1,3,5,9,0,-9,-5,-3,-1};
int mean(int array[],int n);
i = mean(array,n);
printf("Среднее из заданных значений %d\n",i);
}
int mean(int array[],int n)
{
int index;
long sum;
if(n > 0)
{
for(index = 0, sum = 0; index < n; index++)
sum += array[index];
return((int) (sum/n));
}
else
{
printf("Нет массива\n");
return(0);
}
}
Эту программу легко переделать, применяя указатели. Объявим ра указателем на тип int. Затем заменим элемент массива array[index] на соответствующее значение: *(ра + index).
/* Использование указателей для нахождения среднего значения
массива n целых чисел */
int mean(pa, n)
int *pa, n;
{
int index;
long sum; /*Если целых слишком много, их можно суммировать в формате long int */
if (n > 0)
{
for (index = 0, sum = 0; index < n: index++)
sum += *(pa + index);
return((int) (sum/n) ); /* Возвращаетцелое */
}
else
{
printf(" Нет массива. \n");
return(0);
}
}
Это оказалось несложным, но возникает вопрос: должны ли мы изменить при этом вызов функции, в частности numbs, который был именем массива в операторе mean (numbs, size)? Ничего не нужно менять, поскольку имя массива является указателем. Как мы уже говорили в предыдущем разделе, операторы описания
int pa[];
и
int *pa;
идентичны по действию: оба объявляют ра указателем. В программе можно применять любой из них, хотя до сих пор мы использовали второй в виде *(ра + index).
Понятно ли вам, как работать с указателями? Указатель устанавливается на первый элемент массива, и значение, находящееся там, добавляется в sum. Затем указатель передвигается на следующий элемент (к указателю прибавляется единица), и значение, находящееся в нем, также прибавляется к sum и т. д. Это похоже на механизм работы с массивом, где индекс действует как стрелка часов, показывающая по очереди на каждый элемент массива.
Теперь у нас есть два подхода: какой же из них выбрать? Во-первых, хотя массивы и указатели тесно связаны, у них есть отличия. Указатели являются более общим и широко применяемым средством, однако многие пользователи (по крайней мере, начинающие) считают, что массивы более привычны и понятны. Во-вторых, при использовании указателей у нас нет простого эквивалента для задания размера массива. Самую типичную ситуацию, в которой можно применять указатель, мы уже показали: это функция работающая с массивом, который находится где-то в другой части программы. Мы предлагаем использовать любой из подходов по вашему желанию. Однако несомненное преимущество использования указателей в приведенном выше примере должно научить вас легко применять их, когда в этом возникает необходимость.
Что же мы теперь умеем делать с указателями? Язык Си предлагает пять основных операций, которые можно применять к указателям, а нижеследующая программа демонстрирует эти возможности. Чтобы показать результаты каждой операции, мы будем печатать значение указателя (являющегося адресом, на который ссылается указатель), значение, находящееся по этому адресу, и адрес самого указателя.
/* операции с указателями */
#define PR(X) printf(" X = %u, *X = %d, &X = %u\n", X, *X, &X)
/* печатает значение указателя (адрес), значение, находящееся по */
/* этому адресу, и адрес самого указателя */
main()
static int urn[] = {100, 200, 300};
int *ptr1, *ptr2;
{
ptr1 = urn; /* присваивает адрес указателю */
ptr2 = &urn[2]; /* то же самое */
PR(ptr1); /* см. макроопределение, указанное выше */
ptr1++; /* увеличение указателя */
PR(ptr1);
PR(ptr2);
++ptr2; /* выходит за конец массива */
PR(ptr2);
printf(“ptr2 – ptr1 = %u\n", ptr2 – ptr1);
}
В результате работы программы получены следующие результаты:
ptr1 = 18, *ptr1 = 100, &ptr1 = 55990
ptr1 = 20, *ptr1 = 200, &ptr1 = 55990
ptr2 = 22, *ptr2 = 300, &ptr2 = 55992
ptr2 = 24, *ptr2 = 29808, &ptr2 -= 55992
ptr2 – ptr1 = 2
Программа демонстрирует пять основных операций, которые можно выполнять над переменными типа указатель.
1. ПРИСВАИВАНИЕ. Указателю можно присвоить адрес. Обычно мы выполняем это действие, используя имя массива или операцию получения адреса (&). Программа присваивает переменной ptr1 адрес начала массива urn; этот адрес принадлежит ячейке памяти с номером 18. (В нашей системе статические переменные запоминаются в ячейках оперативной памяти.) Переменная ptr2 получает адрес третьего и последнего элемента массива, т. е. urn [2].
2. ОПРЕДЕЛЕНИЕ ЗНАЧЕНИЯ. Операция * выдает значение, хранящееся в указанной ячейке. Поэтому результатом операции *ptr1 в самом начале работы программы является число 100, находящееся в ячейке с номером 18.
3. ПОЛУЧЕНИЕ АДРЕСА УКАЗАТЕЛЯ. Подобно любым переменным переменная типа указатель имеет адрес и значение. Операция & сообщает нам, где находится сам указатель. В нашем примере указатель ptr1 находится в ячейке с номером 55990. Эта ячейка содержит число 18, являющееся адресом начала массива urn.
4. УВЕЛИЧЕНИЕ УКАЗАТЕЛЯ. Мы можем выполнять это действие с помощью обычной операции сложения либо с помощью операции увеличения. Увеличивая указатель, мы перемещаем его на следующий элемент массива. Поэтому операция ptr1++ увеличивает числовое значение переменной ptr1 на 2 (два байта на каждый элемент массива целых чисел), после чего указатель ptr1 ссылается уже на urn[1] (смотри рисунок). Теперь ptr1 имеет значение 20 (адрес следующего элемента массива), а операция *ptr1 выдает число 200, являющееся значением элемента urn[1]. Заметим, что адрес самой ячейки ptr1 остается неизменным, т. е. 55990. После выполнения операции сама переменная не переместилась, потому что она только изменила значение!
Аналогичным образом можно и уменьшить указатель.
Однако при этом следует соблюдать осторожность. Машина не следит, ссылается ли еще указатель на массив или уже нет. Операция ++ptr2 перемещает указатель ptr2 на следующие два байта, и теперь он ссылается на некоторую информацию, расположенную в памяти за массивом.
Кроме того, оператор увеличения можно использовать для переменной типа указатель, но не для констант этого типа подобно тому, как вы не можете применять оператор увеличения для обычных констант. Для переменных и констант типа указатель можно использовать простое сложение:
Правильно Неправильно
ptr1 ++ ; urn++ ;
х++ ; 3++;
ptr2 = ptr1 + 2; ptr2 = urn++;
ptr2 = urn + 1; x = у + 3++;
5. РАЗНОСТЬ. Можно находить разность двух указателей. Обычно это делается для указателей, ссылающихся на элементы одного и того же массива, чтобы определить, на каком расстоянии друг от друга находятся элементы. Помните, что результат имеет тот же тип, что и переменная, содержащая размер массива.
Перечисленные выше операции открывают большие возможности. Программисты на языке Си создают массивы указателей, указатели на функции, массивы указателей на указатели, массивы указателей на функции и т. д. Мы будем придерживаться основных применений, которые уже упоминались. Первое из них — передача информации в функцию и из нее. Мы использовали указатели, когда хотели, чтобы функция изменила переменные, находящиеся в вызывающей программе. Второе — использование указателей в функциях, работающих с многомерными массивами.
Темпест Клауд, метеоролог, занимающаяся явлением перистости облаков, хочет проанализировать данные о ежемесячном количестве осадков на протяжении пяти лет. В самом начале она должна решить, как представлять данные. Можно использовать 60 переменных, по одной на каждый месяц. (Мы уже упоминали о таком подходе ранее, но в данном случае он также неудачен.) Лучше было бы взять массив, состоящий из 60 элементов, но это устроило бы нас только до тех пор, пока можно хранить раздельно данные за каждый год. Мы могли бы также использовать S массивов по 12 элементов каждый, но это очень примитивно и может создать действительно большие неудобства, если Темпест решит изучать данные о количестве осадков за 50 лет вместо пяти. Нужно придумать что-нибудь получше.
Хорошо было бы использовать массив массивов. Основной массив состоял бы тогда из 5 элементов, каждый из которых в свою очередь был бы массивом из 12 элементов. Вот как это записывается:
static float rain[5][12];
Можно также представить массив rain в виде двумерного массива состоящего из 5 строк и 12 столбцов.
При изменении второго индекса на единицу мы передвигаемся вдоль строки, а при изменении первого индекса на единицу, передвигаемся вертикально вдоль столбца. В нашем примере второй индекс дает нам месяцы, а первый — годы.
Используем этот двумерный массив в метеорологической программе. Цель нашей программы — найти общее количество осадков для каждого года, среднегодовое количество осадков и среднее количество осадков за каждый месяц. Для получения общего количества осадков за год следует сложить все данные, находящиеся в нужной строке. Чтобы найти среднее количество осадков за данный месяц, мы сначала складываем все данные в указанном столбце. Двумерный массив позволяет легко представить и выполнить эти действия.
/* найти общее количество осадков для каждого года, средне*/
/* годовое, среднемесячное количество осадков, за несколько лет */
#define TWLV 12 /* число месяцев в году */
#define YRS 5 /* число лет */
main ()
{
static float rain [YRS][TWLV] = {
{10.2, 8.1, 6.8, 4.2, 2.1, 1.8, 0.2, 0.3, 1.1, 2.3, 6.1, 7.4},
{9.2, 9.8, 4.4, 3.3, 2.2, 0.8, 0.4, 0.0,0.6, 1.7, 4.3, 5.2},
{6.6, 5.5, 3.8, 2.8, 1.6, 0.2, 0.0, 0.0,0.0, 1.3, 2.6, 4.2},
{4.3, 4.3, 4.3, 3.0, 2.0, 1.0, 0.2, 0.2,0.4, 2.4, 3.5, 6.6},
{8.5, 8.2, 1.2, 1.6, 2.4, 0.0, 5.2, 0.9,0.3, 0.9, 1.4, 7.2}
};
/* инициализация данных по количеству осадков за 1970—1974 */
int year, month;
float subtot, total;
printf(" ГОД КОЛИЧЕСТВО ОСАДКОВ (дюймы)\n\n" );
for (year = 0, total = 0; year < YRS; year++ )
{
/* для каждого года, суммируем количество осадков
для каждого месяца */
for (month = 0, subtot = 0; month < TWLV; month++ )
subtot += rain [year] [month);
printf("%5d %15.1f\n", 1970 + year, subtot);
total + = subtot; /* общее для всех лет */
}
printf(" \n среднегодовое количество осадков составляет
%.1f дюймов.\n\n" , total/YRS );
printf(" Янв. Фев. Map. Апр.Май Июн. Июл. Авг.Сент.");
printf(" Окт. Нояб. Дек\n");
for (month = 0; month < TWLV; month++ )
{
/* для каждого месяца, суммируем количество осадков за все годы */
for (year = 0, subtot = 0; year < YRS; year++ )
subtot += rain [year] [month];
printf(" %4.1f", subtot/YRS);
}
printf(" \n");
}
ГОД КОЛИЧЕСТВО ОСАДКОВ (дюймы)
1970 50.6
1971 41.9
1972 28.6
1973 32.3
1974 37.8
Среднегодовое количество осадков составляет 38.2 дюйма.
ЕЖЕМЕСЯЧНОЕ КОЛИЧЕСТВО:
Янв. Фев. Мар. Апр. Май Июн. Июл. Авг. Сен. Окт. Нояб. Дек.
7.8 7.2 4.1 3.0 2.1 0.8 1.2 0.3 0.5 1.7 3.6 6.1
В этой программе следует отметить два основных момента: инициализацию и вычисления. Инициализация сложнее, поэтому мы сначала рассмотрим вычисления.
Чтобы найти общее количество осадков за год, мы не изменяем year, а заставляем переменную month пройти все свои значения. Так выполняется внутренний цикл for, находящийся в первой части программы. Затем мы повторяем процесс для следующего значения year. Это внешний цикл первой части программы. Структура вложенного цикла, подобная описанной, подходит для работы с двумерным массивом. Один цикл управляет одним индексом, а второй цикл — другим.
Вторая часть программы имеет такую же структуру, но теперь мы изменяем year во внутреннем цикле, a month во внешнем. Помните, что при однократном прохождении внешнего цикла внутренний цикл выполняется полностью. Таким образом, программа проходит в цикле через все годы, прежде чем изменится месяц, и дает нам общее количество осадков за пять лет для первого месяца, затем общее количество за пять лет для второго месяца и т. д.
Для инициализации массива мы взяли пять заключенных в скобки последовательностей чисел, а все эти данные еще раз заключили в скобки. Данные, находящиеся в первых внутренних скобках, присваиваются первой строке массива, данные во второй внутренней последовательности — второй строке и т. д. Правила, которые мы обсуждали раньше, о несоответствии между размером массива и данных применяются здесь для каждой строки. Если первая последовательность в скобках включает десять чисел, то только первым десяти элементам первой строки будут присвоены значения. Последние два элемента в этой строке будут, как обычно, инициализированы нулем по умолчанию. Если чисел больше, чем нужно, то это считается ошибкой; перехода к следующей строке не произойдет.
Мы могли бы опустить все внутренние скобки и оставить только две самые внешние. До тех пор пока мы будем давать правильное количество входных данных, результат будет тем же самым. Однако, если данных меньше, чем нужно, массив заполняется последовательно (не обращается внимание на разделение по строкам), пока не кончатся все данные. Затем оставшимся элементам будут присвоены нулевые значения. Смотри рисунок.
Все, что мы сказали о двумерных массивах, можно распространить и на трехмерные массивы и т. д. Трехмерный массив описывается следующим образом:
int solido[10][20][30];
Вы можете представить его в виде десяти двумерных массивов (каждый 20x30), поставленных друг на друга, или в виде массива из массивов. То есть это массив из 10 элементов, и каждый его элемент также является массивом. Все эти массивы в свою очередь имеют по 20 элементов, каждый из которых состоит из 30 элементов. Преимущество этого второго подхода состоит в том, что Можно довольно просто перейти к массивам большей размерности, если окажется, что вы не можете представить наглядно четырехмерный объект! Мы же останемся верны двум измерениям.
Как создать указатели для многомерных массивов? Чтобы найти ответ на этот вопрос, рассмотрим несколько примеров.
Предположим, что у нас есть описания
int zippo[4][2]; /* массив типа int из 4 строк и 2 столбцов */
int *pri; /* указатель на целый тип */
Тогда на что
pri = zippo;
указывает? На первый столбец первой строки:
zippo == &zippo[0][0]
А на что указывает pri + 1? На zippo[0][1], т. е. на 1-ю строку 2-го столбца? Или на zippo [1][0], элемент, находящийся во второй строке первого столбца? Чтобы ответить на поставленный вопрос, нужно знать, как располагается в памяти двумерный массив. Он размещается, подобно одномерным массивам, занимая последовательные ячейки памяти. Порядок элементов определяется тем, что самый правый индекс массива изменяется первым, т. е. элементы массива располагаются следующим образом:
zippo[0][0] zippo[0][1] zippo[1][0] zippo[1][1] zippo[2][0]
Сначала запоминается первая строка, за ней вторая, затем третья и т. д. Таким образом, в нашем примере:
pri == &zippo[0][0] /* 1-я строка, 1 столбец */
pri + 1 == &zippo[0][1] /* 1-я строка, 2 столбец */
pri + 2 == &zippo[1][0] /* 2-я строка, 1 столбец */
pri + 3 == &zippo[1][1] /* 2-я строка, 2 столбец */
Получилось? Хорошо, а на что указывает pri + 5? Правильно, на
zippo[2][1].
Мы описали двумерный массив как массив массивов. Если zippo является именем нашего двумерного массива, то каковы имена четырех строк, каждая из которых является массивом из двух элементов? Имя первой строки zippo [0], имя четвертой строки zippo [3]; вы можете заполнить пропущенные имена. Однако имя массива является также указателем на этот массив в том смысле, что оно ссылается на первый его элемент. Значит,
zippo[0] == &zippo[0][0]
zippo[1] == &zippo[1][0]
zippo[2] == &zippo[2][0]
zippo[3] == &zippo[3][0]
Это свойство является более, чем новшеством. Оно позволяет использовать функцию, предназначенную для одномерного массива, для работы с двумерным массивом! Вот доказательство (хотя мы надеемся, что теперь вы бы поверили нам и так) использования двумерного массива в нашей программе нахождения среднего значения:
/* одномерная функция, двумерный массив */
main ()
{
static int junk [3] [4] = {
{2, 4, 6, 8},
{100, 200, 300, 400},
{10, 40, 60, 90}
};
int row;
for (row = 0; row < 3; row++ )
printf(" Среднее строки %d равно %d.\n",
row, mean(junk[row], 4) ); /* junk [row] — одномерный массив из четырех элементов */
}
/* находит среднее в одномерном массиве */
int mean(array,n)
int array[], n;
{
int index; long sum;
if (n > 0)
{
for (index = 0, sum = 0; index < n; index++)
sum += (long) array [index];
return( (int) (sum/n) );
}
else
{
printf("Heт массива\n");
return(0);
}
}
Результат работы программы:
Среднее строки 0 равно 5.
Среднее строки 1 равно 250.
Среднее строки 2 равно 50.
Предположим, что вы хотите иметь функцию, работающую с двумерным массивом, причем со всем целиком, а не с частями. Как вы запишите определения функции и ее описания? Подойдем к этому более конкретно и скажем, что нам нужна функция, управляющая массивом junk[][] в нашем последнем примере. Пусть функция main () выглядит так:
/* junk в main */
main ()
{
static int junk[3][4] = {
{2, 4, 5, 8},
{100, 200, 300, 400},
{10, 40, 60, 90}
};
stuff(junk);
}
Функция stuff () использует в качестве аргумента junk, являющийся указателем на весь массив. Как написать заголовок функции, не зная, что делает stuff ()?
Попробуем написать:
stuff (junk)
int junk[];?
или
stuff(junk)
int junk[][];?
Нет и нет. Первые два оператора еще будут работать некоторым образом, но они рассматривают junk как одномерный массив, состоящий из 12 элементов. Информация о расчленении массива на строки отсутствует.
Вторая попытка ошибочна, потому что хотя оператор и указывает, что junk является двумерным массивом, но нигде не говорится, из чего он состоит. Из шести строк и двух столбцов? Из двух строк и шести столбцов? Или из чего-нибудь еще? Компилятору недостаточно этой информации. Ее дают следующие операторы:
stuff(junk)
int junk[][4];
Они сообщают компилятору, что массив следует разбить на строки по четыре столбца.
Массивы символьных строк являются особым случаем, так как у них нулевой символ в каждой строке сообщает компилятору о конце строки. Это разрешает описания, подобные следующему:
char *list[];
Символьные строки представляют одно из наиболее частых применений массивов и указателей; мы вернемся к этой теме позднее.
Что вы должны были узнать
· Как объявить одномерный массив: long id_ no [200];
· Как объявить двумерный массив: short chess[8] [8];
· Какие массивы можно инициализировать: внешние и статические.
· Как инициализировать массив: static int hats[3] = {10,20,15};
· Другой способ инициализации: static int caps[] = {3,56,2};
· Как получить адрес переменной: использовать операцию &
· Как получить значение, ссылаясь на указатель: использовать операцию *
· Смысл имени массива: hats == &hats[0]
· Соответствие массива и указателя: если ptr = hats; то ptr + 2 == &hat[2]; и *(ptr + 2) == hat[2];
· Пять операций, которые можно применять для переменных типа указатель: см. текст.
· Метод указателей для функций, работающих с массивами.
Вопросы и ответы
Вопросы
1. Что напечатается в результате работы этой программы?
#define PC(X, Y) printf("%c %c\n", X, Y)
char ref[] = { D, О, L, Т};
main ()
{
char *ptr;
int index;
for (index = 0; ptr = ref; index < 4; index++, ptr++ )
PC(ref[index], *ptr);
}
2. Почему в вопросе 1 массив ref описан до оператора main ()?
3. Определите значение *ptr и *(ptr + 2) в каждом случае:
a.
int *ptr;
static int boop[4] = {12, 21, 121, 212};
ptr = boop;
b. float *ptr;
static float awk[2][2] = { { 1.0, 2.0}, {3.0, 4.0}};
ptr = awk[0];
c. int *ptr;
static int jirb[4] = {10023, 7};
ptr = jirb;
d. int = *ptr;
static int torf[2][2) = {12, 14, 16};
ptr = torf[0];
e. int *ptr;
static int fort[2][2] = {{ 12}, {14, 16}};
ptr = fort[0];
4. Предположим, у нас есть описание static int grid[30][100];
a. Выразите адрес grid [22] [56] иначе.
b. Выразите адрес grid[22] [0] двумя способами.
c. Выразите адрес grid[0][0] тремя способами.
Ответы
1.
D D
О О
L L
Т Т
2. По умолчанию такое положение ref относит его к классу памяти типа extern, a массивы этого класса памяти можно инициализировать.
3.
a. 12 и 121
b. 1.0 и 3.0
c. 10023 и 0 (автоматическая инициализация нулем)
d. 12 и 16
e. 12 и 14 (именно 12 появляется в первой строке из-за скобок).
4.
a. &grid[22][56]
b. &grid[22][0] и grid[22]
c. &grid[][] и grld[0] и grid
Упражнение
1. Модифицируйте нашу метеорологическую программу таким образом, чтобы она выполняла вычисления, используя указатели вместо индексов. (Вы по-прежнему должны объявить и инициализировать массив.)
|
