Značky: C logické operátory, logická negácia, logické NIE, !, logické ALEBO, logické sčítanie, OR, logické násobenie, logické AND, AND, poradie vykonávania logické operátory

Logické operátory

Booleovské operátory sú operátory, ktoré berú boolovské hodnoty (false alebo true) ako argumenty a vracajú boolovskú hodnotu. Rovnako ako bežné operátory môžu byť jednomiestne (unárne, to znamená vziať jeden argument), dvojmiestne (binárne, vziať dva argumenty), trojité atď.

Vlastnosťou jazyka C je, že nemá typ, ktorý ukladá boolovskú hodnotu (false alebo true). V C sa celé číslo 0 považuje za nepravdivé (logická nula) a každé nenulové celé číslo bude logickou pravdou. Napríklad

#include #include void main() ( char boolValue = -71; if (boolValue) ( ​​​​printf("boolValue je pravda"); ) else ( printf("boolValue je false"); ) _getch(); )

Booleovské hodnoty sú zvyčajne generované porovnávacími operátormi (==, !=, >,<, >=. <=).

Jazyk C má tri logické operátory: AND, OR a NOT. Začnime tým najjednoduchším

Logická negácia

Operátor NOT sa používa na invertovanie hodnoty argumentu. To znamená, že ak mu bola daná pravda, tak vráti lož, ak dostal lož ako argument, tak vráti pravdu.

Logický operátor NIE
X NIE X
0 1
1 0

V C je negácia reprezentovaná operátorom !. Napríklad

#include #include void main() ( int i = 0; if (i) ( printf("i je pravda\n"); ) if (!i) ( printf("i nie je pravda\n"); ) ak (!! i) ( printf("i nie je pravda\n"); ) if (!!!i) ( printf("i nie je pravda\n"); ) _getch(); )

Ako v bežnej logike, aj tu funguje zákon dvojitej negácie – negáciu negácie možno vynechať.

logické AND

Operátor AND (AND, logické násobenie) vráti hodnotu true vtedy a len vtedy, ak sú pravdivé oba argumenty.


Logický operátor AND
X Y X A Y
0 0 0
0 1 0
1 0 0
1 1 1

V C je logické násobenie reprezentované operátorom &&. Úlohou napríklad je, aby do okruhu vojenských vesmírnych námorníkov boli vpustení len dospelí muži. To znamená, že žiadateľom sa môže stať len ten, pre koho sú splnené obe podmienky súčasne.

#include void main() ( char gender; unsigned int age; printf("Zadajte pohlavie ("M" alebo "F")\n"); scanf("%c", &gender); printf("Zadajte vek\n") ; scanf("%u", &vek); if (pohlavie == "M" && vek > 17) ( printf("Vitajte"); ) else ( printf("Choď preč"); ) _getch(); )

Operátor AND možno použiť postupne na viacero argumentov. Platia pre ňu asociatívne a komutatívne zákony. Zlepšíme program, zavedieme aj rast:

#define _CRT_SECURE_NO_WARNINGS #include #include void main() ( char gender; unsigned int age; unsigned int height; printf("Zadajte pohlavie ("M" alebo "F")\n"); scanf("%c", &gender); printf("Zadajte vek" \n"); scanf("%u", &vek); printf("Zadajte výšku\n"); scanf("%u", &výška); if (pohlavie == "M" && vek > 17 && výška > = 180) ( printf("Vitajte"); ) else ( printf("Choďte preč"); ) _getch(); )

Tiež by sa dala napísať podmienka

(pohlavie == "M" && vek > 17) && výška >= 180

Pohlavie == "M" && (vek > 17 && výška >= 180)

(vek > 17 && výška >= 180) && pohlavie == "M"

Logické ALEBO

Logický operátor OR (logické sčítanie, OR) je pravdivý, ak je pravdivý aspoň jeden z jeho argumentov.


Logický operátor OR
X Y X ALEBO Y
0 0 0
0 1 1
1 0 1
1 1 1

V C je OR reprezentované operátorom ||. Napríklad, poďme vylepšiť program: teraz je možné zadať pohlavie veľkými aj malými písmenami

#define _CRT_SECURE_NO_WARNINGS #include #include void main() ( char genderInput; char gender; unsigned int age; unsigned int height; printf("Zadajte pohlavie ("M" alebo "F")\n"); scanf("%c", &genderInput); printf( "Zadajte vek\n"); scanf("%u", &vek); printf("Zadajte výšku\n"); scanf("%u", &výška); if (genderInput == "M" || genderInput = = "m") ( pohlavie = 1; ) else ( pohlavie = 0; ) if ((vek > 17 && výška >= 180) && pohlavie) ( printf("Vitajte"); ) else ( printf("Choď preč" ); ) _getch(); )

Rovnako ako operátor AND je OR komutatívny a asociatívny.

Operátory je možné navzájom miešať, vytvárať komplexných operátorov

#define _CRT_SECURE_NO_WARNINGS #include #include void main() ( char gender; unsigned int age; unsigned int height; printf("Zadajte pohlavie ("M" alebo "F")\n"); scanf("%c", &gender); printf("Zadajte vek" \n"); scanf("%u", &vek); printf("Zadajte výšku\n"); scanf("%u", &výška); if ((vek > 17 && výška >= 180) && (pohlavie == "M" || pohlavie == "m")) ( printf("Vitajte"); ) else ( printf("Choďte preč"); ) _getch(); )

Stačí si uvedomiť, že operátor negácie má vyššiu prioritu ako AND alebo OR, takže bude vykonaný ako prvý. Ak môže nastať situácia, že exekučný príkaz nie je jasný, definujte ho v zátvorkách.

Príklad: De Morganov zákon. Ak chcete zmeniť AND na OR (alebo naopak), musíte invertovať hodnoty všetkých operandov, nahradiť AND OR (alebo OR za AND) a invertovať konečný výsledok. V prípade nášho stavu

(vek > 17 && výška >= 180) && (pohlavie == "M" || pohlavie == "m")

Najprv zvážte kus

(vek > 17 && výška >= 180)

Obráťte všetky hodnoty

(!(vek > 17) && !(výška >= 180))

nahraďte operátor && za ||

(!(vek > 17) || !(výška >= 180))

a obrátiť odpoveď

!(!(vek > 17) || !(výška >= 180))

Ako vidíte, výsledok je rovnaký. To je zrejmé

! (vek > 17)

ekvivalentné k

Vek<= 17

Preto meníme podmienky

!(Vek<= 17 || height < 180)

Zmeňte druhú zátvorku rovnakým spôsobom

(pohlavie == "M" || pohlavie == "m")

!(pohlavie != "M" && pohlavie != "m")

!(Vek<= 17 || height < 180) && !(gender != "M" && gender != "m")

Teraz môžeme použiť rovnaké pravidlo pre celý výraz

!((Vek<= 17 || height < 180) || (gender != "M" && gender != "m"))

Poradie vykonávania logických operátorov

Zvážte výraz

A B C d

kde a, b, c, d sú boolovské hodnoty. Celý výraz je pravdivý vtedy a len vtedy, ak sú pravdivé všetky operandy. Ak je aspoň jeden z operandov nepravdivý, ostatné už nie sú dôležité. Preto, aby sa optimalizoval výkon, výpočet postupuje zľava doprava a zastaví sa hneď, ako sa nájde prvý nulový operand.

V jazyku C môže operátor priradenia vrátiť hodnotu. Niekedy sa používa priamo v stave:

#define _CRT_SECURE_NO_WARNINGS #include #include #include void main() ( int a = 0; int *p = if (a && (p = (int*) malloc(sizeof(int) * 2))) ( printf("pamäť bola pridelená"); ) free(p ); _getch(); )

V tomto prípade sa operátor malloc nevykoná, pretože prvý operand a je 0 (respektíve celý výraz je nula). Voľný operátor sa teda pokúsi vymazať pamäť, ktorú nemôže vymazať (pretože p bude naďalej odkazovať na a). Ak zmeníme a = 1, tak bude všetko fungovať bez problémov.

To isté sa stane pri vykonávaní ||. Výraz

A || b || c || d

prebieha zľava doprava, kým nenarazí na prvú nenulovú hodnotu. Potom sa vykonávanie zastaví, pretože je známe, že celý výraz sa rovná true.

S objektmi v jazyku C je možné vykonávať rôzne operácie:

  • operácie prideľovania;
  • operácie vzťahov;
  • aritmetika;
  • hlavolam;
  • zmenové operácie.

Výsledkom operácie je číslo.

Operácie môžu byť binárne alebo unárne.
Binárne operácie sa vykonávajú na dvoch objektoch, unárne operácie na jednom.

priraďovacia operácia

Operácia priradenia je označená symbolom = a vykonáva sa v 2 etapách:

  • vyhodnotí sa výraz na pravej strane;
  • výsledok je priradený operandu na ľavej strane:

predmet = výraz;

Príklad:

int a = 4; // premennej a je priradená hodnota 4
intb;
b = a + 2; // premennej b je priradená hodnota 6 vypočítaná na pravej strane

Ak majú objekty v ľavej a pravej časti operácie priradenia rôzne typy, použije sa operácia konverzie explicitného typu.
objekt = (typ)výraz;

Príklad:

