Массивы и указатели (стр. 1 из 4)
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 нельзя получить значение.)
Благодаря тому, что компилятор языка Си умеет это делать, мы имеем следующие равенства: