9: unsigned int smallNumber = 50;
10: difference = bigNumber - smallNumber;
11: cout << "Difference is: " << difference;
12: difference = smallNumber - bigNumber;
13: cout << "nNow difference is: " << difference << endl;
14: return 0;
15: }
Результат:
Difference is: 50
Now difference is: 4294967246
Анализ: Оператор вычитания используется в строке 10, а результат выводится на экран в строке 11, в данном случае вполне ожидаемый. В строке 12 вновь вызывается оператор вычитания, но на этот раз большое беззнаковое число вычитается из малого беззнакового числа. Результат должен быть отрицательным, но поскольку он вычисляется (и выводится) как беззнаковое число, происходит переполнение, о чем говорилось на прошлом занятии. Эта тема подробно рассматривается в приложении А.
Целочисленное деление и деление по модулю
Целочисленное деление несколько отличается от обычного. Целочисленное деление — это то же caмoe деление, которое вы изучали, когда ходили в первый класс. При делении числа 21 на число 4 (21/4) в случае целочисленного деления в ответе получается 5 и остаток 1.
Чтобы получить остаток, нужно число 21 разделить по модулю 4 (21 % 4), в результате получим остаток 1.
Операция деления по модулю иногда оказывается весьма полезной, например, если вы захотите вывести из ряда чисел каждое десятое значение. Любое число, результат деления которого по модулю 10 равен нулю, является кратным десяти, т.е. делится на 10 без остатка. Так, результат выражения 1 % 10 равен 1; 2 % 10 равен 2 и т.д.; а 10 % 10 равен 0. Результат от деления 11 % 10 снова равен 1; 12 % 10 снова равен 2; и так можно продолжать до следующего числа, кратного 10, которым окажется 20. Мы воспользуемся этим методом при рассмотрении циклов на занятии 7.
Вопросы и ответы
При делении 5 на 3 я получаю в ответе 1. В чем моя ошибка?
При делении одного целого числа на другое в качестве результата вы также получите целое число. Следовательно, 5/3 равно 1.
Для получения дробного результата нужно использовать вещественные числа. Выражение 5,0 / 3,0 даст дробный ответ: 1,66667.
Если ваш метод принимает в качестве параметров целочисленные значения, нужно привести их к типу float.
Вопросы и ответы: Выполняя операцию приведения типа переменной, вы заставляете компилятор изменить ее тип. Приэтом вы как будто говорите своемукомпилятору:"Я знаю, что делаю". Было бы неплохо, если бы это оказалось правдой, поскольку компилятор как бы отвечает вам: "Как скажете, босс: вся ответственность ложится на вас". В данном случае мы хотим сказать компилятору: "Я понимаю, что ты считаешь это значение целым, но я знаю, что делаю: это действительно вещественное значение". Для приведения типа существует два способа. Можно использовать приведение типа в старом стиле С или новый улучшенный оператор ANSIstatic_cast. Оба варианта демонстрируются в листинге 4.3.
Листинг 4.3. Приведение переменной к типу float
1: #include <iostream.h>
2:
3: void intDiv(int x, int y)
4: {
5: int z = x / y;
6: cout << "z: " << z << endl;
7: }
8:
9: void floatDiv(int x, int y)
10: {
11: float a = (float)x; // старый стиль
12: float b = static_cast<float>(y); // современный стиль
13: float c = a / b;
14:
15: cout << "c: " << c << endl;
16: }
17:
18: int main()
19: {
20: int x = 5, y = 3;
21: intDiv(x,y);
22: floatDiv(x,y);
23: return 0;
24: }
Результат:
z: 1
с: 1.66667
Анализ: В строке 20 объявляются две целочисленные переменные. В строке 21 они как параметры передаются функции intDiv, а в строке 22 — функции floatDiv. Вторая функция начинается со строки 9. В строках 11 и 12 целые значения приводятся к вещественному типу и присваиваются переменным типа float. Результат деления присваивается третьей переменной типа float в строке 13 и выводится на экран в строке 15.
Совместное использование математических операторов с операторами присваивания
Нет ничего необычного в том, чтобы к переменной прибавить некоторое значение, а затем присвоить результат той же переменной. Если у вас есть переменная myAge и вы хотите увеличить ее значение на два, можно записать следующее:
int myAge = 5;
int temp;
temp = myAge + 2; // складываем 5 + 2 и результат помещаем в
temp myAge = temp; // значение возраста снова помещаем в myAge
Однако этот метод грешит излишествами. В языке C++ можно поместить одну и ту же переменную по обе стороны оператора присваивания, и тогда предыдущий блок сведется лишь к одному выражению:
myAge = myAge + 2;
В алгебре это выражение рассматривалось бы как бессмысленное, но в языке C++ оно читается следующим образом: добавить два к значению переменной myAge и присвоить результат переменной myAge.
Существует еще более простой вариант предыдущей записи, хотя его труднее читать:
myAge += 2;
Этот оператор присваивания с суммой (+=) добавляет r-значение к l-значению, а затем снова записывает результат в l-значение. Если бы до начала выполнения выражения переменная myAge имела значение 4, то после ее выполнения значение переменной myAge стало бы равным 6.
Помимо оператора присваивания с суммой существуют также оператор присваивания с вычитанием (-=), делением (/=), умножением (*=) и делением по модулю (%=).
Инкремент декремент
Очень часто в программах к переменным добавляется (или вычитается) единица. В языке C++ увеличение значения на 1 называется инкрементом, а уменьшение на 1 — декрементом. Для этих действий предусмотрены специальные операторы.
Оператор инкремента (++) увеличивает значение переменной на 1, а оператор декремента (--) уменьшает его на 1. Так, если у вас есть переменная С и вы хотите прирастить ее на единицу, используйте следующее выражение:
C++; // Увеличение значения С на единицу
Это же выражение можно было бы записать следующим образом:
С = С + 1;
что, в свою очередь, равносильно выражению.
С += 1;
Префикс и постфикс
Как оператор инкремента, так и оператор декремента работает в двух вариантах: префиксном и постфиксном. Префиксный вариант записывается перед именем переменной (++myAge), а постфиксный — после него (myAge++).
В простом выражении вариант использования не имеет большого значения, но в сложном при выполнении приращения одной переменной с последующим присваиванием результата другой переменной это весьма существенно. Префиксный оператор вычисляется до присваивания, а постфиксный — после.
Семантика префиксного оператора следующая: инкрементируем значение, а затем считываем его. Семантика постфиксного оператора иная: считываем значение, а затем декрементируем оригинал.
На первый взгляд это может выглядеть несколько запутанным, но примеры легко проясняют механизм действия этих операторов. Если x — целочисленная переменная, значение которой равно 5, и, зная это, вы записали
int а = ++x;
то тем самым велели компилятору инкрементировать переменную x (сделав ее равной 6), а затем присвоить это значение переменной а. Следовательно, значение переменной а теперь равно 6 и значение переменной x тоже равно 6. Если же, после этого вы записали
int b = x++;
то тем самым велели компилятору присвоить переменной b текущее значение переменной x (6), а затем вернуться назад к переменной x и инкрементировать ее. В этом случае значение переменной b равно 6, но значение переменной x уже равно 7. В листинге 4.4 продемонстрировано использование обоих типов операторов инкремента и декремента.
Листинг 4.4. Примеры использования префиксных и постфиксных операторов
1: // Листинг 4.4. Демонстрирует использование
2: // префиксных и постфиксных операторов
3: // инкремента и декремента
4: #include <iostream.h>
5: int main()
6: {
7: int myAge = 39; // инициализируем две целочисленные переменные
8: int yourAge = 39;
9: cout << "I am: " << myAge << " years old.n";
10: cout << "You are: " << yourAge << " years oldn";
11: myAge++; // постфиксный инкремент
12: ++yourAge; // префиксный инкремент
13: cout << "One year passes...n";
14: cout << "I am: " << myAge << " years old.n";
15: cout << "You are: " << yourAge << " years oldn";
16: cout << "Another year passesn";
17: cout << "I am: " << myAge++ << " years old.n";
18: cout << "You are: " << ++yourAge << " years oldn";
19: cout << "Let's print it again.n";
20: cout << "I am: " << myAge << " years old.n";
21: cout << "You are: " << yourAge << " years oldn";
22: return 0;
23: }
Результат:
I am 39 years old