float a = 241,5;
// Pred výpočtom zvyšku delenia sa a skonvertuje na celočíselný typ
int b = (int)a % 2; // b = 1

vzťahové operácie

Základné operácie vzťahov:

  • == ekvivalent - kontrola rovnosti;
  • != nerovná sa - skontrolujte nerovnosť;
  • < menej;
  • > viac;
  • <= menšie alebo rovnaké;
  • >= viac alebo rovné.

Relačné operácie sa používajú na organizáciu podmienok a vetiev. Výsledkom týchto operácií je 1 bit, ktorého hodnota je 1, ak je výsledok operácie pravdivý, a je 0, ak je výsledok operácie nepravdivý.

Aritmetické operácie

Základné binárne operácie usporiadané v zostupnom poradí podľa priority:

  • * - násobenie;
  • / - rozdelenie;
  • + - prídavok;
  • — - odčítanie;
  • % je zvyšok celočíselného delenia.

Základné unárne operácie:

  • ++ - zvýšenie (zvýšenie o 1);
  • -- - dekrementácia (zníženie o 1);
  • — - zmena znamienka.

Výsledok vyhodnotenia výrazu obsahujúceho operácie prírastku alebo znižovania závisí od toho, kde sa nachádza znamienko operácie (pred alebo za objektom). Ak sa operácia nachádza pred objektom, potom sa hodnota premennej najprv zmení na 1 a potom sa táto hodnota použije na vykonanie nasledujúcich operácií. Ak operácia ++ alebo — sa nachádza za premennou, potom sa najskôr vykoná operácia a potom sa hodnota premennej zmení na 1.

Príklad:

Binárne aritmetické operácie možno kombinovať s operátorom priradenia:

  • objekt *= výraz; // objekt = objekt * výraz
  • objekt /= výraz; // objekt = objekt / výraz
  • objekt += výraz; // objekt = objekt + výraz
  • objekt -= výraz; // objekt = objekt - výraz
  • objekt %= výraz; // objekt = objekt % výraz

Booleovské operácie

Logické operácie sú rozdelené do dvoch skupín:

  • podmienené;
  • bitovo.

Podmienené logické operácie sa najčastejšie používajú v operáciách kontroly stavu if a môžu sa vykonávať na akomkoľvek objekte. Výsledok podmienenej booleovskej operácie:

  • 1, ak je výraz pravdivý;
  • 0, ak je výraz nepravdivý.

Vo všeobecnosti sú všetky nenulové hodnoty interpretované podmienenými booleovskými operáciami ako pravdivé.

Základné podmienené logické operácie:

  • && - A (binárne) - vyžaduje sa súčasné vykonávanie všetkých operácií vzťahu;
  • || - OR (binárne) - vyžaduje sa aspoň jedna operácia vzťahu;
  • ! - NOT (unárne) - vyžaduje sa nevykonanie operácie vzťahu.

Bitové logické operácie fungujú s bitmi, z ktorých každý môže nadobúdať iba dve hodnoty: 0 alebo 1.

Základné bitové logické operácie v jazyku C:

  • & konjunkcia (logický AND) - binárna operácia, ktorej výsledok je 1 iba vtedy, keď sú oba operandy jediné (vo všeobecnom prípade, keď sú všetky operandy jednoduché);
  • | disjunkcia (logické OR) - binárna operácia, ktorej výsledok je 1, keď aspoň jeden z operandov je 1;
  • ~ inverzia (logické NOT) je unárna operácia, ktorej výsledkom je 0, ak je operand jediný, a je 1, ak je operand nulový;
  • ^ XOR je binárna operácia, ktorej výsledok je 1, ak iba jeden z dvoch operandov je 1 (vo všeobecnosti, ak má vstupná množina operandov nepárny počet 1s).

Pre každý bit sa získa výsledok operácie v súlade s tabuľkou.

a b a&b a | b ~a a^b
0 0 0 0 1 0
0 1 0 1 1 1
1 0 0 1 0 1
1 1 1 1 0 0

Príklad:

1
2
3
4
5
6
7

unsigned char a = 14; // a = 0000 1110
unsigned char b = 9; // b = 0000 1001
bez znamienka char c, d, e, f;
c = a&b; // c = 8 = 0000 1000
d = a | b; // d = 15 = 0000 1111
e = ~a; // e = 241 = 1111 0001
f = a^b; // f = 7 = 0000 0111


Bitové operácie umožňujú nastaviť a resetovať jednotlivé bity čísla. Na tento účel sa používa bitové maskovanie. V tabuľke sú uvedené masky zodpovedajúce nastaveniu každého bitu v byte

