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

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

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

Неявно (скрито, експлицитно): компилаторът сам се досеща да промени типа

  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;
}