Címkék: L logikai operátorok, logikai negáció, logikai NEM, !, logikai VAGY, logikai összeadás, VAGY, logikai szorzás, logikai ÉS, ÉS, végrehajtási sorrend logikai operátorok

Logikai operátorok

A logikai operátorok olyan operátorok, amelyek logikai értékeket (hamis vagy igaz) vesznek fel argumentumként, és logikai értéket adnak vissza. A közönséges operátorokhoz hasonlóan lehetnek egyhelyesek (unárisak, azaz egy argumentumot vehetnek fel), kéthelyesek (binárisak, két argumentumot vehetnek fel), hármasak és így tovább.

A C nyelv sajátossága, hogy nincs olyan típusa, amely logikai értéket tárol (hamis vagy igaz). C-ben a 0 egész szám hamisnak (logikai nullának) számít, és minden nullától eltérő egész szám logikai igazságnak számít. Például

#beleértve #beleértve void main() ( char boolValue = -71; if (boolÉrték) (printf("boolÉrték igaz"); ) else ( printf("boolÉrték hamis"); ) _getch(); )

A logikai értékeket általában összehasonlító operátorok generálják (==, !=, >,<, >=. <=).

A C nyelvnek három logikai operátora van: ÉS, VAGY és NEM. Kezdjük a legegyszerűbbel

Logikai tagadás

A NOT operátort egy argumentum értékének invertálására használják. Vagyis ha igazat adtak neki, akkor viszonozza a hazugságot, ha hazugságot kapott érvként, akkor az igazságot adja vissza.

Logikai operátor NEM

x	NEM X
0	1
1	0

C-ben a negációt a ! operátor képviseli. Például

#beleértve #beleértve void main() ( int i = 0; if (i) ( printf("i igaz\n"); ) if (!i) ( printf("i nem igaz\n"); ) if (!! i) ( printf("i nem igaz\n"); ) if (!!!i) ( printf("i nem nem igaz\n"); ) _getch(); )

A hétköznapi logikához hasonlóan itt is a kettős tagadás törvénye működik - a tagadás tagadása elhagyható.

logikus ÉS

Az ÉS operátor (ÉS, logikai szorzás) akkor és csak akkor ad vissza igaz értéket, ha mindkét argumentum igaz.

Logikai operátor ÉS

x	Y	X ÉS Y
0	0	0
0	1	0
1	0	0
1	1	1

C-ben a logikai szorzást az && operátor képviseli. Például az a feladat, hogy a katonai űrhajók körébe csak felnőtt férfi állampolgárokat engedjenek be. Vagyis csak az válhat jelentkezővé, akire mindkét feltétel egyszerre igaz.

#beleértve void main() ( char gender; unsigned int age; printf("Írja be a nemet ("M" vagy "F")\n"); scanf("%c", &gender); printf("Adja meg az életkort\n") ; scanf("%u", &age); if (gender == "M" && age > 17) ( printf("Üdvözlöm"); ) else ( printf("Menj el"); ) _getch(); )

Az ÉS operátor egymás után több argumentumra is alkalmazható. Az asszociatív és kommutatív törvények vonatkoznak rá. Javítjuk a programot, növekedést is bevezetünk:

#define _CRT_SECURE_NO_WARNINGS #include #beleértve void main() ( char gender; előjel nélküli int kor \n"); scanf("%u", &age); printf("Adja meg a magasságot\n"); scanf("%u", &height); if (gender == "M" && kor > 17 && magasság > = 180) ( printf("Üdvözlöm"); ) else ( printf("Menj el"); ) _getch(); )

A feltételt is fel lehetne írni

(nem == "M" && életkor > 17) && magasság >= 180

Nem == "M" && (életkor > 17 && magasság >= 180)

(életkor > 17 && magasság >= 180) && nem == "M"

Logikus VAGY

A logikai VAGY operátor (logikai összeadás, VAGY) akkor igaz, ha legalább egy argumentuma igaz.

Logikai VAGY operátor

x	Y	X VAGY Y
0	0	0
0	1	1
1	0	1
1	1	1

C-ben az OR-t a || operátor képviseli. Például javítsuk a programot: most már a nemet kis- és nagybetűvel is be lehet írni