Trocha Maska
0 0x01
1 0x02
2 0x04
3 0x08
4 0x10
5 0x20
6 0x40
7 0x80

Ak chcete nastaviť určitý bit, musíte nastaviť zodpovedajúci bit masky na 1 a vykonať bitovú logickú operáciu OR s konštantou reprezentujúcou masku.

Posledná aktualizácia: 19.06.2017

Samostatná množina operácií predstavuje podmienené výrazy. Takéto operácie vracajú boolovskú hodnotu, teda hodnotu typu bool : true, ak je výraz pravdivý, a false, ak je výraz nepravdivý. Tieto operácie zahŕňajú porovnávacie operácie a logické operácie.

Porovnávacie operácie

Porovnávacie operátory porovnávajú dva operandy a vrátia bool - true, ak je výraz pravdivý, a nepravdu, ak je výraz nepravdivý.

    Porovnáva dva operandy pre rovnosť. Ak sú rovnaké, operácia vráti hodnotu true , ak sa nerovnajú, vráti sa hodnota false:

    B; // nepravda

    Porovná dva operandy a vráti hodnotu true, ak sa operandy nerovnajú, a hodnotu false, ak sú rovnaké.

    int a = 10; int b = 4; bool c = a != b; // true bool d = a!=10; // nepravda

    Menej ako prevádzka. Vráti hodnotu true, ak je prvý operand menší ako druhý, a hodnotu false, ak je prvý operand väčší ako druhý:

    int a = 10; int b = 4; bool c = a< b; // false

    Operácia „väčšia ako“. Porovná dva operandy a vráti hodnotu true, ak je prvý operand väčší ako druhý, inak vráti hodnotu false:

    int a = 10; int b = 4; bool c = a > b; // true bool d = a > 25; // nepravda

    Prevádzka menšia alebo rovná. Porovná dva operandy a vráti hodnotu true, ak je prvý operand menší alebo rovný druhému. V opačnom prípade vráti hodnotu false.

    int a = 10; int b = 4; bool c = a<= b; // false bool d = a <= 25; // true

    Väčšie alebo rovné prevádzke. Porovná dva operandy a vráti hodnotu true, ak je prvý operand väčší alebo rovný druhému, inak vráti hodnotu false:

    int a = 10; int b = 4; bool c = a >= b; // true bool d = a >= 25; // nepravda

Operácie<, > <=, >= majú vyššiu prioritu ako == a !=.

Booleovské operácie

C# tiež definuje logické operátory, ktoré tiež vracajú boolovu hodnotu. Akceptujú boolovské hodnoty ako operandy. Zvyčajne sa používa na vzťahy a kombinuje viaceré porovnávacie operácie.

    Operácia logického sčítania alebo logického ALEBO. Vráti hodnotu true, ak aspoň jeden z operandov vráti hodnotu true.

    bool x1 = (5 > 6) | (štyri< 6); // 5 >6 - nepravda, 4< 6 - true, поэтому возвращается true bool x2 = (5 >6) | (4 > 6); // 5 > 6 - nepravda, 4 >

    Booleovské násobenie alebo logické AND. Vráti hodnotu true, ak sú oba operandy pravdivé súčasne.

    bool x1 = (5 > 6) & (4< 6); // 5 >6 - nepravda, 4< 6 - true, поэтому возвращается false bool x2 = (5 < 6) & (4 < 6); // 5 < 6 - true, 4 < 6 - true, поэтому возвращается true

    Operácia logického sčítania. Vráti hodnotu true, ak aspoň jeden z operandov vráti hodnotu true.

    bool x1 = (5 > 6) || (štyri< 6); // 5 >6 - nepravda, 4< 6 - true, поэтому возвращается true bool x2 = (5 >6) || (4 > 6); // 5 > 6 je nepravda, 4 > 6 je nepravda, takže sa vráti false

    Operácia logického násobenia. Vráti hodnotu true, ak sú oba operandy pravdivé.

    bool x1 = (5 > 6) && (4< 6); // 5 >6 - nepravda, 4< 6 - true, поэтому возвращается false bool x2 = (5 < 6) && (4 < 6); // 5 < 6 - true, 4 < 6 - true, поэтому возвращается true

    Operácia logickej negácie. Vykonáva sa na jednom operande a vráti hodnotu true, ak je operand nepravdivý. Ak je operand pravdivý, operácia vráti hodnotu false:

    bool a = pravda; bool b = !a; // nepravda

    Výhradná prevádzka OR. Vráti hodnotu true, ak je buď prvý alebo druhý operand (ale nie obidva) pravdivé, inak vráti hodnotu false

    bool x5 = (5 > 6)^(4< 6); // 5 >6 - nepravda, 4< 6 - true, поэтому возвращается true bool x6 = (50 > 6) ^ (4 / 2 < 3); // 50 >6 - pravda, 4/2< 3 - true, поэтому возвращается false

