Žymos: L loginiai operatoriai, loginis neigimas, loginis NE, !, loginis ARBA, loginis sudėjimas, ARBA, loginis dauginimas, loginis AND, IR, loginių operatorių vykdymo tvarka

Loginiai operatoriai

Būlio operatoriai yra operatoriai, kurie naudoja logines reikšmes (klaidingas arba teisingas) kaip argumentus ir grąžina loginis. Kaip ir paprasti operatoriai, jie gali būti vienvietės (vienavietės, tai yra, paimkite vieną argumentą), dvivietės (dvejetainės, paimkite du argumentus), trigubos ir pan.

C kalbos ypatybė yra ta, kad ji neturi tipo, kuriame būtų saugoma loginė reikšmė (false arba true). C kalboje sveikasis skaičius 0 laikomas klaidingu (loginiu nuliu), o bet koks sveikasis skaičius, kuris nėra nulis, bus loginė tiesa. Pavyzdžiui

#įtraukti #įtraukti void main() ( char boolValue = -71; if (boolValue) ( ​​printf ("boolValue yra tiesa"); ) else ( printf ("boolValue yra klaidinga"); ) _getch(); )

Būlio reikšmes paprastai generuoja palyginimo operatoriai (==, !=, >,<, >=. <=).

C kalba turi tris loginius operatorius: AND, OR ir NOT. Pradėkime nuo paprasčiausio

Loginis neigimas

Operatorius NOT naudojamas argumento reikšmei apversti. Tai yra, jei jam buvo duota tiesa, tada jis grąžins melą, jei melą gavo kaip argumentą, tada grąžins tiesą.

Loginis operatorius NE

X	NE X
0	1
1	0

C kalboje neigimą vaizduoja operatorius !. Pavyzdžiui

#įtraukti #įtraukti void main() ( int i = 0; if (i) ( printf ("i yra tiesa\n"); ) if (!i) ( printf ("i nėra tiesa\n"); ) if (!! i) ( printf("aš netiesa\n"); ) if (!!!i) ( printf("aš nėra netiesa\n"); ) _getch(); )

Kaip ir įprastoje logikoje, čia veikia dvigubo neigimo dėsnis – neigimo neigimo galima praleisti.

logiška IR

Operatorius IR (IR, loginis dauginimas) grąžina true tada ir tik tada, kai abu argumentai yra teisingi.

Loginis operatorius AND

X	Y	X IR Y
0	0	0
0	1	0
1	0	0
1	1	1

C kalboje loginį dauginimą žymi && operatorius. Pavyzdžiui, užduotis yra ta, kad į karinių kosminių laivų ratą būtų įleidžiami tik suaugusieji vyrai. Tai yra, kandidatu gali tapti tik tas, kuriam vienu metu galioja abi sąlygos.

#įtraukti void main() ( char gender; unsigned int age; printf("Įveskite lytį ("M" arba "F")\n"); scanf("%c", &gender); printf("Įveskite amžių\n") ; scanf("%u", &age); if (lytis == "M" && amžius > 17) ( printf("Sveiki atvykę"); ) else ( printf("Išeik"); ) _getch(); )

Operatorius AND gali būti taikomas nuosekliai keliems argumentams. Jai galioja asociatyviniai ir komutaciniai dėsniai. Tobulinsime programą, taip pat pristatysime augimą:

#define _CRT_SECURE_NO_WARNINGS #įtraukti #įtraukti void main() ( char gender; unsigned int age; besigned int high; printf("Įveskite lytį ("M" arba "F")\n"); scanf("%c", &gender); printf("Įveskite amžių \n"); scanf("%u", &age); printf("Įveskite aukštį\n"); scanf("%u", &height); if (lytis == "M" && amžius > 17 && ūgis > = 180) ( printf("Sveiki atvykę"); ) else ( printf("Išeik"); ) _getch(); )

Taip pat būtų galima parašyti sąlygą

(lytis == „M“ ir amžius > 17) ir ūgis >= 180

Lytis == „M“ ir& (amžius > 17 ir ūgis >= 180)

(amžius > 17 ir ūgis >= 180) && lytis == "M"

Logiška ARBA

Loginis ARBA operatorius (loginis papildymas, ARBA) yra teisingas, kai bent vienas jo argumentas yra teisingas.

Loginis ARBA operatorius

X	Y	X ARBA Y
0	0	0
0	1	1
1	0	1
1	1	1

C kalboje OR žymi || operatorius. Pavyzdžiui, patobulinkime programą: dabar lytį galima įvesti ir didžiosiomis, ir mažosiomis raidėmis