#define _CRT_SECURE_NO_WARNINGS #include #beleértve void main() ( char genderInput; char gender; unsigned int age; unsigned int height; printf("Írja be a nemet ("M" vagy "F")\n"); scanf("%c", &genderInput); printf( "Írja be az életkort\n"); scanf("%u", &age); printf("Adja meg a magasságot\n"); scanf("%u", &height); if (genderInput == "M" || genderInput = = "m") ( gender = 1; ) else ( gender = 0; ) if ((életkor > 17 && magasság >= 180) && nem) ( printf("Üdvözöljük"); ) else ( printf("Menj el" ); ) _getch(); )

Az AND operátorhoz hasonlóan az OR kommutatív és asszociatív.

Az operátorok keverhetők egymással, létrehozva összetett operátorok

#define _CRT_SECURE_NO_WARNINGS #include #beleértve void main() ( char gender; előjel nélküli int kor \n"); scanf("%u", &age); printf("Adja meg a magasságot\n"); scanf("%u", &height); if ((életkor > 17 && magasság >= 180) && (nem == "M" || gender == "m")) ( printf("Üdvözlöm"); ) else ( printf("Menj el"); ) _getch(); )

Csak emlékeznünk kell arra, hogy a tagadó operátornak magasabb a prioritása, mint az ÉS vagy a VAGY, ezért először az kerül végrehajtásra. Ha előfordulhat olyan helyzet, amikor a végrehajtási sorrend nem egyértelmű, zárójelekkel határozza meg.

Példa: De Morgan törvénye. Az ÉS megváltoztatásához VAGY-ra (vagy fordítva) meg kell invertálnia az összes operandus értékét, le kell cserélnie az ÉS-t VAGY-ra (vagy az OR-t AND-ra), és meg kell fordítania a végeredményt. Állapotunk esetében

(életkor > 17 && magasság >= 180) && (nem == "M" || nem == "m")

Először fontolja meg a darabot

(életkor > 17 és magasság >= 180)

Fordítsa meg az összes értéket

(!(életkor > 17) && !(magasság >= 180))

cserélje ki az && operátort ||-re

(!(életkor > 17) || !(magasság >= 180))

és fordítsa meg a választ

!(!(életkor > 17) || !(magasság >= 180))

Amint látja, az eredmény ugyanaz. Ez nyilvánvaló

!(17 évesnél idősebb)

egyenértékű

Kor<= 17

Így megváltoztatjuk a feltételt

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

Ugyanígy változtassa meg a második tartót

(gender == "M" || gender == "m")

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

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

Most ugyanezt a szabályt alkalmazhatjuk a teljes kifejezésre

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

A logikai operátorok végrehajtási sorrendje

Fontolja meg a kifejezést

A && b && c && d

ahol a, b, c, d logikai értékek. Az egész kifejezés akkor és csak akkor igaz, ha minden operandus igaz. Ha legalább az egyik operandus hamis, akkor a többi már nem fontos. Ezért a teljesítmény optimalizálása érdekében a számítás balról jobbra halad, és leáll, amint az első nulla operandus megtalálható.

C-ben egy hozzárendelési operátor visszaadhat egy értéket. Néha közvetlenül olyan állapotban használják:

#define _CRT_SECURE_NO_WARNINGS #include #beleértve #beleértve void main() ( int a = 0; int *p = if (a && (p = (int*) malloc(sizeof(int) * 2))) ( printf("memória lefoglalva"); ) free(p ); _getch(); )

Ebben az esetben a malloc operátor nem kerül végrehajtásra, mert az első a operandus 0 (illetve a teljes kifejezés nulla). Így a szabad operátor megpróbálja törölni a nem tud memóriát (mert p továbbra is a-ra hivatkozik). Ha megváltoztatjuk a = 1-et, akkor minden probléma nélkül fog működni.

Ugyanez történik a || végrehajtásakor. Kifejezés

A || b || c || d

balról jobbra fut, amíg meg nem találja az első nullától eltérő értéket. Ezt követően a végrehajtás leáll, mivel ismert, hogy a teljes kifejezés igaz.

Különféle műveletek hajthatók végre az objektumokon a C nyelven:

• hozzárendelési műveletek;
• kapcsolati műveletek;
• számtan;
• összerakós játékaik;
• műszakos műveletek.

A művelet eredménye egy szám.

A műveletek lehetnek binárisak vagy unárisak.
A bináris műveleteket két objektumon hajtják végre, az unáris műveleteket egyen.

értékadó művelet

A hozzárendelési műveletet a = szimbólum jelöli, és 2 lépésben hajtják végre:

• a jobb oldali kifejezés kiértékelésre kerül;
• az eredményt a bal oldalon lévő operandushoz rendeljük:

tárgy = kifejezés;

Példa:

int a = 4; // az a változóhoz 4-es érték tartozik
intb;
b = a + 2; // a b változóhoz a jobb oldalon számított 6-os érték van hozzárendelve

Ha a hozzárendelési művelet bal és jobb oldalán lévő objektumok különböző típusúak, akkor egy explicit típuskonverziós műveletet használunk.
objektum = (típus)kifejezés;

Példa:

float a = 241,5;
// Az osztás maradékának kiszámítása előtt az a-t egész típussá alakítjuk
int b = (int )a % 2; // b = 1

kapcsolati műveletek

Alapvető kapcsolati műveletek:

• == egyenértékű - egyenlőség ellenőrzése;
• != nem egyenlő - ellenőrizze az egyenlőtlenséget;
• < Kevésbé;
• > több;
• <= kisebb vagy egyenlő;
• >= több vagy egyenlő.

A relációs műveleteket feltételek és ágak szervezésére használják. Ezen műveletek eredménye 1 bit, amelynek értéke 1, ha a művelet eredménye igaz, és 0, ha a művelet eredménye hamis.

Aritmetikai műveletek

Alapvető bináris műveletek, csökkenő prioritási sorrendben:

• * - szorzás;
• / - osztály;
• + - kiegészítés;
• — - kivonás;
• % egy egész osztás maradéka.

Alapvető unáris műveletek:

• ++ - növekvő (növekedés 1-gyel);
• -- - csökkentés (1-gyel csökkenteni);
• — - jelcsere.

A növelési vagy csökkentési műveleteket tartalmazó kifejezés kiértékelésének eredménye attól függ, hogy a művelet előjele hol található (az objektum előtt vagy után). Ha a művelet az objektum előtt található, akkor a változó értéke először 1-re változik, majd ezzel az értékkel hajtjuk végre a következő műveleteket. Ha a művelet ++ vagy — a változó után helyezkedik el, akkor először a műveletet hajtjuk végre, majd a változó értéke 1-re változik.

Példa :

A bináris aritmetikai műveletek kombinálhatók a hozzárendelési operátorral:

• objektum *= kifejezés; // objektum = objektum * kifejezés
• objektum /= kifejezés; // objektum = objektum / kifejezés
• objektum += kifejezés; // objektum = objektum + kifejezés
• objektum -= kifejezés; // objektum = objektum - kifejezés
• objektum %= kifejezés; // objektum = objektum % kifejezés

Boole-műveletek

A logikai műveletek két csoportra oszthatók:

• feltételes;
• bitenként.

A feltételes logikai műveleteket leggyakrabban if állapotellenőrző műveletekben használják, és bármely objektumon végrehajthatók. A feltételes logikai művelet eredménye:

• 1, ha a kifejezés igaz;
• 0, ha a kifejezés hamis.

Általában a feltételes logikai műveletek minden nullától eltérő értéket igaznak értelmeznek.

Alapvető feltételes logikai műveletek:

• && - És (bináris) - a reláció összes műveletének egyidejű végrehajtása szükséges;
• || - VAGY (bináris) - legalább egy relációs művelet szükséges;
• ! - NEM (unáris) - a relációs művelet nem végrehajtása szükséges.

A bitenkénti logikai műveletek biteken működnek, amelyek mindegyike csak két értéket vehet fel: 0 vagy 1.

Alapvető bitenkénti logikai műveletek C nyelven:

• & konjunkció (logikai ÉS) - bináris művelet, amelynek eredménye csak akkor 1, ha mindkét operandus egyetlen (általános esetben, ha minden operandus egyetlen);
• | diszjunkció (logikai VAGY) - bináris művelet, amelynek eredménye 1, ha legalább az egyik operandus 1;
• ~ az inverzió (logikai NEM) egy unáris művelet, amelynek eredménye 0, ha az operandus egyszeres, és egyenlő 1, ha az operandus nulla;
• ^ Az XOR egy bináris művelet, amelynek eredménye 1, ha a két operandus közül csak az egyik 1 (általában, ha az operandusok bemeneti halmazának páratlan száma 1).

Minden bit esetében a művelet eredményét a táblázatnak megfelelően kapjuk meg.

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

Példa :

1
2
3
4
5
6
7

