Операторы унарные в C

Привет, будущие суперзвезды программирования! Сегодня мы отправляемся в захватывающее путешествие по миру унарных операторов в C. Не волнуйтесь, если вы новичок в программировании – я стану вашим дружественным гидом, и мы будем исследовать эту тему шаг за шагом. Так что возьмите свой виртуальный рюкзак, и начнем!

Оператор инкремента в C

Начнем с оператора инкремента, который является своего рода магической кнопкой "+1" для наших переменных. В C мы используем "++" для увеличения значения. Это очень удобно, когда我们需要 считать что-то или двигаться по последовательности.

Есть два способа использования оператора инкремента:

1. Предварительный инкремент: ++переменная
2. Постпроцедурный инкремент: переменная++

Посмотрим на примеры:

#include <stdio.h>

int main() {
int печенье = 5;

printf("У меня есть %d печенек.\n", печенье);

// Предварительный инкремент
printf("После того, как я съел одно: %d\n", ++печенье);

// Постпроцедурный инкремент
printf("Текущее количество: %d\n", печенье++);
printf("После подсчета: %d\n", печенье);

return 0;
}

Вывод:

У меня есть 5 печенек.
После того, как я съел одно: 6
Текущее количество: 6
После подсчета: 7

В этом примере мы начинаем с 5 печенек. Когда мы используем предварительный инкремент (++печенье), он сразу увеличивает значение, прежде чем использовать его. С постпроцедурным инкрементом (печенье++), он использует текущее значение сначала, а затем увеличивает его.

Оператор декремента в C

Теперь познакомимся с оператором декремента, сестрой-близняшкой инкремента. Он делает противоположное – вычитает 1 из нашей переменной. Для этой операции мы используем "--".

Как и его сестра, он приходит в двух вариантах:

1. Предварительный декремент: --переменная
2. Постпроцедурный декремент: переменная--

Посмотрим, как это работает:

#include <stdio.h>

int main() {
int жизни = 3;

printf("У вас есть %d жизней.\n", жизни);

// Предварительный декремент
printf("Ой! Вы потеряли одну: %d\n", --жизни);

// Постпроцедурный декремент
printf("Текущее количество жизней: %d\n", жизни--);
printf("Игра окончена: %d\n", жизни);

return 0;
}

Вывод:

У вас есть 3 жизни.
Ой! Вы потеряли одну: 2
Текущее количество жизней: 2
Игра окончена: 1

Здесь мы начинаем с 3 жизнями в нашей фантастической игре. Предварительный декремент (--жизни) сразу снижает счет, а постпроцедурный декремент (жизни--) использует текущее значение, прежде чем уменьшить его.

Унарный оператор "+" в C

Унарный оператор "+" может показаться немного избыточным с первого взгляда. В конце концов, неужели положительное число уже... положительное? Да, но этот оператор имеет свои применения, особенно при работе с различными типами данных.

#include <stdio.h>

int main() {
int число = 42;
float пи = 3.14;

printf("Положительное целое: %d\n", +число);
printf("Положительное вещественное: %f\n", +пи);

return 0;
}

Вывод:

Положительное целое: 42
Положительное вещественное: 3.140000

В этом примере унарный "+" не изменяет значения, но обеспечивает, что они обрабатываются как положительные числа. Это как если бы вы дали своим переменным немного поддержки: "Оставайтесь положительными, дружок!"

Унарный оператор "-" в C

Унарный оператор "-" похож на волшебную палочку, которая превращает положительные числа в отрицательные (и наоборот). Это очень полезно, когда нам нужно изменить знак значения.

#include <stdio.h>

int main() {
int температура = 25;
float баланс = -100.50;

printf("Исходная температура: %d\n", температура);
printf("Ниже нуля: %d\n", -температура);

printf("Исходный баланс: %.2f\n", баланс);
printf("Долги выплачены: %.2f\n", -баланс);

return 0;
}

Вывод:

Исходная температура: 25
Ниже нуля: -25
Исходный баланс: -100.50
Долги выплачены: 100.50