Tu máme dva páry operácií | a || (rovnako ako & a &&) vykonávajú podobné akcie, ale nie sú ekvivalentné.

Vo výraze z=x|y; vypočítajú sa hodnoty x aj y.

Vo výraze z=x||y; najprv sa vypočíta hodnota x a ak sa rovná true , potom výpočet hodnoty y už nemá zmysel, pretože v každom prípade už máme z rovné true . Hodnota y sa vyhodnotí iba vtedy, ak je x nepravdivé

To isté platí pre pár operácií &/&&. Vo výraze z=x budú vypočítané obe hodnoty - x aj y.

Vo výraze z=x& sa najprv vypočíta hodnota x a ak sa rovná false , tak výpočet hodnoty y už nemá zmysel, keďže v každom prípade už máme z rovné false . Hodnota y sa vyhodnotí iba vtedy, ak je x pravdivé

Preto operácie || a && sú pri výpočtoch pohodlnejšie, pretože umožňujú skrátiť čas na vyhodnotenie hodnoty výrazu, a tým zlepšiť výkon. A operácie | a & sú vhodnejšie na vykonávanie bitových operácií s číslami.

Akýkoľvek jazykový výraz pozostáva z operandov (premenných, konštánt atď.) spojených operačnými znakmi. Znak operátora je znak alebo skupina znakov, ktorá hovorí kompilátoru, aby vykonal určité aritmetické, logické alebo iné operácie.

Operácie sa vykonávajú v prísnom poradí. Hodnota, ktorá určuje prednostné právo na vykonanie konkrétnej operácie, sa nazýva priorita. V tabuľke. 2 sú uvedené rôzne operácie jazyka C (C). Ich priority pre každú skupinu sú rovnaké (skupiny sú farebne zvýraznené). Čím väčšiu výhodu má príslušná skupina operácií, tým vyššie sa nachádza v tabuľke. Poradie, v ktorom sa operácie vykonávajú, je možné ovládať pomocou zátvoriek.

Tabuľka 2 - operácie

Prevádzkový znak

Účel operácie

Volanie funkcie

Výber prvku poľa

Zvýraznenie prvku záznamu

Zvýraznenie prvku záznamu

Logická negácia

Bitová negácia

Zmena znamienka

Zvýšenie jednotky

Znížiť o jednu

Prijatie adresy

Kontaktovať podľa adresy

Konverzia typu (t. j. (float) a)

Určenie veľkosti v bajtoch

Násobenie

Definícia zvyšku delenia

Doplnenie

Odčítanie

Shift doľava

posun doprava

Menej ako

Menej alebo rovnaké

Viac ako

Viac alebo rovnaké

Bitové logické "A"

Bitový XOR

Bitové logické "ALEBO"

Logika "A"

logické "ALEBO"

Podmienená (ternárna) operácia

Pridelenie

+=, - =, *=, /=, %=, <<=,
>>=, &=, |=, ^=

Binárne operácie (napríklad a *= b
(t. j. a = a * b) atď.)

Operačná čiarka

Operátor v jazyku C (C)

Aby sme vylúčili zmätok v pojmoch „prevádzka“ a „operátor“, poznamenávame, že operátor je najmenšia spustiteľná jednotka programu. Existujú výrazové operátory, ktorých úlohou je vyhodnotiť dané výrazy (napríklad: a = sin(b)+c; j++;), deklaračné operátory, zložené operátory, prázdne operátory, operátory návestí, operátory cyklov atď. Na označenie konca príkazu v C (C) sa používa bodkočiarka. Pokiaľ ide o zložený príkaz (alebo blok), ktorý je množinou logicky súvisiacich príkazov umiestnených medzi otváracími (() a uzatváracími ()) zloženými zátvorkami ("operátorovými zátvorkami"), za ním nenasleduje bodkočiarka. Všimnite si, že blok sa líši od zloženého príkazu prítomnosťou definícií v tele bloku.

Charakteristika základných operácií jazyka C (C)

Charakterizujme hlavné operácie jazyka SI (C).

priraďovacia operácia

Najprv zvážte jeden z nich - operátor priradenia (=). Vyjadrenie formy

priradí hodnotu x y. Operátor "=" možno použiť viackrát v jednom výraze, napríklad:

x=y=z=100;

Existujú unárne a binárne operácie. Prvý z nich má jeden operand a druhý má dva. Začnime ich uvažovanie operáciami priradenými k prvej z nasledujúcich tradičných skupín:

Aritmetické operácie.

Logické a relačné operácie.

Operácie s bitmi.

