Тагове: C логически оператори, логическо отрицание, логическо НЕ, !, логическо ИЛИ, логическо събиране, ИЛИ, логическо умножение, логическо И, И, ред на изпълнение логически оператори

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

Булевите оператори са оператори, които приемат булеви стойности (false или true) като аргументи и връщат булева стойност. Подобно на обикновените оператори, те могат да бъдат едноместни (унарни, т.е. приемат един аргумент), двуместни (двоични, приемат два аргумента), тройни и т.н.

Характеристика на езика C е, че той няма тип, който съхранява булева стойност (false или true). В C цяло число 0 се счита за невярно (логическа нула) и всяко ненулево цяло число ще бъде логическа истина. Например

#включи #включи void main() ( char boolValue = -71; if (boolValue) ( ​​​​printf("boolValue е true"); ) else ( printf("boolValue е false"); ) _getch(); )

Булевите стойности обикновено се генерират от оператори за сравнение (==, !=, >,<, >=. <=).

Езикът C има три логически оператора: И, ИЛИ и НЕ. Да започнем с най-простото

Логическо отрицание

Операторът NOT се използва за обръщане на стойността на аргумент. Тоест, ако му е дадена истината, той ще върне лъжа, ако е получил лъжа като аргумент, той ще върне истината.

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

х	НЕ X
0	1
1	0

В C отрицанието се представя от оператора !. Например

#включи #включи void main() ( int i = 0; if (i) ( printf("i е вярно\n"); ) if (!i) ( printf("i не е вярно\n"); ) if (!! i) ( printf("i не е невярно\n"); ) if (!!!i) ( printf("i не не е невярно\n"); ) _getch(); )

Както в обикновената логика, тук действа законът за двойното отрицание - отрицанието на отрицанието може да бъде пропуснато.

логично И

Операторът И (И, логическо умножение) връща истина, ако и само ако и двата аргумента са верни.

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

х	Y	X И Y
0	0	0
0	1	0
1	0	0
1	1	1

В C логическото умножение е представено от оператора &&. Например, задачата е само пълнолетни мъже да бъдат допускани в кръга на военните космически кораби. Тоест кандидат може да стане само този, за когото са валидни и двете условия едновременно.

#включи void main() ( char gender; unsigned int age; printf("Въведете пол ("M" или "F")\n"); scanf("%c", &gender); printf("Въведете възраст\n") ; scanf("%u", &age); if (gender == "M" && age > 17) ( printf("Добре дошъл"); ) else ( printf("Тръгни си"); ) _getch(); )

Операторът И може да се прилага последователно към множество аргументи. За него важат асоциативни и комутативни закони. Ще подобрим програмата, ще въведем и растеж:

#define _CRT_SECURE_NO_WARNINGS #include #включи void main() ( char gender; unsigned int age; unsigned int height; printf("Въведете пол ("M" или "F")\n"); scanf("%c", &gender); printf("Въведете възраст \n"); scanf("%u", &възраст); printf("Въведете височина\n"); scanf("%u", &височина); if (пол == "M" && възраст > 17 && височина > = 180) ( printf("Добре дошли"); ) else ( printf("Върви си"); ) _getch(); )

Освен това условието може да бъде написано

(пол == "M" && възраст > 17) && височина >= 180

Пол == "M" && (възраст > 17 && височина >= 180)

(възраст > 17 && височина >= 180) && пол == "M"

Логическо ИЛИ

Логическият оператор ИЛИ (логическо събиране, ИЛИ) е верен, когато поне един от аргументите му е верен.

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

х	Y	X ИЛИ Y
0	0	0
0	1	1
1	0	1
1	1	1

В C ИЛИ е представено от оператора ||. Например, нека подобрим програмата: сега полът може да се въвежда както с главни, така и с малки букви

#define _CRT_SECURE_NO_WARNINGS #include #включи void main() ( char genderInput; char gender; unsigned int age; unsigned int height; printf("Въведете пол ("M" или "F")\n"); scanf("%c", &genderInput); printf( "Въведете възраст\n"); scanf("%u", &възраст); printf("Въведете височина\n"); scanf("%u", &ръст); if (genderInput == "M" || genderInput = = "m") ( пол = 1; ) else ( пол = 0; ) if ((възраст > 17 && височина >= 180) && пол) ( printf("Добре дошъл"); ) else ( printf("Върви си" ); ) _getch(); )