előjel nélküli karakter a = 14; // a = 0000 1110
előjel nélküli karakter b = 9; // b = 0000 1001
előjel nélküli karakter 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

A bitenkénti műveletek lehetővé teszik egy szám egyes bitjeinek beállítását és visszaállítását. Erre a célra azt használják kicsit maszkolás. Az egyes bitek beállításának megfelelő maszkokat egy bájtban a táblázat tartalmazza

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

Egy bizonyos bit beállításához a maszk megfelelő bitjét 1-re kell állítani, és bitenkénti logikai VAGY műveletet kell végrehajtani a maszkot reprezentáló konstanssal.

Utolsó frissítés: 2017.06.19

A műveletek külön halmaza képviseli a feltételes kifejezéseket. Az ilyen műveletek logikai értéket adnak vissza, azaz bool típusú értéket: igaz, ha a kifejezés igaz, és false, ha a kifejezés hamis. Ezek a műveletek összehasonlító műveleteket és logikai műveleteket tartalmaznak.

Összehasonlító műveletek

Az összehasonlító operátorok összehasonlítanak két operandust, és egy bool értéket adnak vissza – igaz, ha a kifejezés igaz, és hamis, ha a kifejezés hamis.

Összehasonlít két operandust az egyenlőségre. Ha egyenlők, akkor a művelet igazat ad vissza, ha nem egyenlő, akkor false értéket ad vissza:

B; // hamis

Összehasonlít két operandust, és igaz értéket ad vissza, ha az operandusok nem egyenlőek, és hamis értéket, ha egyenlők.

int a = 10; int b = 4; bool c = a != b; // igaz bool d = a!=10; // hamis

Kevesebb, mint a művelet. Igaz értéket ad vissza, ha az első operandus kisebb, mint a második, és hamis értéket, ha az első operandus nagyobb, mint a második:

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

Művelet "nagyobb, mint". Összehasonlít két operandust, és igazat ad vissza, ha az első operandus nagyobb, mint a második, egyébként hamis értéket ad vissza:

int a = 10; int b = 4; bool c = a > b; // igaz bool d = a > 25; // hamis

A művelet kisebb vagy egyenlő, mint. Összehasonlít két operandust, és igazat ad vissza, ha az első operandus kisebb vagy egyenlő, mint a második. Ellenkező esetben false értéket ad vissza.

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

Nagyobb vagy egyenlő, mint a művelet. Összehasonlít két operandust, és igazat ad vissza, ha az első operandus nagyobb vagy egyenlő a másodiknál, ellenkező esetben false értéket ad vissza:

int a = 10; int b = 4; bool c = a >= b; // igaz bool d = a >= 25; // hamis

Tevékenységek<, > <=, >= magasabb prioritású, mint az == és a !=.

Boole-műveletek

A C# logikai operátorokat is meghatároz, amelyek szintén bool értéket adnak vissza. Elfogadják a logikai értékeket operandusként. Jellemzően kapcsolatokra alkalmazzák, és több összehasonlítási műveletet kombinál.

A logikai összeadás vagy logikai VAGY művelete. Igaz értéket ad vissza, ha legalább az egyik operandus igazat ad vissza.

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

Logikai szorzás vagy logikai ÉS. Igaz értéket ad vissza, ha mindkét operandus igaz egyszerre.

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

A logikai összeadás művelete. Igaz értéket ad vissza, ha legalább az egyik operandus igazat ad vissza.

bool x1 = (5 > 6) || (négy< 6); // 5 >6 - hamis, 4< 6 - true, поэтому возвращается true bool x2 = (5 >6) || (4 > 6); // 5 > 6 hamis, 4 > 6 hamis, tehát false ad vissza

A logikai szorzás művelete. Igaz értéket ad vissza, ha mindkét operandus igaz.

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

Logikai tagadás művelete. Egyetlen operanduson hajtják végre, és igazat ad vissza, ha az operandus hamis. Ha az operandus igaz, akkor a művelet hamis értéket ad vissza:

bool a = igaz; bool b = !a; // hamis

Exkluzív VAGY működés. Igazat ad vissza, ha az első vagy a második operandus (de nem mindkettő) igaz, ellenkező esetben false értéket ad vissza

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

Itt van két műveletpár | és || (valamint a & és &&) hasonló műveleteket hajtanak végre, de nem egyenértékűek.

A z=x|y kifejezésben; x és y értékek is kiszámításra kerülnek.