#define _CRT_SECURE_NO_WARNINGS #įtraukti #įtraukti void main() ( char genderInput; char gender; unsigned int age; besigned int high; printf("Įveskite lytį ("M" arba "F")\n"); scanf("%c", &genderInput); printf( "Įveskite amžių\n"); scanf("%u", &age); printf("Įveskite aukštį\n"); scanf("%u", &height); if (genderInput == "M" || genderInput = = "m") ( lytis = 1; ) else ( lytis = 0; ) if ((amžius > 17 && ūgis >= 180) && lytis) ( printf("Sveiki atvykę"); ) else ( printf("Išeiti" ); ) _getch(); )

Kaip ir operatorius AND, OR yra komutacinis ir asociatyvus.

Operatorius galima maišyti tarpusavyje, kurti sudėtingi operatoriai

#define _CRT_SECURE_NO_WARNINGS #įtraukti #įtraukti void main() ( char gender; unsigned int age; besigned int high; printf("Įveskite lytį ("M" arba "F")\n"); scanf("%c", &gender); printf("Įveskite amžių \n"); scanf("%u", &age); printf("Įveskite aukštį\n"); scanf("%u", &height); if ((amžius > 17 && ūgis >= 180) && (lytis == "M" || lytis == "m")) ( printf("Sveiki atvykę"); ) else ( printf("Išeik"); ) _getch(); )

Reikia tik atsiminti, kad neigimo operatorius turi aukštesnę pirmenybę nei AND arba ARBA, todėl jis bus vykdomas pirmiausia. Jei gali būti situacija, kai vykdymo tvarka nėra aiškus, apibrėžkite jį skliaustuose.

Pavyzdys: De Morgano dėsnis. Norėdami pakeisti AND į ARBA (arba atvirkščiai), turite apversti visų operandų reikšmes, pakeisti AND į OR (arba OR su AND) ir apversti galutinį rezultatą. Mūsų būklės atveju

(amžius > 17 ir ūgis >= 180) && (lytis == "M" || lytis == "m")

Pirmiausia apsvarstykite gabalą

(amžius > 17 ir ūgis >= 180)

Apverskite visas vertes

(!(amžius > 17) && !(ūgis >= 180))

pakeiskite operatorių && į ||

(!(amžius > 17) || !(ūgis >= 180))

ir apverskite atsakymą

!(!(amžius > 17) || !(ūgis >= 180))

Kaip matote, rezultatas yra tas pats. Tai akivaizdu

!(amžius > 17)

lygiavertis

Amžius<= 17

Taigi mes keičiame sąlygą

! (amžius<= 17 || height < 180)

Pakeiskite antrąjį laikiklį tokiu pačiu būdu

(lytis == "M" || lytis == "m")

!(lytis != „M“ && lytis != „m“)

! (amžius<= 17 || height < 180) && !(gender != "M" && gender != "m")

Dabar galime taikyti tą pačią taisyklę visai išraiškai

!((amžius<= 17 || height < 180) || (gender != "M" && gender != "m"))

Loginių operatorių vykdymo tvarka

Apsvarstykite išraišką

A && b && c && d

kur a, b, c, d yra loginės reikšmės. Visa išraiška yra teisinga tada ir tik tada, kai visi operandai yra teisingi. Jei bent vienas iš operandų yra klaidingas, likusieji nebėra svarbūs. Todėl, siekiant optimizuoti našumą, skaičiavimas vyksta iš kairės į dešinę ir sustabdomas, kai tik randamas pirmasis nulinis operandas.

C kalboje priskyrimo operatorius gali grąžinti reikšmę. Kartais jis naudojamas tiesiogiai tokiomis sąlygomis:

#define _CRT_SECURE_NO_WARNINGS #įtraukti #įtraukti #įtraukti void main() ( int a = 0; int *p = if (a && (p = (int*) malloc(sizeof(int) * 2))) ( printf("atmintis buvo skirta"); ) free(p ); _getch(); )

Tokiu atveju malloc operatorius nebus vykdomas, nes pirmasis operandas a yra 0 (atitinkamai visa išraiška lygi nuliui). Taigi laisvasis operatorius bandys išvalyti atmintį, kurios negali išvalyti (nes p ir toliau nurodys a). Jei pakeisime a = 1, tada viskas veiks be problemų.

Tas pats nutinka vykdant ||. Išraiška

A || b || c || d

veikia iš kairės į dešinę, kol susidurs su pirmąja ne nuline verte. Po to vykdymas sustoja, nes žinoma, kad visa išraiška yra lygi tiesai.

Su objektais C kalba gali būti atliekamos įvairios operacijos:

• priskyrimo operacijos;
• santykių operacijos;
• aritmetika;
• galvosūkis;
• pamaininės operacijos.

Operacijos rezultatas yra skaičius.

Operacijos gali būti dvejetainės arba vienanarės.
Dvejetainės operacijos atliekamos su dviem objektais, vienarūšės – su vienu.

priskyrimo operacija

Priskyrimo operacija žymima simboliu = ir atliekama 2 etapais:

• įvertinama išraiška dešinėje;
• rezultatas priskiriamas operandui kairėje pusėje:

objektas = išraiška;

Pavyzdys:

int a = 4; // kintamajam a priskiriama 4 reikšmė
intb;
b = a + 2; // kintamajam b priskiriama reikšmė 6, apskaičiuota dešinėje pusėje

Jei kairėje ir dešinėje priskyrimo operacijos dalyse esantys objektai yra skirtingų tipų, naudojama aiški tipo konvertavimo operacija.
objektas = (tipo)raiška;

Pavyzdys:

plūdė a = 241,5;
// Prieš apskaičiuojant likusią dalybos dalį, a paverčiama sveikojo skaičiaus tipu
int b = (int )a % 2; // b = 1

santykių operacijos

Pagrindinės santykių operacijos:

• == lygiavertis – lygybės patikrinimas;
• != nelygus - patikrinkite, ar nėra nelygybės;
• < mažiau;
• > daugiau;
• <= mažesnis arba lygus;
• >= daugiau ar lygus.

Santykinės operacijos naudojamos sąlygoms ir šakoms organizuoti. Šių operacijų rezultatas yra 1 bitas, kurio reikšmė yra 1, jei operacijos rezultatas teisingas ir 0, jei operacijos rezultatas klaidingas.

Aritmetiniai veiksmai

Pagrindinės dvejetainės operacijos, išdėstytos pirmumo mažėjimo tvarka:

• * - daugyba;
• / - padalijimas;
• + - papildymas;
• — - atimtis;
• % yra sveikojo skaičiaus dalinio liekana.

Pagrindinės unarinės operacijos:

• ++ - didėjantis (padidinti 1);
• -- - mažėjimas (sumažinti 1);
• — - ženklo pakeitimas.

Išraiškos, turinčios didinimo arba mažinimo operacijas, įvertinimo rezultatas priklauso nuo to, kur yra operacijos ženklas (prieš objektą ar po jo). Jei operacija yra prieš objektą, tada kintamojo reikšmė pirmiausia pakeičiama į 1, o tada ši reikšmė naudojama toliau nurodytoms operacijoms atlikti. Jei operacija ++ arba — yra po kintamojo, tada pirmiausia atliekama operacija, o tada kintamojo reikšmė pakeičiama į 1.

Pavyzdys :

Dvejetaines aritmetines operacijas galima derinti su priskyrimo operatoriumi:

• objektas *= išraiška; // objektas = objektas * išraiška
• objektas /= išraiška; // objektas = objektas / išraiška
• objektas += išraiška; // objektas = objektas + išraiška
• objektas -= išraiška; // objektas = objektas – išraiška
• objektas %= išraiška; // objektas = objekto % išraiška

Būlio operacijos

Loginės operacijos skirstomos į dvi grupes:

• sąlyginis;
• bitais.

Sąlyginės loginės operacijos dažniausiai naudojamos if būklės tikrinimo operacijose ir gali būti atliekamos su bet kokiu objektu. Sąlyginės loginės operacijos rezultatas:

• 1, jei išraiška teisinga;
• 0, jei išraiška klaidinga.

Apskritai, visos nulinės reikšmės sąlyginės loginės operacijos interpretuojamos kaip teisingos.

Pagrindinės sąlyginės loginės operacijos:

• && - Ir (dvejetainis) - reikia vienu metu atlikti visas ryšio operacijas;
• || - ARBA (dvejetainis) - reikalinga bent viena ryšio operacija;
• ! - NOT (vieninis) - būtinas ryšio operacijos nevykdymas.

Bitinės loginės operacijos veikia su bitais, kurių kiekvienas gali turėti tik dvi reikšmes: 0 arba 1.

Pagrindinės bitinės loginės operacijos C kalba:

• & konjunkcija (loginė IR) - dvejetainė operacija, kurios rezultatas yra 1 tik tada, kai abu operandai yra pavieniai (bendruoju atveju, kai visi operandai yra pavieniai);
• | disjunkcija (loginis ARBA) - dvejetainė operacija, kurios rezultatas yra 1, kai bent vienas iš operandų yra 1;
• ~ inversija (loginė NE) yra vienarė operacija, kurios rezultatas yra 0, jei operandas yra vienas, ir 1, jei operandas yra nulis;
• ^ XOR yra dvejetainė operacija, kurios rezultatas yra 1, jei tik vienas iš dviejų operandų yra 1 (paprastai, jei įvesties operandų rinkinyje yra nelyginis skaičius 1).