Както при оператора И, ИЛИ е комутативен и асоциативен.

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

#define _CRT_SECURE_NO_WARNINGS #include #включи void main() ( char gender; unsigned int age; unsigned int height; printf("Въведете пол ("M" или "F")\n"); scanf("%c", &gender); printf("Въведете възраст \n"); scanf("%u", &възраст); printf("Въведете височина\n"); scanf("%u", &ръст); if ((възраст > 17 && височина >= 180) && (пол == "M" || пол == "m")) ( printf("Добре дошъл"); ) else ( printf("Върви си"); ) _getch(); )

Трябва само да запомните, че операторът за отрицание има по-висок приоритет от И или ИЛИ, така че той ще бъде изпълнен първи. Ако може да има ситуация, при която редът за изпълнение не е ясен, дефинирайте го със скоби.

Пример: Законът на Де Морган. За да промените И на ИЛИ (или обратно), трябва да обърнете стойностите на всички операнди, да замените И с ИЛИ (или ИЛИ с И) и да обърнете крайния резултат. В случая с нашето състояние

(възраст > 17 && височина >= 180) && (пол == "M" || пол == "m")

Помислете първо за парчето

(възраст > 17 && височина >= 180)

Обърнете всички стойности

(!(възраст > 17) && !(височина >= 180))

заменете оператора && с ||

(!(възраст > 17) || !(ръст >= 180))

и обърнете отговора

!(!(възраст > 17) || !(ръст >= 180))

Както виждате, резултатът е същият. Очевидно е, че

!(възраст > 17)

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

Възраст<= 17

Така променяме условието

!(възраст<= 17 || height < 180)

Променете втората скоба по същия начин

(пол == "М" || пол == "м")

!(пол != "M" && пол != "m")

!(възраст<= 17 || height < 180) && !(gender != "M" && gender != "m")

Сега можем да приложим същото правило за целия израз

!((възраст<= 17 || height < 180) || (gender != "M" && gender != "m"))

Ред на изпълнение на логически оператори

Помислете за израза

A && b && c && d

където a, b, c, d са булеви стойности. Целият израз е верен тогава и само ако всички операнди са верни. Ако поне един от операндите е фалшив, тогава останалите вече не са важни. Следователно, за да се оптимизира производителността, изчислението продължава отляво надясно и спира веднага щом бъде открит първият нулев операнд.

В C операторът за присвояване може да върне стойност. Понякога се използва директно в състояние:

#define _CRT_SECURE_NO_WARNINGS #include #включи #включи void main() ( int a = 0; int *p = if (a && (p = (int*) malloc(sizeof(int) * 2))) ( printf("паметта е разпределена"); ) free(p ); _getch(); )

В този случай операторът malloc няма да бъде изпълнен, тъй като първият операнд a е 0 (съответно целият израз е нула). По този начин операторът free ще се опита да изчисти паметта, която не може да изчисти (защото p ще продължи да препраща към a). Ако променим a = 1, тогава всичко ще работи без проблеми.

Същото се случва при изпълнение на ||. Изразяване

А || b || c || д

върви отляво надясно, докато срещне първата ненулева стойност. След това изпълнението спира, тъй като е известно, че целият израз е равен на true.

Могат да се извършват различни операции върху обекти на езика C:

• операции по присвояване;
• релационни операции;
• аритметика;
• главоблъсканица;
• сменен режим.

Резултатът от операцията е число.

Операциите могат да бъдат двоични или унарни.
Бинарните операции се извършват върху два обекта, а унарните операции - върху един.

операция присвояване

Операцията за присвояване се обозначава със символа = и се извършва на 2 етапа:

• изразът от дясната страна се оценява;
• резултатът се присвоява на операнда от лявата страна:

обект = израз;

Пример:

int a = 4; // на променлива a се присвоява стойност 4
intb;
b = a + 2; // на променлива b се присвоява стойността 6, изчислена от дясната страна

Ако обектите в лявата и дясната част на операцията за присвояване имат различни типове, се използва изрична операция за преобразуване на типа.
обект = (тип) израз;

