Условна конструкция (програмиране)

от Уикипедия, свободната енциклопедия
Направо към: навигация, търсене

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

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

Булеви изрази, оператори за сравнение и логически оператори[редактиране | edit source]

Булеви изрази[редактиране | edit source]

Множеството от стойности на булевия тип (bool в C/C++/C#, boolean в Java) се състои от два елемента — стойностите true и false. Тези стойности се наричат още булеви константи.

Булев израз в информатиката наричаме, всеки израз, който след своето преобразувание, може да се сведе до булева константа.

Оператори за сравнение[редактиране | edit source]

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

Оператор Действие
== равно
 != различно
> по-голямо
< по-малко
>= по-голямо или равно
<= по-малко или равно

Примери:

Тип на данните Логически израз Резултат
(int) Целочислен 5 == (7 - 2) true
(int) Целочислен 5 != (2 + 2) true
(int) Целочислен 5 > (2 + 3) false
(int) Целочислен 5 >= (2 + 3) true
(double) С плаваща запетая 5.0 > Math.PI true
(double) С плаваща запетая 5.5 == (11 / 2) false *
(string) Символен низ "Alpha" == "Alpha" true **
  • Резултатът на 5.5 == (11 / 2) е false, тъй като от дясната страна на оператора за сравнение стои израз, чиято стойност се разглежда като резултат от целочислено делене. В този смисъл, стойността му след деленето ще бъде целочислената стойност 5, като остатъкът 0.5 няма да се отрази. Тоест сравнението на стойностите 5.5 и 5.0 (След неявно преобразуване на типа от (int) в (double)) ще бъде false.
  • Сравнението на различни обекти от тип символен низ (string), проверява и сравнява съдържанието на обектите, за разлика от използването на операторите '==' и '!=' за други референтни типове, където тези оператори проверяват референциите към обектите, тоест дали двете променливи, които сравняваме сочат към един и същи обект. Ако желаем да извършим това действие за типа string, се налага изрично да преобразуваме типа на object - ((object)stringOne == (object)stringTwo), което вече ще провери, дали 2-те променливи сочат към един и същи обект. При символните низове и другите референтни типове, не можем да използваме операторите '>', '<', '>=', '<='. В езика C#, за сравнение на символни низове по лексикографската им подредба, съществуват специални методи на класа System.String

Логически оператори[редактиране | edit source]

Логическите оператори приемат булеви стойности и връщат булев резултат.

Логически оператор Стилизиран запис Наименование
&& AND И
|| OR ИЛИ
 ! NOT Логическо отрицание
^ XOR Изключващо ИЛИ
x y  !x x && y x || y x ^ y
true true false true true false
true false false false true true
false true true false true true
false false true false false false

Видове условни конструкции[редактиране | edit source]

В езиците от семейството на C разграничаваме следните видове условни конструкции:

if / else / else if / вложени if конструкции[редактиране | edit source]

Една програма може да се държи различно, в зависимост от някакво условие посредством условните конструкции if и if-else. Те представляват тип условен контрол, който се проверява по време на изпълнение на конструкцията.

if[редактиране | edit source]

Форматът на условната конструкция if е следният: if-клауза, булев израз и тяло на условната конструкция.

if (булев израз)
{
      тяло на условната конструкция;
}

Булевите изрази могат да бъдат променливи от булев тип или булев логически израз. В C# те не могат да бъдат цяло число за разлика от други езици за програмиране като C и C++.

Тялото на конструкцията е заключена между големите къдрави скоби "{}" и може да се състои от един или няколко операции (statements).

Ако изразът в скобите след ключовата дума if бъде изчислен до стойност true, се изпълнява тялото на условната конструкция. Ако резултатът от изчислението на булевия израз е false, то операторите в тялото няма да бъдат изпълнени.

Пример за използване на условната конструкция if:

static void Main()
{
      Console.WriteLine("Enter two numbers.");
      Console.Write("Enter first number: ");
      int firstNumber = int.Parse(Console.ReadLine());
      Console.Write("Enter second number: ");
      int secondNumber = int.Parse(Console.ReadLine());
      int biggerNumber = firstNumber;
      if (secondNumber > firstNumber)
      {
            biggerNumber = secondNumber;
      }
      Console.WriteLine("The bigger number is: {0}", biggerNumber);
}

След като въведем числата 4 и 5, ще получим следния резултат:

Enter two numbers.
Enter first number: 4
Enter second number: 5
The bigger number is: 5

else[редактиране | edit source]

Съществува и условна конструкция с else клауза (if-else). Форматът и включва: запазена дума if, булев израз, тяло на условната конструкция, запазена дума else и тяло на else-конструкцията, което може да се състои от един или няколко оператора:

if (булев израз)
{
      тяло на условната конструкция;
}
else
{
      тяло на else-конструкция;
}

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

Пример за използване на условната конструкция if-else:

static void Main()
{
      int x = 2;
      if (x > 3)
      {
            Console.WriteLine("x е по-голямо от 3");
      }
      else
      {
            Console.WriteLine("x не е по-голямо от 3");
      }
}

Резултатът от примера е:

x не е по-голямо от 3

Понеже е x=2, ще бъде изпълнен операторът от else-конструкцията: "x не е по-голямо от 3".

else if[редактиране | edit source]

Освен if и else, които общо могат да опишат 2 случая, можем да имаме и else if конструкции, които проверяват няколко условия. Задължително е else if конструкциите да се използват след if конструкция, като след else if, може да има една единствена else конструкция, която обаче е незадължителна.

if (x == 0)
{
    Console.WriteLine("The number is 0");
}
else if (x == 1)
{
    Console.WriteLine("The number is 1");
}
else if (x == 2)
{
    Console.WriteLine("The number is 2");
}
else
{
    Console.WriteLine("Another number");
}

Както вече знаем, if проверява някакво условие, ако това условие е изпълнено, преминаваме в изпълнение на кода в тази if конструкцията и игнорираме кода на всички останали else if и незадължителната else конструкция. Ако условието в if не е изпълнено, проверяваме условията на всеки else if по реда, в който са записани. При намиране на съвпадение се изпълнява съответния код, а останалите се игнорират. Ако съществува else конструкция и не сме имали съвпадение в if или else if, то тогава се изпълнява кода в else конструкцията, която обхваща всички случаи, които не са разгледани от предходните конструкции.

Вложени if конструкции[редактиране | edit source]

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

Пример за употреба на вложени if конструкции:

int first = 5;
int second = 3;
if (first == second)
{
      Console.WriteLine("These two numbers are equal.");
}
else
{
      if (first > second)
      {
            Console.WriteLine("The first number is greater.");
      }
      else
      {
            Console.WriteLine("The second number is greater.");
      }
}

Тук двете числа се сравняват на две стъпки: първо дали са равни и ако не са, се сравняват отново, за да се установи кое от числата е по-голямо.

Ето го и резултатът:

The first number is greater.

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

switch-case[редактиране | edit source]

Условната конструкция switch (множествено разклонение в някои езици за програмиране) се използва за избор измежду списък с възможности. Конструкцията сравнява дадена стойност с определени константи и въз основа на съвпадението с някоя от тях, предприема дадено действие.

switch (селектор)
{
          case стойност-1: код за изпълнение; break;
          case стойност-2: код за изпълнение; break;
          case стойност-3: код за изпълнение; break;
          case стойност-4: код за изпълнение; break;
          // …
          default: код за изпълнение; break;
}

Конструкцията switch-case избира измежду части от програмен код на базата на изчислената стойност на определен израз. Този израз най-често е целочислен, но може да бъде и от тип string или char. Стой­ността на селектора трябва задължително да бъде изчис­лена преди да се сравнява със стойностите вътре в switch конструк­цията. Етикетите (case) не трябва да имат една и съща стойност. При намиране на съвпадение на селектора с някоя от case стойностите, switch-case конструкцията изпълнява кода след съответния case. При липса на съвпадение, се изпълнява default конструкцията, когато такава съществува. Всеки case етикет, както и етикетът по подразбиране (default), трябва да завършват с ключовата дума break, която приключва работата на switch-case конструкцията, след като е намерено съвпадение и е изпълнен съответния код.


В C Sharp имаме възможността да използваме множество етикети, когато те трябва да изпълняват един и същи код. При този начин на записване, когато намерим съвпадение, тъй като след съответния case етикет липсва код за изпълнение и break оператор, ще се изпълни следващия срещнат код. Ако такъв липсва ще се изпълни default конструкцията.

int number = 6;
switch (number)
{
      case 1:
      case 4:
      case 6:
      case 8:
      case 10:
            Console.WriteLine("Числото не е просто!"); break;
      case 2:
      case 3:
      case 5:
      case 7:
            Console.WriteLine("Числото е просто!"); break;
      default:
            Console.WriteLine("Не знам какво е това число!"); break;
}

Добри практики при използването на switch-case

  • Добра практика е винаги да се използва default конструкция, която да се поставя в края, след останалите case етикети, която да обработва нетипичните стойности, които селектора може да приеме или дори ситуации, които могат да бъдат считани за грешни.
  • Добре е на първо място да поставяме онези case случаи, които обработват най-често случилите се ситуации, а case конструкциите, обработващи по-рядко възникващи ситуации да оставим в края.
  • Ако стойностите в case етикетите са целочислени, е препоръчително да се подреждат по големина в нарастващ ред.
  • Ако стойностите в case етикетите са от символен тип, е препоръ­чително case етикетите да бъдат подреждани по азбучен ред.

Тернарен оператор ? :[редактиране | edit source]

Условният оператор ? : е оператор в езика C и C-подобните езици. Извествен е още като тернарен оператор, тъй като е единствения оператор, който приема 3 операнда.

операнд1 ? операнд2 : операнд3

Първия операнд или условието на условната конструкция може да бъде булева променлива или булев израз и може да приема двете булеви стойности true (истина) и false (лъжа). Ако след извършването на необходимите преобразувания, операнд1 се сведе до истинно твърдение (true), то тогава след изпълнението си тернарния оператор ще върне стойността на операнд2, в противен случай (false), върнатата стойност ще бъде стойността на операнд3.

int a = 5;
int b = 3;
int larger = (a > b) ? a : b;

В горния пример, инициализираме 2 целочислени променливи а и b и им задаваме стойности съответно 5 и 3. На променливата larger присвояваме резултата от тернарния оператор. В случая това е 5, тъй като условието (a > b) е изпълнено (true), върнатата стойност ще бъде тази на операнда преди двете точки, тоест променливата a, която е 5. Този пример показва как по лесен начин можем да определим кое от две числа е по-голямо, без използването на if-else конструкцията. Същия пример, реализиран чрез if-else би изглеждал по следния начин:

int a = 5;
int b = 3;
int larger;
if (a > b)
   larger = a;
else
   larger = b;

Вижте също[редактиране | edit source]

Източници[редактиране | edit source]