Kiekvieno bito operacijos rezultatas bus gautas pagal lentelę.

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

Pavyzdys :

1
2
3
4
5
6
7

nepasirašytas simbolis a = 14; // a = 0000 1110
beženklis simbolis b = 9; // b = 0000 1001
nepasirašytas simbolis 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

Bitų operacijos leidžia nustatyti ir iš naujo nustatyti atskirus skaičiaus bitus. Šiuo tikslu jis naudojamas bitų maskavimas. Lentelėje pateikiamos kaukės, atitinkančios kiekvieno bito nustatymą baite

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

Norėdami nustatyti tam tikrą bitą, turite nustatyti atitinkamą kaukės bitą į 1 ir atlikti bitų loginę ARBA operaciją su konstanta, vaizduojančia kaukę.

Paskutinis atnaujinimas: 2017-06-19

Atskiras operacijų rinkinys reiškia sąlygines išraiškas. Tokios operacijos grąžina loginę reikšmę, ty bool tipo reikšmę: true, jei išraiška teisinga, ir false, jei išraiška klaidinga. Šios operacijos apima palyginimo operacijas ir logines operacijas.

Lyginimo operacijos

Palyginimo operatoriai lygina du operandus ir grąžina loginę reikšmę – tiesa, jei išraiška teisinga, ir false, jei išraiška klaidinga.

Lygina du lygybės operandus. Jei jie yra lygūs, operacija grąžina true , jei ne lygi, tada grąžinama false:

B; // netikras

Palygina du operandus ir grąžina teisingą, jei operandai nėra lygūs, ir false, jei jie yra lygūs.

int a = 10; int b = 4; bool c = a != b; // tikroji bool d = a!=10; // netikras

Mažiau nei operacija. Grąžina tiesa, jei pirmasis operandas yra mažesnis už antrąjį, ir false, jei pirmasis operandas yra didesnis nei antrasis:

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

Operacija „didesnė nei“. Palygina du operandus ir grąžina true, jei pirmasis operandas yra didesnis už antrąjį, kitu atveju grąžina false:

int a = 10; int b = 4; bool c = a > b; // tikroji bool d = a > 25; // netikras

Operacija mažesnė arba lygi. Palygina du operandus ir grąžina true, jei pirmasis operandas yra mažesnis arba lygus antrajam. Kitu atveju grąžina klaidingą.

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

Didesnis arba lygus operacijai. Palygina du operandus ir grąžina teisingą, jei pirmasis operandas yra didesnis arba lygus antrajam, kitu atveju grąžina false:

int a = 10; int b = 4; bool c = a >= b; // tikroji bool d = a >= 25; // netikras

Operacijos<, > <=, >= turi didesnę pirmenybę nei == ir !=.

Būlio operacijos

C# taip pat apibrėžia loginius operatorius, kurie taip pat grąžina bool reikšmę. Jie priima bool vertes kaip operandus. Paprastai taikoma santykiams ir derinamos kelios palyginimo operacijos.

Loginio papildymo arba loginio ARBA operacija. Grąžina tiesa, jei bent vienas iš operandų grąžina teisingą.

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

Būlio daugyba arba loginis AND. Grąžina true, jei abu operandai yra teisingi vienu metu.

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

Loginio papildymo operacija. Grąžina tiesa, jei bent vienas iš operandų grąžina teisingą.

bool x1 = (5 > 6) || (keturi< 6); // 5 >6 – klaidinga, 4< 6 - true, поэтому возвращается true bool x2 = (5 >6) || (4 > 6); // 5 > 6 yra klaidinga, 4 > 6 yra klaidinga, todėl grąžinama false

Loginio daugybos operacija. Grąžina tiesa, jei abu operandai yra teisingi.

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

Loginio neigimo operacija. Atliekama su vienu operandu ir grąžinama tiesa, jei operandas yra klaidingas. Jei operandas teisingas, operacija grąžina false:

bool a = tiesa; bool b = !a; // netikras

Išskirtinė ARBA operacija. Grąžina true, jei pirmasis arba antrasis operandas (bet ne abu) yra teisingi, kitu atveju grąžina false

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

Čia yra dvi poros operacijų | ir || (taip pat & ir &&) atlieka panašius veiksmus, tačiau jie nėra lygiaverčiai.

Išraiškoje z=x|y; bus apskaičiuojamos ir x, ir y reikšmės.