A z=x||y kifejezésben; először az x értéket számítjuk ki, és ha ez egyenlő igaz -val, akkor az y érték számításának már nincs értelme, hiszen mindenesetre z egyenlő igaz -val. Az y értéke csak akkor kerül kiértékelésre, ha x hamis

Ugyanez vonatkozik az &/&& műveletpárra is. A z=x kifejezésben mindkét érték - x és y - kiszámításra kerül.

A z=x& kifejezésben először az x értéket számítjuk ki, és ha ez egyenlő hamis -val, akkor az y érték számításának már nincs értelme, hiszen mindenesetre z egyenlő a false -val. Az y értéke csak akkor kerül kiértékelésre, ha x igaz

Ezért a műveletek || és && kényelmesebbek a számításokban, mivel lehetővé teszik a kifejezés értékének kiértékeléséhez szükséges idő csökkentését, és ezáltal a teljesítmény javítását. És műveletek | és a & alkalmasabbak bitenkénti műveletek végrehajtására számokon.

Minden nyelvi kifejezés operandusokból (változókból, konstansokból stb.) áll, amelyeket műveleti jelek kötnek össze. A műveleti jel egy karakter vagy karaktercsoport, amely bizonyos aritmetikai, logikai vagy egyéb műveletek végrehajtására utasítja a fordítót.

A műveleteket szigorú sorrendben hajtják végre. Azt az értéket, amely meghatározza egy adott művelet végrehajtásának elővásárlási jogát, prioritásnak nevezzük. táblázatban. A 2. ábra felsorolja a C nyelv különféle műveleteit (C). A prioritásaik minden csoportnál azonosak (a csoportok színnel vannak kiemelve). Minél több előnyt élvez a megfelelő műveletcsoport, annál magasabban helyezkedik el a táblázatban. A műveletek végrehajtásának sorrendje zárójelekkel szabályozható.

2. táblázat – műveletek

Művelet jele	A művelet célja
	Funkcióhívás
	Egy tömbelem kiválasztása
	Rekordelem kiemelése
	Rekordelem kiemelése
	Logikai tagadás
	Bitenkénti tagadás
	Jelváltás
	Egységnövelés
	Csökkentse eggyel
	Cím felvétele
	Érdeklődni címen
	Típuskonverzió (azaz (lebegő) a)
	A méret meghatározása bájtban
	Szorzás
	Az osztás maradékának meghatározása
	Kiegészítés
	Kivonás
	Váltás balra
	váltson jobbra
	Kevesebb, mint
	Kisebb vagy egyenlő
	Több mint
	Több vagy egyenlő
	Bitenkénti logikai "ÉS"
	Bitenkénti XOR
	Bitenkénti logikai "VAGY"
	Logika "ÉS"
	Logikus "VAGY"
	Feltételes (hármas) működés
	Feladat
+=, - =, *=, /=, %=, <<=, >>=, &=, |=, ^=	Bináris műveletek (például a *= b (azaz a = a * b) stb.)
	Művelet vessző

Operátor C nyelven (C)

A "művelet" és az "operátor" fogalmak közötti zavarok elkerülése érdekében megjegyezzük, hogy az operátor a program legkisebb végrehajtható egysége. Vannak kifejezés-operátorok, amelyek tevékenysége adott kifejezések kiértékelése (például: a = sin(b)+c; j++;), deklarációs operátorok, összetett operátorok, üres operátorok, címke operátorok, ciklus operátorok stb. Pontosvesszővel jelöljük a C (C) utasítás végét. Ami az összetett utasítást (vagy blokkot) illeti, amely logikailag összefüggő utasítások halmaza, amelyek a nyitó (() és a záró ()) kapcsos kapcsos zárójelek („operátori zárójelek”) közé helyezkednek el, azt nem követi pontosvessző. Vegye figyelembe, hogy egy blokk abban különbözik az összetett utasítástól, hogy a blokk törzsében definíciókat tartalmaznak.

A C nyelv alapműveleteinek jellemzői (C)

Jellemezzük az SI (C) nyelv főbb műveleteit.

értékadó művelet

Először is vegye figyelembe az egyiket - a hozzárendelés operátorát (=). A forma kifejezése

x értékét rendeli y-hoz. Az "=" operátor többször is használható egy kifejezésben, például:

x=y=z=100;