Aritmetické operácie sú špecifikované nasledujúcimi symbolmi (tabuľka 2): +, -, *, /, % . Posledný z nich nemožno použiť na premenné reálneho typu. Napríklad:

a = b + c;
x = y - z;
r = t*v;
s = k/l;
p = q % w;

Booleovské operácie

Logické operácie vzťahu sú špecifikované nasledujúcimi symbolmi (pozri tabuľku 2): && ("AND"), || ("ALEBO"), ! ("NIE"), >, >=,<, <= , = = (равно), != (не равно). Традиционно эти операции должны давать одно из двух значений: истину или ложь. В языке СИ (C)принято следующее правило: истина - это любое ненулевое значение; ложь - это нулевое значение. Выражения, использующие логические операции и операции отношения, возвращают 0 для ложного значения и 1 для истинного. Ниже приводится таблица истинности для логических операций.

Bitové operácie možno použiť na premenné typu int, char a ich varianty (napríklad long int). Nemožno ich použiť na premenné typu float, double, void (alebo komplexnejšie typy). Tieto operácie sú špecifikované nasledujúcimi symbolmi: ~ (bitová negácia),<< (сдвиг влево), >> (posun doprava), & (bitový AND), ^ (bitový XOR), | (bitové "ALEBO").

Príklady: ak a=0000 1111 a b=1000 1000 potom

~a = 1111 0000,
a<< 1 = 0001 1110,
a >> 1 = 0000 0111,
a & b = 0000 1000,
a^b=10000111,
a | b = 1000 1111.

Jazyk poskytuje dva nekonvenčné operátory inkrementácie (++) a dekrementácie (--). Sú navrhnuté tak, aby zvýšili a znížili o jednu hodnotu operandu. Operátory ++ a -- môžu byť napísané pred alebo za operand. V prvom prípade (++n alebo --n) sa hodnota operandu (n) zmení pred jeho použitím v zodpovedajúcom výraze a v druhom prípade (n++ alebo n--) po jeho použití. Zvážte nasledujúce dva riadky programu:

a = b + c++;
a1 = b1 + ++cl;

Predpokladajme, že b = b1 = 2, c = c1 = 4. Potom po vykonaní operácií: a = 6, b = 2, c = 5, a1 = 7, b1 = 2, c1 = 5.

Široko používané sú aj výrazy s inou netradičnou ternárnou alebo podmienenou operáciou ?:. Vo vzorci

y = a, ak x nie je nula (t. j. pravda), a y = b, ak x je nula (nepravda). Nasledujúci výraz

y = (a>b) ? a:b;

umožňuje priradiť premennej y hodnotu väčšej premennej (a alebo b), t.j. y = max (a, b).

Ďalším rozdielom jazyka je, že výraz v tvare a = a + 5; možno písať v inom tvare: a += 5;. Namiesto znamienka + možno použiť aj symboly iných binárnych operácií (pozri tabuľku 2).

Ďalšie operácie zo stola. 2 budú opísané v nasledujúcich odsekoch.

Slučky sú organizované tak, aby vykonali určitý príkaz alebo skupinu príkazov určitý počet krát. V jazyku C (C) existujú tri príkazy cyklu: for, while a do - while. Prvý z nich je formálne napísaný takto:

for (výraz_1; výraz_2; výraz_3) telo_slučky

Telo cyklu je buď jeden príkaz, alebo niekoľko príkazov, ktoré sú v ňom uzavreté rovnátka( ... ) (za blokom nie je bodkočiarka). Výrazy 1, 2, 3 obsahujú špeciálnu premennú nazývanú riadiaca premenná. Jeho hodnotou je nastavená potreba zopakovať cyklus alebo z neho vystúpiť.

Výraz_1 priradí riadiacej premennej počiatočnú hodnotu, výraz_3 ju v každom kroku zmení a výraz_2 skontroluje, či dosiahol hraničnú hodnotu, ktorá určuje potrebu ukončiť cyklus.

pre (i = 1; i< 10; i++)

for (ch = "a"; ch != "p";) scanf ("%c", &ch);

/* Slučka bude vykonaná až do klávesnice

znak "p" nebude zadaný */

Ktorýkoľvek z troch výrazov v pre slučku možno vynechať, ale bodkočiarka musí zostať. Takže pre (; ;) (...) je nekonečná slučka, z ktorej sa dá vystúpiť iba inými spôsobmi.

Nasledujúce pravidlo je prijaté v jazyku SI (C). Akýkoľvek výraz priradenia uzavretý v zátvorkách má rovnakú hodnotu ako priraďovaný výraz. Napríklad výraz (a=7+2) má hodnotu 9. Potom môžete napísať ďalší výraz, napríklad: ((a=7+2)<10), которое в данном случае будет всегда давать истинное значение. Следующая конструкция:

((ch = getch()) == "i")

umožňuje zadať hodnotu premennej ch a dať pravdivý výsledok len vtedy, keď je zadaná hodnota písmeno "i". V zátvorkách môžete napísať niekoľko vzorcov, ktoré tvoria zložitý výraz. Na tieto účely sa používa operácia čiarka. Vzorce sa vyhodnotia zľava doprava a celý výraz nadobudne hodnotu posledného vyhodnoteného vzorca. Napríklad, ak existujú dve premenné typu char, potom výraz

z = (x = y, y = getch());

definuje nasledujúce akcie: hodnota premennej y je priradená k premennej x; znak sa zadáva z klávesnice a priraďuje sa premennej y; z dostane hodnotu y. Zátvorky sú tu potrebné, pretože operátor čiarky má nižšiu prioritu ako operátor priradenia zapísaný za premennou z. Operátor čiarky sa široko používa na vytváranie výrazov pre slučku a umožňuje vám paralelne meniť hodnoty niekoľkých riadiacich premenných.

Povolené sú vnorené konštrukcie, t.j. telo cyklu môže obsahovať iné príkazy for.

Príkaz while je formálne napísaný takto:

while (výraz) loop_body

Výraz v zátvorkách môže mať nenulovú (pravda) alebo nulovú (nepravdivú) hodnotu. Ak je to pravda, potom sa vykoná telo cyklu a výraz sa vyhodnotí znova. Ak je výraz nepravdivý, cyklus while sa skončí.

Príkaz do-while je formálne napísaný takto:

do (loop_body) while (výraz);

Hlavný rozdiel medzi slučkami while a do-while je v tom, že telo v slučke do-while sa vykoná aspoň raz. Telo cyklu sa bude vykonávať, kým sa výraz v zátvorkách nevyhodnotí ako nepravda. Ak je pri vstupe do slučky nepravdivý, jeho telo sa vykoná presne raz.

Je povolené vkladanie niektorých slučiek do iných, t.j. príkazy for, while a do-while sa môžu objaviť v tele ľubovoľného cyklu.

Nové príkazy break a continue možno použiť v tele cyklu. Príkaz break poskytuje okamžitý výstup z cyklu, príkaz continue spôsobí ukončenie nasledujúcej iterácie a začiatok ďalšej iterácie.

Operátory podmieneného a nepodmieneného skoku

Na organizovanie podmienených a nepodmienených skokov v programe C (C) sa používajú nasledujúce príkazy: if - else, switch a goto. Prvý je napísaný takto:

if (check_condition) statement_1; else výpis_2;

Ak sa podmienka v zátvorkách vyhodnotí ako pravdivá, vykoná sa príkaz_1, ak nepravda, vykoná sa príkaz_2. Ak je potrebné vykonať viacero príkazov namiesto jedného, ​​sú uzavreté v zložených zátvorkách. Príkaz if nesmie obsahovať slovo else.

V príkaze if - else musia za kľúčovými slovami if a else ihneď nasledovať ďalšie príkazy. Ak je aspoň jeden z nich príkaz if, nazýva sa vnorený. Podľa konvencie jazyka C slovo else vždy odkazuje na najbližšie, ak mu predchádza.

Príkaz switch vám umožňuje vybrať si jednu z niekoľkých alternatív. Je napísaný v tejto formálnej forme:

prepínač (výraz)

prípad konštanta_1: výroky_1;

case konštanta_2: statement_2;

........ ........

predvolene: operator_default;

Tým sa vyhodnotí hodnota celého výrazu v zátvorkách (niekedy nazývaný selektor) a porovná sa so všetkými konštantami (konštantnými výrazmi). Všetky konštanty musia byť odlišné. Ak existuje zhoda, vykoná sa zodpovedajúci variant príkazu (jeden alebo viac príkazov). Variant s predvoleným kľúčovým slovom sa implementuje, ak sa nezhoduje žiadne z ostatných (slovo predvolené môže chýbať). Ak predvolená hodnota chýba a všetky výsledky porovnania sú negatívne, nevykoná sa žiadna z možností.

Na zastavenie následných kontrol po úspešnom výbere niektorej možnosti sa používa príkaz break, ktorý poskytuje okamžitý odchod z prepínača.

Vnorené konštrukcie prepínačov sú povolené.

Zvážte pravidlá vykonávania bezpodmienečného skoku, ktoré môžu byť znázornené v nasledujúcej forme:

goto štítok;