Išraiškoje z=x||y; pirmiausia bus apskaičiuojama x reikšmė, o jei ji lygi true , tada y reikšmės skaičiavimas nebėra prasmės, nes bet kuriuo atveju mes jau turime z lygų true . Y reikšmė bus įvertinta tik tuo atveju, jei x yra klaidinga

Tas pats pasakytina ir apie &/&& operacijų porą. Išraiškoje z=x bus apskaičiuojamos abi reikšmės - x ir y.

Išraiškoje z=x& pirmiausia bus apskaičiuojama x reikšmė, o jei ji lygi false , tada y reikšmės skaičiavimas nebėra prasmingas, nes bet kuriuo atveju jau turime z lygų false . Y reikšmė bus įvertinta tik tuo atveju, jei x yra teisinga

Todėl operacijos || ir && yra patogesni skaičiavimuose, nes leidžia sutrumpinti laiką, kurio reikia išraiškos vertei įvertinti, ir taip pagerinti našumą. Ir operacijos | ir & labiau tinka atlikti bitines operacijas su skaičiais.

Bet kuri kalbos išraiška susideda iš operandų (kintamųjų, konstantų ir kt.), sujungtų operacijos ženklais. Operatoriaus ženklas yra simbolis arba simbolių grupė, kuri nurodo kompiliatoriui atlikti tam tikras aritmetines, logines ar kitas operacijas.

Operacijos atliekamos griežta seka. Reikšmė, kuri lemia pirmumo teisę atlikti tam tikrą operaciją, vadinama prioritetu. Lentelėje. 2 pateikiamos įvairios C kalbos operacijos (C). Jų prioritetai kiekvienai grupei yra vienodi (grupės paryškintos spalva). Kuo daugiau pranašumų turi atitinkama operacijų grupė, tuo aukščiau ji yra lentelėje. Veiksmų atlikimo tvarką galima valdyti naudojant skliaustus.

2 lentelė – operacijos

Operacijos ženklas	Operacijos tikslas
	Funkcijos skambutis
	Masyvo elemento pasirinkimas
	Įrašo elemento paryškinimas
	Įrašo elemento paryškinimas
	Loginis neigimas
	Bitinis neigimas
	Ženklo pakeitimas
	Vieneto padidėjimas
	Sumažinti vienu
	Adreso paėmimas
	Susisiekite adresu
	Tipo konvertavimas (t. y. (plaukimas) a)
	Dydžio baitais nustatymas
	Daugyba
	Likusios padalijimo dalies apibrėžimas
	Papildymas
	Atimtis
	Perkelkite į kairę
	perjungti į dešinę
	Mažiau nei
	Mažiau arba lygus
	Daugiau nei
	Daugiau ar lygu
	Bitiškai loginis "IR"
	Bitinis XOR
	Bitiškai loginis "ARBA"
	Logika "IR"
	Loginis "ARBA"
	Sąlyginis (trejų) veikimas
	Užduotis
+=, - =, *=, /=, %=, <<=, >>=, &=, |=, ^=	Dvejetainės operacijos (pavyzdžiui, a *= b (t. y. a = a * b) ir tt)
	Operacija kablelis

Operatorius C kalba (C)

Kad būtų išvengta painiavos sąvokose „operacija“ ir „operatorius“, pažymime, kad operatorius yra mažiausias vykdomasis programos vienetas. Yra reiškinių operatoriai, kurių veiksmas yra įvertinti duotąsias išraiškas (pavyzdžiui: a = sin(b)+c; j++;), deklaravimo operatoriai, sudėtiniai operatoriai, tušti operatoriai, etiketės operatoriai, ciklo operatoriai ir kt. Kabliataškis naudojamas teiginio pabaigai pažymėti C (C). Po sudėtinio teiginio (arba bloko), kuris yra logiškai susijusių teiginių rinkinys, esantis tarp atidaromų (() ir uždarančių ()) lenktų skliaustų („operatoriaus skliaustų“), po kabliataškio nėra. Atminkite, kad blokas nuo sudėtinio teiginio skiriasi tuo, kad bloko turinyje yra apibrėžimų.

C kalbos pagrindinių operacijų charakteristikos (C)

Apibūdinkime pagrindines SI (C) kalbos operacijas.

priskyrimo operacija

Pirmiausia apsvarstykite vieną iš jų – priskyrimo operatorių (=). Formos išraiška

priskiria x reikšmę y. Operatorius "=" vienoje išraiškoje gali būti naudojamas kelis kartus, pavyzdžiui:

x=y=z=100;