Vannak unáris és bináris műveletek. Az elsőnek egy, a másodiknak kettő operandusa van. Kezdjük a vizsgálatot a következő hagyományos csoportok közül az elsőhöz rendelt műveletekkel:

Aritmetikai műveletek.

Logikai és relációs műveletek.

Műveletek bitekkel.

Az aritmetikai műveleteket a következő szimbólumok határozzák meg (2. táblázat): +, -, *, /, % . Ezek közül az utolsó nem alkalmazható valós típusú változókra. Például:

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

Boole-műveletek

Egy reláció logikai műveleteit a következő szimbólumok határozzák meg (lásd 2. táblázat): && (ÉS), || ("VAGY"), ! ("NEM"), >, >=,<, <= , = = (равно), != (не равно). Традиционно эти операции должны давать одно из двух значений: истину или ложь. В языке СИ (C)принято следующее правило: истина - это любое ненулевое значение; ложь - это нулевое значение. Выражения, использующие логические операции и операции отношения, возвращают 0 для ложного значения и 1 для истинного. Ниже приводится таблица истинности для логических операций.

A bitműveletek alkalmazhatók int, char típusú változókra és ezek változataira (például long int). Nem alkalmazhatók float, double, void (vagy bonyolultabb típusok) típusú változókra. Ezeket a műveleteket a következő szimbólumok határozzák meg: ~ (bitenkénti negáció),<< (сдвиг влево), >> (jobbra eltolás), & (bitenkénti ÉS), ^ (bitenkénti XOR), | (bitenkénti "VAGY").

Példák: ha a=0000 1111 és b=1000 1000, akkor

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

A nyelv két nem szokványos növekményes (++) és csökkentő (--) operátort biztosít. Úgy tervezték, hogy eggyel növeljék és csökkentsék az operandus értékét. A ++ és -- operátorok írhatók az operandus elé vagy után. Az első esetben (++n vagy --n) az operandus értéke (n) a megfelelő kifejezésben való felhasználás előtt módosul, a második esetben (n++ vagy n--) pedig felhasználása után. Tekintsük a következő két programsort:

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

Tegyük fel, hogy b = b1 = 2, c = c1 = 4. Majd a műveletek elvégzése után: a = 6, b = 2, c = 5, a1 = 7, b1 = 2, c1 = 5.

Más, nem hagyományos háromtagú vagy feltételes művelettel ?: is széles körben használatosak. A képletben

y = a, ha x nem nulla (azaz igaz), és y = b, ha x nulla (hamis). A következő kifejezés

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

lehetővé teszi egy nagyobb változó értékének (a vagy b) hozzárendelését az y változóhoz, azaz. y = max(a, b).

A nyelv másik különbsége, hogy az a = a + 5 alakú kifejezés; más formában is felírható: a += 5;. A + jel helyett más bináris műveletek szimbólumai is használhatók (lásd 2. táblázat).

Egyéb műveletek a táblázatból. A 2. ábrát a következő bekezdések ismertetik.

A hurkok úgy vannak megszervezve, hogy bizonyos utasításokat vagy utasításcsoportokat bizonyos számú alkalommal hajtsanak végre. A C (C) nyelvben három ciklusutasítás létezik: for, while és do - while. Közülük az első hivatalosan a következőképpen íródott:

for (kifejezés_1; kifejezés_2; kifejezés_3) loop_body

A hurok törzse vagy egy utasítás, vagy több olyan utasítás, amelyekbe bele van zárva kapcsos zárójel( ... ) (a blokk után nincs pontosvessző). Az 1, 2, 3 kifejezések tartalmaznak egy speciális változót, az úgynevezett vezérlőváltozót. Értékével be van állítva a ciklus megismétlésének vagy abból való kilépésének szükségessége.

A_1 kifejezés egy kezdeti értéket rendel a vezérlőváltozóhoz, a_3 kifejezés ezt minden lépésben megváltoztatja, a_2 kifejezés pedig ellenőrzi, hogy elérte-e azt a határértéket, amely beállítja a ciklusból való kilépés szükségességét.

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

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

/* A ciklus a billentyűzetig lesz végrehajtva

"p" karakter nem kerül beírásra */

A három kifejezés bármelyike hurokhoz elhagyható, de a pontosvesszőnek meg kell maradnia. Tehát a for (; ;) (...) egy végtelen ciklus, amelyből csak más módon lehet kilépni.