Пример:

float a = 241.5;
// Преди да се изчисли остатъкът от делението, a се преобразува в тип цяло число
int b = (int )a % 2; // b = 1

релационни операции

Основни релационни операции:

• == еквивалент - проверка за равенство;
• != не е равно - проверка за неравенство;
• < по-малко;
• > Повече ▼;
• <= по-малко или равно;
• >= повече или равно.

Релационните операции се използват за организиране на условия и разклонения. Резултатът от тези операции е 1 бит, чиято стойност е 1, ако резултатът от операцията е истина и 0, ако резултатът от операцията е невярно.

Аритметични операции

Основни двоични операции, подредени в низходящ ред на приоритет:

• * - умножение;
• / - разделяне;
• + - допълнение;
• — - изваждане;
• % е остатъкът от целочислено деление.

Основни унарни операции:

• ++ - нарастване (увеличаване с 1);
• -- - намаляващ (намаляване с 1);
• — - смяна на знака.

Резултатът от изчисляването на израз, съдържащ операции за увеличаване или намаляване, зависи от това къде се намира знакът на операцията (преди или след обекта). Ако операцията се намира преди обекта, стойността на променливата първо се променя на 1 и след това тази стойност се използва за извършване на следните операции. Ако операцията ++ или — се намира след променливата, тогава първо се извършва операцията и след това стойността на променливата се променя на 1.

Пример:

Двоичните аритметични операции могат да се комбинират с оператора за присвояване:

• обект *= израз; // обект = обект * израз
• обект /= израз; // обект = обект / израз
• обект += израз; // обект = обект + израз
• обект -= израз; // обект = обект - израз
• обект %= израз; // обект = обект % израз

Булеви операции

Логическите операции се разделят на две групи:

• условно;
• побитово.

Условните логически операции най-често се използват в операции за проверка на условия if и могат да се изпълняват върху всеки обект. Резултат от условната булева операция:

• 1 ако изразът е верен;
• 0, ако изразът е false.

Като цяло, всички ненулеви стойности се интерпретират от условните булеви операции като истина.

Основни условни логически операции:

• && - И (двоичен) - необходимо е едновременно изпълнение на всички операции на релацията;
• || - ИЛИ (двоичен) - необходима е поне една релационна операция;
• ! - NOT (unary) - изисква се неизпълнение на операцията за релация.

Побитовите логически операции работят с битове, всеки от които може да приема само две стойности: 0 или 1.

Основни побитови логически операции на език C:

• & конюнкция (логическо И) - двоична операция, чийто резултат е 1 само когато и двата операнда са единични (в общия случай, когато всички операнди са единични);
• | дизюнкция (логическо ИЛИ) - двоична операция, резултатът от която е 1, когато поне един от операндите е 1;
• ~ инверсията (логическо НЕ) е унарна операция, резултатът от която е 0, ако операндът е единичен, и е 1, ако операндът е нула;
• ^ XOR е двоична операция, чийто резултат е 1, ако само един от двата операнда е 1 (обикновено, ако входният набор от операнди има нечетен брой 1s).

За всеки бит резултатът от операцията ще бъде получен в съответствие с таблицата.

а	b	а&б	a | b	~а	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

Пример:

1
2
3
4
5
6
7

unsigned char a = 14; // a = 0000 1110
unsigned char b = 9; // b = 0000 1001
неподписан знак 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

Побитовите операции ви позволяват да задавате и нулирате отделни битове от число. За тази цел се използва битово маскиране. Маските, съответстващи на настройката на всеки бит в байт, са представени в таблицата

малко	Маска
0	0x01
1	0x02
2	0x04
3	0x08
4	0x10
5	0x20
6	0x40
7	0x80

За да зададете определен бит, трябва да зададете съответния бит на маската на 1 и да извършите побитова логическа операция ИЛИ с константа, представляваща маската.

Последна актуализация: 19.06.2017

Отделен набор от операции представлява условни изрази. Такива операции връщат булева стойност, тоест стойност от тип bool: true, ако изразът е true, и false, ако изразът е false. Тези операции включват операции за сравнение и логически операции.

Операции за сравнение

Операторите за сравнение сравняват два операнда и връщат bool - true, ако изразът е true, и false, ако изразът е false.