Yra vienanario ir dvejetainio operacijos. Pirmasis iš jų turi vieną operandą, o antrasis - du. Pradėkime nuo operacijų, priskirtų pirmajai iš šių tradicinių grupių:

Aritmetiniai veiksmai.

Loginės ir reliacinės operacijos.

Operacijos su bitais.

Aritmetiniai veiksmai nurodomi šiais simboliais (2 lentelė): +, -, *, /, % . Paskutinis iš jų negali būti taikomas tikrojo tipo kintamiesiems. Pavyzdžiui:

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

Būlio operacijos

Loginės ryšio operacijos nurodomos šiais simboliais (žr. 2 lentelę): && ("IR"), || („ARBA“), ! ("NE"), >, >=,<, <= , = = (равно), != (не равно). Традиционно эти операции должны давать одно из двух значений: истину или ложь. В языке СИ (C)принято следующее правило: истина - это любое ненулевое значение; ложь - это нулевое значение. Выражения, использующие логические операции и операции отношения, возвращают 0 для ложного значения и 1 для истинного. Ниже приводится таблица истинности для логических операций.

Bitų operacijos gali būti taikomos int, char ir jų variantų kintamiesiems (pavyzdžiui, long int). Jie negali būti taikomi plaukiojančių, dvigubų, tuščių (arba sudėtingesnių tipų) kintamiesiems. Šios operacijos nurodomos šiais simboliais: ~ (bitinis neigimas),<< (сдвиг влево), >> (paslinkimas į dešinę), & (bitais IR), ^ (bitais XOR), | (bitais "ARBA").

Pavyzdžiai: jei a = 0000 1111 ir b = 1000 1000, tada

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

Kalba pateikia du netradicinius didinimo (++) ir mažinimo (--) operatorius. Jie skirti padidinti ir sumažinti vienu operando reikšmę. Operatoriai ++ ir -- gali būti parašyti prieš operandą arba po jo. Pirmuoju atveju (++n arba --n) operando reikšmė (n) keičiama prieš jį panaudojant atitinkamoje išraiškoje, o antruoju atveju (n++ arba n--) panaudojus. Apsvarstykite šias dvi programos eilutes:

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

Tarkime, b = b1 = 2, c = c1 = 4. Tada atlikus operacijas: a = 6, b = 2, c = 5, a1 = 7, b1 = 2, c1 = 5.

Taip pat plačiai vartojamos išraiškos su kitu netradiciniu trinariu arba sąlyginiu veiksmu ?:. Formulėje

y = a, jei x nėra nulis (t. y. tiesa), ir y = b, jei x yra nulis (netiesa). Toliau pateikta išraiška

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

leidžia kintamajam y priskirti didesnio kintamojo reikšmę (a arba b), t.y. y = max(a, b).

Kitas kalbos skirtumas yra tas, kad a = a + 5 formos išraiška; galima parašyti ir kita forma: a += 5;. Vietoj + ženklo gali būti naudojami ir kitų dvejetainių operacijų simboliai (žr. 2 lentelę).

Kitos operacijos iš lentelės. 2 bus aprašytas tolesnėse pastraipose.

Ciklos organizuojamos tam, kad tam tikrą sakinį ar teiginių grupę įvykdytų tam tikrą skaičių kartų. C (C) kalboje yra trys ciklo sakiniai: for, while ir do – while. Pirmasis iš jų oficialiai parašytas taip:

for (išraiška_1; išraiška_2; išraiška_3) ciklas_kūnas

Ciklo turinys yra vienas sakinys arba keli teiginiai petnešos( ... ) (po bloko nėra kabliataškio). Išraiškose 1, 2, 3 yra specialus kintamasis, vadinamas kontroliniu kintamuoju. Pagal jo vertę nustatomas poreikis pakartoti ciklą arba išeiti iš jo.

Išraiška_1 priskiria pradinę kontrolinio kintamojo reikšmę, išraiška_3 ją keičia kiekviename žingsnyje, o išraiška_2 patikrina, ar ji pasiekė ribinę reikšmę, kuri nustato poreikį išeiti iš ciklo.

už (i = 1; i< 10; i++)

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

/* Ciklas bus vykdomas iki klaviatūros

simbolis "p" nebus įvestas */

Bet kuri iš trijų išraiškų už kilpą gali būti praleistas, bet kabliataškis turi likti. Taigi for (; ;) (...) yra begalinis ciklas, iš kurio galima išeiti tik kitais būdais.

Ši taisyklė priimta SI (C) kalba. Bet kuri skliausteliuose esanti priskyrimo išraiška turi tokią pačią reikšmę kaip ir priskirtoji. Pavyzdžiui, išraiškos (a=7+2) reikšmė yra 9. Po to galite parašyti kitą išraišką, pavyzdžiui: ((a=7+2)<10), которое в данном случае будет всегда давать истинное значение. Следующая конструкция:

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