A következő szabályt az SI (C) nyelven alkalmazzák. A zárójelben lévő hozzárendelési kifejezések értéke megegyezik a hozzárendelt kifejezéssel. Például az (a=7+2) kifejezés értéke 9. Ezután írhat egy másik kifejezést, például: ((a=7+2)<10), которое в данном случае будет всегда давать истинное значение. Следующая конструкция:

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

lehetővé teszi a ch változó értékének megadását, és csak akkor ad igaz eredményt, ha a beírt érték "i" betű. Zárójelben több olyan képlet is írható, amelyek egy összetett kifejezést alkotnak. Erre a célra a vesszőt használjuk. A képletek kiértékelése balról jobbra történik, és a teljes kifejezés az utoljára kiértékelt képlet értékét veszi fel. Például, ha két char típusú változó van, akkor a kifejezés

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

a következő műveleteket határozza meg: az y változó értéke hozzá van rendelve az x változóhoz; egy karaktert írunk be a billentyűzetről, és hozzárendeljük az y változóhoz; z megkapja y értékét. A zárójelekre azért van szükség, mert a vessző operátornak kisebb a prioritása, mint a z változó után írt hozzárendelési operátornak. A vessző operátort széles körben használják cikluskifejezések létrehozására, és lehetővé teszi több vezérlőváltozó értékének párhuzamos megváltoztatását.

A beágyazott építmények megengedettek, pl. a ciklus törzse tartalmazhat más utasításokat is.

A while nyilatkozat formálisan így van írva:

while (kifejezés) loop_body

A zárójeles kifejezés nullától eltérő (igaz) vagy nulla (hamis) értéket vehet fel. Ha igaz, akkor a ciklus törzse végrehajtódik, és a kifejezés újra kiértékelődik. Ha a kifejezés hamis, akkor a while ciklus véget ér.

A do-while nyilatkozat formálisan a következőképpen van írva:

do (loop_body) while (kifejezés);

A fő különbség a while és a do-while ciklus között az, hogy a do-while ciklus törzse legalább egyszer végrehajtásra kerül. A ciklus törzse mindaddig végrehajtásra kerül, amíg a zárójelben lévő kifejezés hamisra nem értékelődik. Ha hamis a ciklusba való belépéskor, akkor a törzse pontosan egyszer kerül végrehajtásra.

Egyes hurkok egymásba ágyazása megengedett, pl. A for, while és do-while utasítások bármelyik ciklus törzsében megjelenhetnek.

Az új szünet és folytatás utasítások használhatók a ciklustörzsben. A break utasítás azonnali kilépést biztosít a ciklusból, a turpināt utasítás a következő iteráció befejezését és a következő iteráció kezdetét okozza.

Feltételes és feltétel nélküli ugrás operátorok

A feltételes és feltétel nélküli ugrások szervezéséhez egy C (C) programban a következő utasításokat használjuk: if - else, switch és goto. Az elsőt a következőképpen írják:

if (ellenőrzési_feltétel) utasítás_1; else utasítás_2;

Ha a zárójelben lévő feltétel igaz, akkor a_1 utasítás, ha hamis, a_2 utasítás kerül végrehajtásra. Ha több utasítást kell végrehajtani egy helyett, akkor azokat kapcsos zárójelek közé kell tenni. Az if utasítás nem tartalmazhatja az else szót.

Az if - else utasításban a többi utasításnak közvetlenül az if és else kulcsszavakat kell követnie. Ha ezek közül legalább az egyik if utasítás, akkor beágyazottnak nevezzük. A C nyelvi konvenció szerint az else szó mindig a legközelebbire vonatkozik, ha az megelőzi.

A switch utasítás lehetővé teszi, hogy válasszon egyet a több alternatíva közül. A következő formális formában van írva:

kapcsoló (kifejezés)

esetállandó_1: utasítások_1;

esetállandó_2: utasítások_2;

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

alapértelmezett: operátorok_alapértelmezett;

Ez kiértékeli a teljes kifejezés értékét zárójelben (ezt néha szelektornak is nevezik), és összehasonlítja az összes konstanssal (konstans kifejezéssel). Minden állandónak különbözőnek kell lennie. Ha van egyezés, akkor a megfelelő utasításváltozat (egy vagy több utasítás) végrehajtásra kerül. Az alapértelmezett kulcsszót tartalmazó változatot a rendszer implementálja, ha a többi közül egyik sem egyezik (lehet, hogy az alapértelmezett szó hiányzik). Ha az alapértelmezett érték hiányzik, és az összes összehasonlítási eredmény negatív, akkor egyik opció sem hajtódik végre.