Сравнява два операнда за равенство. Ако те са равни, тогава операцията връща true, ако не са равни, тогава се връща false:

B; // невярно

Сравнява два операнда и връща true, ако операндите не са равни, и false, ако са равни.

int a = 10; int b = 4; bool c = a != b; // вярно bool d = a!=10; // невярно

По-малко от операция. Връща true, ако първият операнд е по-малък от втория, и false, ако първият операнд е по-голям от втория:

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

Операция "по-голямо от". Сравнява два операнда и връща true, ако първият операнд е по-голям от втория, в противен случай връща false:

int a = 10; int b = 4; bool c = a > b; // вярно bool d = a > 25; // невярно

Операция по-малко или равно на. Сравнява два операнда и връща true, ако първият операнд е по-малък или равен на втория. В противен случай връща false.

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

По-голямо или равно на операция. Сравнява два операнда и връща true, ако първият операнд е по-голям или равен на втория, в противен случай връща false:

int a = 10; int b = 4; bool c = a >= b; // вярно bool d = a >= 25; // невярно

Операции<, > <=, >= имат по-висок приоритет от == и !=.

Булеви операции

C# също дефинира логически оператори, които също връщат bool стойност. Те приемат bool стойности като операнди. Обикновено се прилага към релации и комбинира множество операции за сравнение.

Операцията логическо събиране или логическо ИЛИ. Връща истина, ако поне един от операндите върне истина.

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

Булево умножение или логическо И. Връща истина, ако и двата операнда са верни едновременно.

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

Операцията на логическото добавяне. Връща истина, ако поне един от операндите върне истина.

bool x1 = (5 > 6) || (четири< 6); // 5 >6 - невярно, 4< 6 - true, поэтому возвращается true bool x2 = (5 >6) || (4 > 6); // 5 > 6 е false, 4 > 6 е false, така че се връща false

Операция логическо умножение. Връща истина, ако и двата операнда са верни.

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

Операция на логическото отрицание. Изпълнява се върху един операнд и връща true, ако операндът е false. Ако операндът е true, тогава операцията връща false:

bool a = вярно; bool b = !a; // невярно

Изключително ИЛИ операция. Връща true, ако първият или вторият операнд (но не и двата) са true, в противен случай връща false

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

Тук имаме две двойки операции | и || (както и & и &&) изпълняват подобни действия, но не са еквивалентни.

В израза z=x|y; ще бъдат изчислени както x, така и y стойностите.

В израза z=x||y; първо ще бъде изчислена стойността x и ако е равна на true, тогава изчисляването на стойността y вече няма смисъл, тъй като във всеки случай вече имаме z равно на true. Стойността на y ще бъде оценена само ако x е невярно

Същото важи и за двойката операции &/&&. В израза z=x ще бъдат изчислени и двете стойности - x и y.

В израза z=x& първо ще се изчисли стойността на x и ако тя е равна на false, тогава изчисляването на стойността y вече няма смисъл, тъй като във всеки случай вече имаме z равно на false. Стойността на y ще бъде оценена само ако x е вярно

Следователно операциите || и && са по-удобни при изчисления, тъй като позволяват да се намали времето за оценка на стойността на израза и по този начин да се подобри производителността. И операции | и & са по-подходящи за извършване на побитови операции с числа.

Всеки езиков израз се състои от операнди (променливи, константи и т.н.), свързани с операции. Знакът на оператора е знак или група от знаци, които казват на компилатора да извърши определени аритметични, логически или други операции.

Операциите се извършват в строга последователност. Стойността, която определя преимущественото право за извършване на определена операция, се нарича приоритет. В табл. 2 изброява различните операции на езика C (C). Техните приоритети за всяка група са еднакви (групите са маркирани с цвят). Колкото по-голямо е предимството на съответната група операции, толкова по-високо е разположена тя в таблицата. Редът, в който се изпълняват операциите, може да се контролира с помощта на скоби.

Таблица 2 - операции

