Операция sizeof и тип size_t

Операция sizeof возвращает размер своего операнда в байтах. (Вспомните также, что байт в языке С определен как размер, используемый для типа char. В прошлом байт чаще всего состоял из 8 битов, но некоторые наборы символов использовали байты большего размера.) Операндом может быть конкретный объект данных, такой как имя переменной, либо им может быть тип. Если это тип, скажем, float, то операнд должен быть помещен в круглые скобки. В примере, представленном в листинге 5.8, показаны обе формы операндов.

Листинг 5.8. Программа sizeof.с

// sizeof.c -- использование операции sizeof

// в примере применяется определенный в стандарте с99 модификатор %z

#include <stdio.h>

int main(void)

{

int n = 0;

size_t intsize;

intsize = sizeof (int);

printf("n = %d, n состоит из %zd байтов; все значения int имеют %zd байтов.\n",

n, sizeof n, intsize);

return 0;

}

В языке С указано, что операция sizeof возвращает значение типа size_t. Это целочисленный тип без знака, но не совершенно новый тип. Он определен в терминах стандартных типов.

Операция деления по модулю: %

Операция деления но модулю применяется в целочисленной арифметике. Ее результатом является остаток от деления целого числа, стоящего слева от знака операции, на число, расположенное справа от него. Например, 13 % 5 (читается как “13 по модулю 5”) дает в результате 3, поскольку 5 умещается в 13 дважды с остатком, равным 3. Не пытайтесь выполнять эту операцию над числами с плавающей запятой. Она просто не работает.

На первый взгляд эта операция может показаться экзотическим инструментом, предназначенным только для математиков, но по существу она очень удобна и полезна. Обычно она используется, чтобы помочь управлять ходом выполнения программы. Предположим, например, что вы работаете над программой подготовки счетов, предназначенной для начисления дополнительной платы каждый третий месяц. Для этого достаточно разделить номер месяца по модулю 3 (т.е. month % 3) и проверить, не равен ли результат 0. Если равен, программа включает дополнительную плату.

В листинге 5.9 приведен еще один пример применения операции %. В нем также демонстрируется еще один способ использования цикла while.

Листинг 5.9. Программа min_sec.c

// min_sec.c -- переводит секунды в минуты и секунды

#include <stdio.h>

#define SEC_PER_MIN 60 // количество секунд в минуте

int main(void)

{

int sec, min, left;

printf("Перевод секунд в минуты и секунды!\n");

printf("Введите количество секунд (<=0 для выхода):\n");

scanf("%d", &sec); // чтение количества секунд

while (sec > 0)

{

min = sec / SEC_PER_MIN; // усеченное количество минут

left = sec % SEC_PER_MIN; // количество секунд в остатке

printf("%d seconds is %d minutes, %d seconds.\n", sec, min, left);

printf("Введите следующее значение (<=0 для выхода):\n");

scanf("%d", &sec);

}

printf("Готово!\n");

return 0;

}

Вот как выглядит пример вывода:

Перевод секунд в минуты и секунды!

Введите количество секунд (<=0 для выхода):

154 секунд - это 2 минут(ы) 34 секунд.

Введите следующее значение (<=0 для выхода):

5 67 секунд - это 9 минут (ы) 27 секунд.

Введите следующее значение (<=0 для выхода):

Готово!

В коде из листинга 5.2 для управления циклом while применяется счетчик. Как только значение счетчика превысит заданный размер, цикл завершается. Однако для загрузки новых значений переменной sec код в листинге 5.9 использует функцию scanf (). Цикл продолжается до тех пор, пока это значение положительно. Когда пользователь вводит ноль или отрицательное значение, цикл завершается. Важной особенностью программы в обоих случаях является то, что каждая итерация цикла обновляет значение проверяемой переменной.

Операции инкремента и декремента: ++ и --

Операция инкремента решает простую задачу: она увеличивает (инкрементирует) значение своего операнда на 1. Существуют две разновидности этой операции. В первом случае символы ++ располагаются перед изменяемой переменной; это префиксная форма.

Во втором случае символы ++ следуют сразу за переменной; это постфиксная форма. Эти две формы отличаются друг от друга по моменту выполнения инкрементирования. Сначала мы объясним подобные черты этих форм, а затем обратимся к различиям. Короткий пример, представленный в листинге 5.10, демонстрирует работу операции инкремента.

Листинг 5.10. Программа add_one.c

/* add_one.c -- инкремент: префиксная и постфиксная формы*/

#include <stdio.h>

int main(void)

{

int ultra = 0, super = 0;

while (super < 5)

{

super++;

++ultra;

printf("super = %d, ultra = %d \n", super, ultra);

}

return 0;

}

Выполнение программы add one.c генерирует следующий вывод:

super = 1, ultra = 1 super = 2, ultra = 2 super = 3, ultra = 3 super = 4, ultra = 4 super = 5, ultra = 5

Программа одновременно дважды просчитала до пяти. Тот же результат можно было бы получить, заменив две операции инкремента следующими операторами присваивания:

super = super + 1; ultra = ultra + 1;