A későbbi ellenőrzések leállítására valamely opció sikeres kiválasztása után a break utasítást használják, amely azonnali kilépést biztosít a kapcsolókapcsolóból.

A beágyazott kapcsolókonstrukciók megengedettek.

Fontolja meg a feltétel nélküli ugrás végrehajtásának szabályait, amelyek a következő formában ábrázolhatók:

goto címke;

A címke bármely azonosító, amelyet kettőspont követ. A goto utasítás megadja, hogy a program végrehajtásának a címke előtti utasítástól kell folytatódnia. Egy címke elhelyezhető bármely olyan utasítás elé a függvényben, ahol a megfelelő goto utasítás található. Nem kell bejelenteni.

A Turbo debugger teljes mértékben támogatja a C nyelv (C) kifejezés szintaxisát. A kifejezés műveletek, karakterláncok, változók keverékéből áll

Mivel az előző cikkben először logikai műveletet használtam, elmondom, hogy mik ezek, hányan és hogyan kell használni.

A C++-ban három logikai művelet van:

1. A logikai ÉS műveletet && , már ismerjük;
2. Logikai művelet VAGY || ;
3. Logikai művelet NEM ! vagy logikai tagadás.

A logikai műveletek több egyszerű (két vagy több) feltételből összetett (összetett) feltételt alkotnak. Ezek a műveletek többszörösen leegyszerűsítik a programkód szerkezetét. Igen, lehet nélkülük is, de akkor az if-ek száma többszörösére nő, állapottól függően. Az alábbi táblázat röviden jellemzi a C++ programozási nyelv összes logikai műveletét a logikai feltételek felépítéséhez.

Most meg kell értenie a különbséget az ÉS logikai művelet és a VAGY logikai művelet között, hogy a jövőben ne keveredjen össze. Ideje megismerkedni az adattípussal bool-logikus. Ez az adattípus két értéket vehet fel: igaz (igaz) és false (hamis). A select utasításokban ellenőrizendő feltétel a bool adattípus. Tekintsük a következő program elvét, és ezekkel a logikai műveletekkel minden világos lesz.

// or_and_not.cpp: Megadja a konzolalkalmazás belépési pontját. #include "stdafx.h" #include névtér használata std; int main(int argc, char* argv) ( bool a1 = igaz, a2 = hamis; // logikai változók deklarálása bool a3 = igaz, a4 = hamis; 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; }

9. és 10. sorvilágosnak kell lennie, mivel a típusú változók itt inicializálódnak bool . És minden változóhoz hozzá van rendelve egy érték igaz vagy hamis . Kezdve ezzel 9. sorés véget ér 20, amely a logikai műveletek használatát mutatja be. A program eredménye (lásd 1. ábra).

Hamis napló operacii && igaz && hamis: 0 hamis && igaz: 0 igaz && igaz: 1 hamis && hamis: 0 tábla operacikk || igaz || hamis: 1 hamis || igaz: 1 igaz || igaz: 1 hamis || hamis: 0 !true: 0 !false: 1 A folytatáshoz nyomja meg bármelyik gombot. . .

1. ábra - C++ logikai műveletek

Valószínűleg van egy kérdése: „Mik ezek a nullák és egyesek?”. Ha van kérdés, akkor válaszolni kell rá. Azt válaszolom: „A nulla a false (hamis) logikai érték reprezentációja, de az egyesek az igaz (igaz) logikai érték. Hadd magyarázzam el röviden néhány pontot. Összetett feltétel Boolean használatával És csak akkor igaz, ha mindkét egyszerű feltétel igaz. Minden más esetben az összetett feltétel hamis. A logikai VAGY összetett feltétel csak akkor hamis, ha mindkét egyszerű feltétel hamis. Minden más esetben az összetett feltétel igaz. Logikai tagadás NEM egy unáris művelet, és a logikai műveletekkel ellentétben nem kombinál két feltételt Ésés VAGY, amelyek bináris műveletek. A logikai tagadás lehetővé teszi a feltétel jelentésének megfordítását, ami bizonyos esetekben nagyon kényelmes. A logikai tagadással rendelkező feltétel akkor igaz, ha ugyanaz a feltétel tagadás nélkül hamis, és fordítva.