Операционен знак	Цел на операцията
	Извикване на функция
	Избор на елемент от масив
	Маркиране на елемент на запис
	Маркиране на елемент на запис
	Логическо отрицание
	Побитово отрицание
	Смяна на знака
	Увеличение на единица
	Намалете с единица
	Вземане на адрес
	Контакт по адрес
	Преобразуване на типа (т.е. (float) a)
	Определяне на размера в байтове
	Умножение
	Дефиниция на остатъка от делението
	Допълнение
	Изваждане
	Преместване наляво
	изместване надясно
	По-малко от
	По-малко или равно
	Повече от
	Повече или равно
	Побитово логическо „И“
	Побитово XOR
	Побитово логическо „ИЛИ“
	Логика "И"
	Логическо "ИЛИ"
	Условна (троична) операция
	Възлагане
+=, - =, *=, /=, %=, <<=, >>=, &=, |=, ^=	Двоични операции (например a *= b (т.е. a = a * b) и т.н.)
	Операция запетая

Оператор на език C (C)

За да премахнем объркването в понятията "операция" и "оператор", отбелязваме, че операторът е най-малката изпълнима единица на програмата. Има изразни оператори, чието действие е да оценяват дадени изрази (например: a = sin(b)+c; j++;), декларационни оператори, съставни оператори, празни оператори, етикетни оператори, циклични оператори и др. Точка и запетая се използва за отбелязване на края на израз в C (C). Що се отнася до съставен оператор (или блок), който е набор от логически свързани оператори, поставени между отварящи (() и затварящи ()) фигурни скоби („операторни скоби“), той не е последван от точка и запетая. Имайте предвид, че блокът се различава от съставния оператор по наличието на дефиниции в тялото на блока.

Характеристики на основните операции на езика C (C)

Нека характеризираме основните операции на езика SI (C).

операция присвояване

Първо, разгледайте един от тях - операторът за присвояване (=). Изразяване на формата

присвоява стойността на x на y. Операторът "=" може да се използва няколко пъти в един израз, например:

x=y=z=100;

Има унарни и двоични операции. Първият от тях има един операнд, а вторият има два. Нека започнем тяхното разглеждане с операции, причислени към първата от следните традиционни групи:

Аритметични операции.

Логически и релационни операции.

Операции с битове.

Аритметичните операции се определят със следните символи (Таблица 2): +, -, *, /, % . Последният от тях не може да се приложи към променливи от реален тип. Например:

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

Булеви операции

Логическите операции на релация се определят със следните символи (вижте Таблица 2): && ("И"), || ("ИЛИ"), ! ("НЕ"), >, >=,<, <= , = = (равно), != (не равно). Традиционно эти операции должны давать одно из двух значений: истину или ложь. В языке СИ (C)принято следующее правило: истина - это любое ненулевое значение; ложь - это нулевое значение. Выражения, использующие логические операции и операции отношения, возвращают 0 для ложного значения и 1 для истинного. Ниже приводится таблица истинности для логических операций.

Битовите операции могат да се прилагат към променливи от типове int, char и техните варианти (например long int). Те не могат да се прилагат към променливи от типове float, double, void (или по-сложни типове). Тези операции се определят със следните символи: ~ (побитово отрицание),<< (сдвиг влево), >> (дясно преместване), & (побитово И), ^ (побитово XOR), | (побитово "ИЛИ").

Примери: ако a=0000 1111 и b=1000 1000 тогава

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

Езикът предоставя два нетрадиционни оператора за увеличение (++) и намаляване (--). Те са предназначени да увеличават и намаляват с единица стойността на операнда. Операторите ++ и -- могат да бъдат записани преди или след операнда. В първия случай (++n или --n) стойността на операнда (n) се променя преди да бъде използвана в съответния израз, а във втория случай (n++ или n--) след като бъде използвана. Помислете за следните два реда програма:

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

Да предположим, че b = b1 = 2, c = c1 = 4. Тогава след извършване на операциите: a = 6, b = 2, c = 5, a1 = 7, b1 = 2, c1 = 5.

Изрази с друга нетрадиционна троична или условна операция ?: също се използват широко. Във формулата

y = a, ако x не е нула (т.е. вярно), и y = b, ако x е нула (невярно). Следният израз

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

ви позволява да присвоите стойността на по-голяма променлива (a или b) на променливата y, т.е. y = max(a, b).