Смите, как мы превратили теплый день в холодный, и выплатили наши долги с помощью одного маленького знака минус? Вот мощь унарного оператора минус!

Оператор адреса (&) в C

Теперь погружемся в чуть более сложную тему – оператор адреса. Этот маленький амперсанд (&) похож на GPS для наших переменных, указывая точное местоположение в памяти компьютера.

#include <stdio.h>

int main() {
int возраст = 25;
float рост = 1.75;

printf("Значение возраста: %d\n", возраст);
printf("Адрес возраста: %p\n", (void*)&возраст);

printf("Значение роста: %.2f\n", рост);
printf("Адрес роста: %p\n", (void*)&рост);

return 0;
}

Вывод (нота: фактические адреса будут варьироваться):

Значение возраста: 25
Адрес возраста: 0x7ffd5e8e3994
Значение роста: 1.75
Адрес роста: 0x7ffd5e8e3998

Здесь мы не только смотрим на значения наших переменных, но и подглядываем в их секретные укрытия в памяти. Круто, правда?

Оператор dereference (*) в C

Оператор dereference похож на карту сокровищ – он помогает нам найти значение, спрятанное в определенном адресе памяти. Это парный оператор для нашего оператора адреса.

#include <stdio.h>

int main() {
int сокровище = 1000;
int *карта = &сокровище;

printf("Значение сокровища: %d\n", сокровище);
printf("Карта указывает на: %p\n", (void*)карта);
printf("Найдено сокровище: %d\n", *карта);

*карта = 2000;  // Изменяем сокровище!
printf("Новое значение сокровища: %d\n", сокровище);

return 0;
}

Вывод:

Значение сокровища: 1000
Карта указывает на: 0x7ffd5e8e3994
Найдено сокровище: 1000
Новое значение сокровища: 2000

В этом примере наша 'карта' (указатель) ведет нас к сокровищу, и мы даже можем изменить значение сокровища с помощью оператора dereference. Это как магия!

Логический оператор NOT (!) в C

Логический оператор NOT похож на бунтаря – он превращает истину в ложь и ложь в истину. В C любое не нулевое значение считается истиной, а ноль – ложью.

#include <stdio.h>

int main() {
int солнечно = 1;  // 1 означает истину
int дождливо = 0;  // 0 означает ложь

printf("Солнечно? %d\n", солнечно);
printf("Не солнечно? %d\n", !солнечно);

printf("Дождливо? %d\n", дождливо);
printf("Не дождливо? %d\n", !дождливо);

return 0;
}

Вывод:

Солнечно? 1
Не солнечно? 0
Дождливо? 0
Не дождливо? 1

Смите, как наш логический оператор NOT переворачивает погодные условия? Это как если бы у нас была кнопка "наоборотный день"!

Оператор 1's Complement (~) в C

Наконец, поговорим о операторе 1's Complement. Этот оператор переворачивает все биты в числе, превращая 0 в 1 и наоборот. Это как если бы вы дали вашему двоичному числу полную перекраску!

#include <stdio.h>

int main() {
unsigned char a = 5;  // Двоично: 00000101
unsigned char b = ~a; // Двоично: 11111010

printf("Исходное значение: %d\n", a);
printf("Комплемент значение: %d\n", b);

printf("Двоичное представление:\n");
printf("a: ");
for (int i = 7; i >= 0; i--) {
printf("%d", (a >> i) & 1);
}
printf("\nb: ");
for (int i = 7; i >= 0; i--) {
printf("%d", (b >> i) & 1);
}
printf("\n");

return 0;
}

Вывод:

Исходное значение: 5
Комплемент значение: 250
Двоичное представление:
a: 00000101
b: 11111010

В этом примере мы видим, как оператор 1's Complement переворачивает каждый бит. Это как вывернуть ваше двоичное число наизнанку!

Итак, у нас все унарные операторы в C. Помните, практика – это основа, так что не стесняйтесь экспериментировать с этими операторами в своем коде. Счастливого кодирования, и май унарные операторы быть с вами!

Credits: Image by storyset