leidžia įvesti kintamojo ch reikšmę ir pateikti tikrą rezultatą tik tada, kai įvesta reikšmė yra raidė "i". Skliausteliuose galite parašyti kelias formules, kurios sudaro sudėtingą išraišką. Šiems tikslams naudojama kablelio operacija. Formulės bus vertinamos iš kairės į dešinę, o visa išraiška įgis paskutinės įvertintos formulės reikšmę. Pavyzdžiui, jei yra du char tipo kintamieji, tada išraiška

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

apibrėžia tokius veiksmus: kintamojo y reikšmė priskiriama kintamajam x; iš klaviatūros įvedamas simbolis ir priskiriamas kintamajam y; z gauna y reikšmę. Skliaustai čia reikalingi, nes kablelio operatorius turi mažesnę pirmenybę nei priskyrimo operatorius, parašytas po kintamojo z. Kablelių operatorius plačiai naudojamas konstruojant ciklo išraiškas ir leidžia lygiagrečiai keisti kelių valdymo kintamųjų reikšmes.

Leidžiamos įdėtos konstrukcijos, t.y. ciklo turinyje gali būti kitų teiginių.

Nors pareiškimas oficialiai parašytas taip:

while (išraiška) loop_body

Skliausteliuose esanti išraiška gali turėti ne nulinę (tiesa) arba nulinę (klaidingą) reikšmę. Jei tai tiesa, tada ciklo korpusas vykdomas ir išraiška įvertinama dar kartą. Jei išraiška klaidinga, ciklas while baigiasi.

„Do-while“ pareiškimas oficialiai parašytas taip:

do (loop_body) while (išraiška);

Pagrindinis skirtumas tarp while ir do-while kilpų yra tas, kad elementas do-while kilpoje yra vykdomas bent kartą. Ciklo turinys bus vykdomas tol, kol skliausteliuose esanti išraiška bus įvertinta kaip false. Jei jis klaidingas įeinant į kilpą, tada jo kūnas vykdomas tiksliai vieną kartą.

Vienų kilpų įkišimas į kitas leidžiamas, t.y. teiginiai for, while ir do-while gali būti rodomi bet kurios kilpos turinyje.

Nauji pertraukos ir tęsimo teiginiai gali būti naudojami ciklo turinyje. Pertraukos sakinys suteikia tiesioginį išėjimą iš ciklo, teiginys tęsti baigia kitą iteraciją ir pradeda kitos iteracijos pradžią.

Sąlyginio ir besąlyginio šuolio operatoriai

Norint organizuoti sąlyginius ir besąlyginius šuolius C (C) programoje, naudojami šie teiginiai: if - else, switch ir goto. Pirmasis parašytas taip:

if (patikrinimo_sąlyga) teiginys_1; else teiginys_2;

Jei sąlyga skliausteliuose vertinama kaip tiesa, vykdomas teiginys_1, o jei klaidingas, vykdomas teiginys_2. Jei reikia atlikti kelis sakinius, o ne vieną, jie įterpiami į skliaustus. Jei sakinyje negali būti kito žodžio.

Jei – else teiginyje kiti teiginiai turi iš karto po raktinių žodžių if ir else. Jei bent vienas iš jų yra if teiginys, jis vadinamas įdėtu. Pagal C kalbos susitarimą žodis else visada reiškia artimiausią, jei jis yra prieš jį.

Perjungimo teiginys leidžia pasirinkti vieną iš kelių alternatyvų. Jis parašytas tokia formalia forma:

jungiklis (išraiška)

atvejo konstanta_1: teiginiai_1;

atvejo konstanta_2: teiginiai_2;

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

numatytasis: operatoriai_numatytasis;

Tai įvertina visos išraiškos reikšmę skliausteliuose (kartais vadinama parinkikliu) ir lygina ją su visomis konstantomis (pastoviomis išraiškomis). Visos konstantos turi būti skirtingos. Jei yra atitiktis, bus vykdomas atitinkamas teiginio variantas (vienas ar daugiau teiginių). Variantas su numatytuoju raktiniu žodžiu įdiegiamas, jei neatitiko nė vienas kitas (žodžio numatytasis gali nebūti). Jei numatytosios vertės nėra ir visi palyginimo rezultatai yra neigiami, tada nė viena parinktis nevykdoma.

Norėdami sustabdyti vėlesnius patikrinimus sėkmingai pasirinkus kurią nors parinktį, naudojamas pertraukos sakinys, kuris leidžia nedelsiant išjungti jungiklio jungiklį.