Друга разлика на езика е, че израз от формата a = a + 5; може да се запише в друга форма: a += 5;. Вместо знака + могат да се използват и символи на други двоични операции (виж таблица 2).

Други операции от таблицата. 2 ще бъдат описани в следващите параграфи.

Циклите са организирани за изпълнение на даден оператор или група оператори определен брой пъти. В езика C (C) има три оператора за цикъл: for, while и do - while. Първият от тях е формално написан, както следва:

за (израз_1; израз_2; израз_3) тяло_на цикъл

Тялото на цикъла е или един оператор, или няколко оператора, включени в него брекети( ... ) (след блока няма точка и запетая). Изрази 1, 2, 3 съдържат специална променлива, наречена контролна променлива. По неговата стойност се задава необходимостта от повторение на цикъла или излизане от него.

Expression_1 присвоява начална стойност на контролната променлива, expression_3 я променя на всяка стъпка, а expression_2 проверява дали е достигнала граничната стойност, която определя необходимостта от излизане от цикъла.

за (i = 1; i< 10; i++)

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

/* Цикълът ще се изпълнява до клавиатурата

знакът "p" няма да бъде въведен */

Всеки от трите израза в за цикълможе да се пропусне, но точката и запетая трябва да остане. Така че for (; ;) (...) е безкраен цикъл, от който може да се излезе само по други начини.

Следното правило е прието в езика SI (C). Всеки израз за присвояване, ограден в скоби, има същата стойност като този, който се присвоява. Например изразът (a=7+2) има стойност 9. След това можете да напишете друг израз, например: ((a=7+2)<10), которое в данном случае будет всегда давать истинное значение. Следующая конструкция:

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

ви позволява да въведете стойността на променливата ch и да дадете верен резултат само когато въведената стойност е буквата "i". В скоби можете да напишете няколко формули, които съставят сложен израз. За тези цели се използва операция със запетая. Формулите ще бъдат оценени отляво надясно и целият израз ще приеме стойността на последната оценена формула. Например, ако има две променливи от тип char, тогава изразът

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

дефинира следните действия: стойността на променливата y се присвоява на променливата x; знак се въвежда от клавиатурата и се присвоява на променливата y; z получава стойността на y. Скобите са необходими тук, защото операторът със запетая има по-нисък приоритет от оператора за присвояване, написан след променливата z. Операторът запетая се използва широко за конструиране на изрази за цикъл и ви позволява да променяте паралелно стойностите на няколко контролни променливи.

Разрешени са вложени конструкции, т.е. тялото на цикъл може да съдържа други for изявления.

Операторът while е официално написан по следния начин:

докато (израз) loop_body

Изразът в скоби може да приеме различна от нула (истина) или нула (фалшива) стойност. Ако е вярно, тогава тялото на цикъла се изпълнява и изразът се оценява отново. Ако изразът е false, цикълът while приключва.

Изявлението do-while е официално написано, както следва:

do (loop_body) while (израз);

Основната разлика между циклите while и do-while е, че тялото в цикъл do-while се изпълнява поне веднъж. Тялото на цикъла ще бъде изпълнено, докато изразът в скобите не стане фалшив. Ако е false при влизане в цикъла, тогава тялото му се изпълнява точно веднъж.

Разрешено е влагане на едни цикли в други, т.е. операторите for, while и do-while могат да се появят в тялото на всеки цикъл.

Новите оператори break и continue могат да се използват в тялото на цикъла. Операторът break осигурява незабавен изход от цикъла, операторът continue причинява прекратяване на следващата итерация и началото на следващата итерация.

Оператори за условен и безусловен скок

За организиране на условни и безусловни скокове в C (C) програма се използват следните оператори: if - else, switch и goto. Първият е написан по следния начин:

ако (проверка_условие) оператор_1; else statement_2;

Ако условието в скоби е вярно, се изпълнява statement_1; ако е false, се изпълнява statement_2. Ако трябва да се изпълнят няколко оператора вместо един, те се поставят във фигурни скоби. Операторът if може да не съдържа думата else.

В оператор if - else други оператори трябва да следват незабавно ключовите думи if и else. Ако поне един от тях е оператор if, той се нарича вложен. Според конвенцията на езика C, думата else винаги се отнася до най-близкия, ако го предхожда.

