Преговор - УПП, Седмица 2, 13.10.2023

Reading: 6 min || Created: 12 October 2023 || Edited: 26 February 2024 || GitLab source

Конвертиране на данни, побитови оператори, условни оператори

Конвертиране на данни

Неявно (скрито, експлицитно): компилаторът сам се досеща да промени типа
```
int a = 5;
double b = a;
```
Явно (изрично, експлицитно): казваме как типът да се конвертира
```
double a = 5.7, b = 3.42;
int m = (int)a + (int)b;
```

Със загуба на информация (от по-голям тип в по-малък)
```
double a = 5.8371;
int b = a;
```
Без загуба на информация (от по-малък тип в по-голям)
```
int a = 1000;
long b = a;
```

Побитови оператори

Първо ще ги погледнем чисто теоретично.

Внимавайте, те са различни от логическите оператори!

Означавам побитовите числа с водеща буква “b”! Тоест, числото b1001 е двоичното число 1001, което е десетичното число 9.

Отрицание/негация, ~: обръща 0 в 1 и 1 в 0
```
~ b0010 = b1101
```

Побитово “и”, &: за два бита, ако и двете са 1, връща 1, иначе връща 0
```
3 & 5 = 1
b0011 & b0101 = b0001
```
Побитово “или”, |: за два бита, ако и двете са 0, връща 0, иначе връща 1
```
3 | 5 = 7
b0011 | b0101 = b0111
```
Изключващо “или”, ^: ако само един от двата бита е 1, връща 1, иначе връща 0
```
3 ^ 5 = 6
b0011 ^ b0101 = b0110
```

Побитово отместване на ляво, <<: отмества всеки бит с n позиции на ляво
Винаги “запълва” с нули (няма разлика между логическо и аритметично ляво отместване)
```
b1010 << 1 = b0100
b0001 << 3 = b1000
```
(приемаме, че типа данни съхранява само 4 бита данни)
Побитово отместване на дясно, >>: отмества всеки бит с n позиции на дясно
При аритметичното отместване, дупките се запълват с предходната стойност на старшия бит
При логическото отместване, винаги запълваме с 0
В C++ има един оператор, дали е аритметическо или логическо се определя от типа
```
b1000 >> 1 = b0100 или пък b1100
b1010 >> 3 = b0001 или пък b1111
```

Примери с код:

int a = 3, b = 5;

int n1 = ~ a; // -4
int n2 = ~ (unsigned int)a; // 4294967292

int i1 = 3 & 5; // 1
int i2 = 3 | 5; // 7
int i3 = 3 ^ 5; // 6

int l1 = b << 1; // 10
int l2 = b << 3; // 40

int r1 =  b >> 1; // 2
int r2 =  b >> 2; // 1
int r3 = -b >> 1; // -3
int r4 = (unsigned int)b  >> 1; // 2
int r5 = (unsigned int)-b >> 1; // 2147483645

Логически оператори

Много приличат на побитовите, обаче побитовите работят върху битове, докато логическите работят върху bool.

!: обръща true във false и обратно
```
! true  // false
! false // true
```

&&: “логическо и”, ако и двете стойности са true, тогава и резултатът е true
```
true  && true  // true
false && true  // false
false && false // false
```
||: “логическо или”, само ако и двете са false, тогава е false
```
true  || true  // true
false || true  // true
false || false // false
```

Условни конструкции

if: приема булева стойност, ако е true, изпълнява кода в къдравите скоби, ако е false ги пропуска
```
if (expression) {
  dosomething;
}
dootherthing;
```
expression се конвертира към типа bool

Ако в къдравите скоби имаме един израз (тоест е само един ред код, завършващ на ;) можем да ги пропуснем.
```
if (expression) dosomething;
dootherthing;
```

if-else: работи като if, обаче след къдравите скоби добавяме else { ... }.
```
if (expression) {
  dothing1;
}
else {
  dothing2;
}
dootherthing;
```
Ако expression е истина, dothing1 се изпълнява и dothing2 се пропуска изцяло. Аналогично, ако expression е лъжа, dothing1 се изпуска и dothing2 се изпълнява.

Както с if, ако dothing2 е само един израз, можем да пропуснем къдравите скоби
```
if (expression) {
  dothing1;
}
else dothing2;
dootherthing;
```

благодарение на изпускането на къдрави скоби, можем да пишем

if (expression1) {
  doSomething1;
}
else if (expression2) {
  doSometing2;
}
...
else {
  doSomethingN;
}

Това е еквивалентно на:

if (expression1) doSomething1;
else {
  if (expression2) doSomething2;
  else {
      ...
          else doSomethingN;
  }
}

expression винаги се конвертира до тип bool (ако е нужно)
Никога не правете такива неща:
```
bool a;
if (expression) a = true;
else a = false;
```
```
bool a = false;
if (expression) a = true;
```
Просто правите bool a = expression;
```
bool a;
if (expression) a = false;
else a = true;
```
Просто правите bool a = ! expression;

Тернарен оператор: ако искате да имате такава условна конструкция като част от израз (който взема стойност) използвате
```
(expression) ? valueA : valueB
```
Ако expression е истина, връща се valueA, иначе се връща valueB
```
int grade;
std::cin >> grade;
double a = (grade < 300) ? 2.0 : grade / 100.0;
```
Има много нисък приоритет, в повечето случаи ще ви се наложи да го оградите в скоби.
```
int grade;
std::cin >> grade;
std::cout << ((grade < 300) ? 2.0 : grade / 100.0);
```

switch: приема стойност и изпълнява случая, при който стойността съвпада с определената
```
switch (value) {
  case valueA: doSomething1; break;
  case valueB: doSomething2; break;
  case valueC: doSomething3; break;
}
```
Служи като улеснение на синтаксиса:
```
if (value == valueA) doSomething1;
else if (value == valueB) doSomething2;
else if (value == valueC) doSomething3;
```
otherwise е като else, това е случая когато не съвпада с никоя стойност. Може да бъде изпуснат.

Без break изпълнението продължава към следващия case

char characterInput;
std::cin >> characterInput;
switch(characterInput) {
    case 'h':
    case '?': std::cout << "This is a helpful message."; break;
    case 'w': std::cout << "Hello World"; break;
    default: std::cout << "Error"; break;
}