Leidžiamos įdėtos jungiklių konstrukcijos.

Apsvarstykite besąlyginio šuolio atlikimo taisykles, kurios gali būti pavaizduotos tokia forma:

goto etiketė;

Etiketė yra bet koks identifikatorius, po kurio yra dvitaškis. Goto sakinys nurodo, kad programos vykdymas turi būti tęsiamas nuo teiginio, prieš kurį yra etiketė. Etiketė gali būti dedama prieš bet kurį funkcijos sakinį, kuriame randamas atitinkamas goto sakinys. To skelbti nereikia.

„Turbo Debugger“ visiškai palaiko C kalbos (C) išraiškos sintaksę. Išraiška susideda iš operacijų, eilučių, kintamųjų mišinio

Kadangi ankstesniame straipsnyje pirmiausia naudojau loginę operaciją, aš jums pasakysiu, kas tai yra, kiek jų ir kaip juos naudoti.

C++ yra trys loginės operacijos:

1. Loginė IR operacija && , mes jau žinome;
2. Loginis veiksmas ARBA || ;
3. Loginis veiksmas NE ! arba loginis neigimas.

Loginės operacijos sudaro sudėtingą (sudėtinę) sąlygą iš kelių paprastų (dviejų ar daugiau) sąlygų. Šios operacijos kelis kartus supaprastina programos kodo struktūrą. Taip, galima apsieiti ir be jų, bet tada if skaičius padidėja kelis kartus, priklausomai nuo būklės. Šioje lentelėje trumpai apibūdinamos visos loginės operacijos C++ programavimo kalba, kuriant logines sąlygas.

Dabar turėtumėte suprasti skirtumą tarp loginės operacijos IR ir loginės operacijos ARBA, kad ateityje nesusipainiotumėte. Atėjo laikas susipažinti su duomenų tipu bool- logiška. Šis duomenų tipas gali turėti dvi reikšmes: true (true) ir false (false). Sąlyga, kurią reikia patikrinti pasirinktuose sakiniuose, turi duomenų tipą bool . Apsvarstykite šios programos principą ir viskas bus aišku su visomis šiomis loginėmis operacijomis.

// or_and_not.cpp: nurodo konsolės programos įėjimo tašką. #include "stdafx.h" #include naudojant vardų erdvę std; int main(int argc, char* argv) ( bool a1 = tiesa, a2 = klaidinga; // loginių kintamųjų deklaracija bool a3 = tiesa, a4 = klaidinga; 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 ir 10 eilutėsturėtumėte būti aiškūs, nes čia inicijuojami tokio tipo kintamieji bool . Ir kiekvienam kintamajam priskiriama reikšmė tiesa ar melas . Pradedant nuo 9-oji eilutė ir baigiasi 20 d, rodantis loginių operacijų naudojimą. Programos rezultatas (žr. 1 pav.).

Operacinių žurnalų lentelės && tiesa && klaidingas: 0 klaidingas && teisingas: 0 teisingas && teisingas: 1 klaidingas && klaidingas: 0 operacijų žurnalas || tiesa || klaidinga: 1 klaidinga || tiesa: 1 tiesa || tiesa: 1 klaidinga || klaidinga: 0 !true: 0 !false: 1 Norėdami tęsti, paspauskite bet kurį klavišą. . .

1 pav. – C++ loginės operacijos

Tikriausiai jums kyla klausimas: „Kas yra tie nuliai ir vienetai? Jei yra klausimas, tai turi būti atsakyta. Aš atsakau: „Nulis yra loginės reikšmės false (false) atvaizdas, o vienetai yra loginė reikšmė true (true).“ Leiskite trumpai paaiškinti kai kuriuos dalykus. Sudėtinė sąlyga naudojant Būlio reikšmę Ir yra teisinga tik tuo atveju, jei teisingos abi paprastos sąlygos. Visais kitais atvejais sudėtinė sąlyga yra klaidinga. Sudėtinė sąlyga, naudojanti loginį ARBA, yra klaidinga tik tuo atveju, jei abi paprastos sąlygos yra klaidingos. Visais kitais atvejais sudėtinė sąlyga yra teisinga. Loginis neigimas NE yra vienkartinė operacija ir ji nesujungia dviejų sąlygų, skirtingai nei loginės operacijos Ir ir ARBA, kurios yra dvejetainės operacijos. Loginis neigimas leidžia pakeisti sąlygos reikšmę, o tai kai kuriais atvejais yra labai patogu. Sąlyga su loginiu neigimu yra teisinga, jei ta pati sąlyga yra klaidinga be neigimo, ir atvirkščiai.