Операторът switch ви позволява да изберете една от няколко алтернативи. Изписва се в следната формална форма:

превключвател (израз)

случай константа_1: изрази_1;

случай константа_2: изрази_2;

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

по подразбиране: operators_default;

Това оценява стойността на целия израз в скоби (понякога наричан селектор) и го сравнява с всички константи (константни изрази). Всички константи трябва да са различни. Ако има съвпадение, ще се изпълни съответният вариант на оператор (един или повече оператори). Вариантът с ключовата дума по подразбиране се прилага, ако никой от другите не съвпада (думата по подразбиране може да отсъства). Ако по подразбиране липсва и всички резултати от сравнението са отрицателни, тогава нито една от опциите не се изпълнява.

За спиране на последващи проверки след успешен избор на някоя опция се използва командата break, която осигурява незабавен изход от превключвателя.

Разрешени са вложени конструкции за превключване.

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

goto етикет;

Етикет е всеки идентификатор, последван от двоеточие. Операторът goto указва, че изпълнението на програмата трябва да продължи от оператора, предшестван от етикета. Етикет може да бъде поставен преди всеки оператор във функцията, където се намира съответният оператор goto. Не е необходимо да се обявява.

Turbo debugger напълно поддържа синтаксис на изрази на език C (C). Изразът се състои от смес от операции, низове, променливи

Тъй като в предишната статия за първи път използвах логическа операция, ще ви кажа какви са те, колко от тях и как да ги използвате.

В C++ има три логически операции:

1. Логическата операция И &&, която вече знаем;
2. Логическа операция ИЛИ || ;
3. Логическа операция НЕ ! или логическо отрицание.

Логическите операции образуват сложно (съставно) условие от няколко прости (две или повече) условия. Тези операции опростяват структурата на програмния код няколко пъти. Да, може и без тях, но тогава броят на ако се увеличава няколко пъти, в зависимост от състоянието. Следващата таблица характеризира накратко всички логически операции в езика за програмиране C++ за изграждане на логически условия.

Сега трябва да разберете разликата между логическата операция И и логическата операция ИЛИ, за да не се бъркате в бъдеще. Време е да се запознаем с типа данни bool- логично. Този тип данни може да приема две стойности: вярно (true) и невярно (false). Условието, което трябва да се провери в операторите за избор, има тип данни bool. Помислете за принципа на следната програма и всичко ще стане ясно с всички тези логически операции.

// or_and_not.cpp: Указва входната точка за конзолното приложение. #include "stdafx.h" #include използване на пространство от имена std; int main(int argc, char* argv) ( bool a1 = true, a2 = false; // декларация на булеви променливи bool a3 = true, a4 = false; 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 и 10трябва да сте наясно, тъй като тук се инициализират променливи от типа bool . И на всяка променлива е присвоена стойностистина или лъжа . Започвайки с 9-ти реди край 20-ти, показващи използването на логически операции. Резултатът от програмата (вижте Фигура 1).

Таблица на достоверността на журнала на операциите && вярно && невярно: 0 невярно && вярно: 0 вярно && вярно: 1 невярно && невярно: 0 Таблица на достоверността на журнала на операциите || вярно || невярно: 1 невярно || вярно: 1 вярно || вярно: 1 невярно || невярно: 0 !true: 0 !false: 1 Натиснете произволен клавиш, за да продължите. . .

Фигура 1 - C++ логически операции

Вероятно имате въпрос „Какви са тези нули и единици?“. Ако има въпрос, значи трябва да се отговори. Отговарям: „Нулата е представяне на логическата стойност false (false), но единиците са логическата стойност true (true).“ Нека накратко обясня някои точки. Сложно условие, използващо Boolean Ие вярно само ако и двете прости условия са верни. Във всички останали случаи съставното условие е невярно. Съставно условие, използващо логическо ИЛИ, е невярно само ако и двете прости условия са неверни. Във всички останали случаи съставното условие е вярно. Логическо отрицание НЕе унарна операция и не комбинира две условия, за разлика от логическите операции Ии ИЛИ, които са двоични операции. Логическото отрицание ви позволява да обърнете значението на условието, което е много удобно в някои случаи. Условие с логическо отрицание е вярно, ако същото условие е невярно без отрицание и обратно.