Это достаточно простые операторы. Зачем создавать еще одно сокращение, не говоря уже о двух? Одна из причин заключается в том, что компактная форма позволяет улучшить читабельность и упростить программы. Данные операции придают программам изящество и элегантность, радуя глаз. Например, часть программы shoes2.c из листинга 5.2 можно переписать так:

shoe = 3.0;

while (shoe < 18.5)

{

foot = SCALE * size + ADJUST;

printf("% 10.1f %20.2f дюймов\n", shoe, foot);

++shoe;

}

Тем не менее, вы по-прежнему не до конца задействовали преимущества операции инкремента. Фрагмент программы можно еще больше сократить, как показано ниже:

shoe = 2.0;

while (++shoe < 18.5)

{

foot = SCALE*shoe + ADJUST;

printf("%10.1f %20.2f дюймов\n", shoe, foot);

}

Здесь процесс инкрементирования и сравнения из цикла while объединены в одно выражение. Конструкции такого типа настолько часто встречаются в программах на С, что заслуживают более пристального внимания.

Во-первых, как работает такая конструкция? Все довольно просто. Значение переменной shoe увеличивается на 1, а затем сравнивается с 18.5. Если оно меньше 18.5, то операторы, заключенные в фигурные скобки, выполняются один раз. Затем shoe снова увеличивается на 1 и цикл продолжается до тех пор, пока значение shoe не станет достаточно большим. Чтобы скомпенсировать инкремент переменной shoe, выполненный перед первым вычислением значения переменной foot, мы уменьшили начальное значение shoe с 3.0 до 2.0 (рис. 5.4).

Во-вторых, в чем преимущества такого подхода? Программа становится компактной. Но более важно то, что при этом объединяются в одном месте два процесса, которые управляют циклом. Первичным процессом является проверка того, продолжать ли выполнение цикла? В данном случае проверка заключается в выяснении, меньше ли значение переменной size, чем 18. 5. Вторичный процесс изменяет значение проверяемого объекта; в данном случае размер обуви увеличивается на единицу.

Предположим, что вы забыли изменить размер обуви. Тогда значение переменной shoe всегда будет меньше 18.5, и цикл никогда не завершится. Вошедший в бесконечный цикл компьютер будет выводить одну и ту же строку. В конце концов, вы потеряете интерес к выводу и будете вынуждены как-то прервать выполнение программы. Проверка условия и изменение параметра цикла в одном месте, а не в разных, помогает помнить о необходимости изменить значение параметра цикла.

Недостаток объединения двух операций в одно выражение заключается в том, что это затрудняет понимание кода и увеличивает вероятность внесения ошибок.

Еще одно достоинство операции инкремента состоит в том, что она приводит к генерации несколько более эффективного кода на машинном языке по причине своего подобия действительным инструкциям машинного языка. Тем не менее, по мере улучшения компиляторов С поставщиками программного обеспечения это преимущество постепенно исчезает. Интеллектуальный компилятор способен распознать, что операцию х = х + 1 можно трактовать как ++х.

Наконец, эти операции обладают дополнительной характеристикой, которая может оказаться полезной в ряде тонких ситуаций. Чтобы выяснить, о чем идет речь, попробуйте запустить программу из листинга 5.11.

Листинг 5.11. Программа post_pre.c

/* post_pre.c -- постфиксная и префиксная формы*/

#include <stdio.h>

int main(void)

{

int a = 1, b = 1;

int a_post, pre_b;

a_post = a++; // значение a++ во время этапа присваивания

pre_b = ++b; // значение ++b во время этапа присваивания

printf("a a_post b pre_b \n");

printf("%1d %5d %5d %5d\n", a, a_post, b, pre_b);

return 0;

}

Если все было сделано правильно, должен получиться следующий результат:

a a_post b рге_b 2 12 2

Как и было задумано, значения переменных а и b увеличились на единицу. Однако a post содержит значение переменной а перед изменением, а b__рrе — значение переменной b после изменения. Именно в этом заключается отличие между префиксной и постфиксной формами операции инкремента (рис. 5.5):

a_post = а++; // постфиксная форма: переменная а меняется после

// использования ее значения

b_рге= ++b; // префиксная форма: переменная b меняется до использования

// ее значения

Когда одна из этих операций инкремента применяется сама по себе, как в одиночном операторе ego++; ее форма не имеет значения. Однако выбранная форма играет роль, если операция и ее операнд являются частью более крупного выражения, как в только что показанных операторах присваивания. В ситуациях подобного рода нужно иметь четкое представление о том, какой результат вы желаете получить. В качестве примера вспомните, что мы намеревались использовать следующую конструкцию:

while (++shoe < 18.5)

Такая проверка условия завершения цикла позволяет получить таблицу значений вплоть до размера 18. Если вы укажете shoe++ вместо ++shoe, то таблица расширится до размера 19, т.к. значение shoe будет увеличиваться после сравнения, а не до него. Конечно, вы могли бы возвратиться к менее элегантной форме:

shoe = shoe + 1;

но тогда никто не поверит, что вы настоящий программист на языке С.