Označenie je ľubovoľný identifikátor, za ktorým nasleduje dvojbodka. Príkaz goto určuje, že vykonávanie programu by malo pokračovať od príkazu, ktorému predchádza označenie. Označenie možno umiestniť pred ľubovoľný príkaz vo funkcii, kde sa nachádza príslušný príkaz goto. Netreba to oznamovať.

Turbo debugger plne podporuje syntax výrazov v jazyku C (C). Výraz pozostáva zo zmesi operácií, reťazcov, premenných

Keďže som v predchádzajúcom článku najskôr použil logickú operáciu, poviem vám, ktoré to sú, koľko ich je a ako ich používať.

V C++ existujú tri logické operácie:

  1. Logická operácia AND && už vieme;
  2. Logická operácia ALEBO || ;
  3. Logická operácia NIE ! alebo logická negácia.

Logické operácie tvoria komplexnú (zloženú) podmienku z niekoľkých jednoduchých (dvoch alebo viacerých) podmienok. Tieto operácie niekoľkonásobne zjednodušujú štruktúru programového kódu. Áno, zaobídete sa aj bez nich, ale potom sa počet if niekoľkonásobne zvyšuje v závislosti od stavu. Nasledujúca tabuľka stručne charakterizuje všetky logické operácie v programovacom jazyku C++ na vytváranie logických podmienok.

Teraz by ste mali pochopiť rozdiel medzi logickou operáciou AND a logickou operáciou OR, aby ste sa v budúcnosti nemýlili. Je čas zoznámiť sa s typom údajov bool- logické. Tento typ údajov môže mať dve hodnoty: true (true) a false (false). Podmienka, ktorá sa má skontrolovať v príkazoch select, má dátový typ bool . Zvážte princíp nasledujúceho programu a so všetkými týmito logickými operáciami bude všetko jasné.

// or_and_not.cpp: Určuje vstupný bod pre aplikáciu konzoly. #include "stdafx.h" #include pomocou menného priestoru std; int main(int argc, char* argv) ( bool a1 = pravda, a2 = nepravda; // deklarácia boolovských premenných bool a3 = pravda, a4 = nepravda; cout<< "Tablica istinnosti log operacii &&" << endl; cout << "true && false: " << (a1 && a2) << endl // логическое И << "false && true: " << (a2 && a1) << endl << "true && true: " << (a1 && a3) << endl << "false && false: " << (a2 && a4) << endl; cout << "Tablica istinnosti log operacii ||" << endl; cout << "true || false: " << (a1 || a2) << endl // логическое ИЛИ << "false || true: " << (a2 || a1) << endl << "true || true: " << (a1 || a3) << endl << "false || false: " << (a2 || a4) << endl; cout << "Tablica istinnosti log operacii !" << endl; cout << "!true: " << (! a1) << endl // логическое НЕ << "!false: "<< (! a2) << endl; system("pause"); return 0; }

Riadky 9 a 10mali by ste mať jasno, pretože premenné tohto typu sa inicializujú tu bool . A každej premennej je priradená hodnota pravda alebo lož . Počnúc 9. riadok a končí 20, ukazujúci použitie logických operácií. Výsledok programu (pozri obrázok 1).

Tablica istinnosti log operacii && pravda && nepravda: 0 nepravda && pravda: 0 pravda && pravda: 1 nepravda && nepravda: 0 Tablica istinnosti log operacii || pravda || nepravda: 1 nepravda || pravda: 1 pravda || pravda: 1 nepravda || nepravda: 0 !true: 0 !false: 1 Pokračujte stlačením ľubovoľného klávesu. . .

Obrázok 1 - Logické operácie C++

Pravdepodobne máte otázku: "Aké sú tieto nuly a jednotky?". Ak existuje otázka, musí byť zodpovedaná. Odpovedám: „Nula je vyjadrením logickej hodnoty nepravda (nepravda), ale jednotky sú logickou hodnotou pravda (pravda). Dovoľte mi stručne vysvetliť niektoré body. Zložená podmienka pomocou booleovskej hodnoty A je pravdivé iba vtedy, ak sú splnené obe jednoduché podmienky. Vo všetkých ostatných prípadoch je zložená podmienka nepravdivá. Zložená podmienka využívajúca logické OR je nepravdivá iba vtedy, ak sú obe jednoduché podmienky nepravdivé. Vo všetkých ostatných prípadoch platí zložená podmienka. Logická negácia NIE je unárna operácia a na rozdiel od logických operácií nekombinuje dve podmienky A a ALEBO, čo sú binárne operácie. Logická negácia vám umožňuje obrátiť význam podmienky, čo je v niektorých prípadoch veľmi výhodné. Podmienka s logickou negáciou je pravdivá, ak je rovnaká podmienka nepravdivá bez negácie, a naopak.