Теория
Всяко изчисление в C# е израз (expression): комбинация от стойности, променливи и оператори, която се свежда до една стойност. Стойностите, върху които операторът действа, се наричат операнди — в a + b операндите са a и b. Аритметичните оператори са пет: +, -, *, / и % (остатък от деление). Типът на резултата се определя от типовете на операндите, а не от променливата, в която го записвате: int с int дава int, а щом поне единият операнд е double, целият резултат е double. Оттук идва най-известният капан: 7 / 2 е целочислено деление и дава 3, докато 7 / 2.0 дава 3.5. Делението на цяло число на нула спира програмата с DivideByZeroException, а при double резултатът е специалната стойност Infinity (или NaN за 0.0 / 0).
Операторът % връща остатъка от целочисленото деление: 7 % 2 е 1, 17 % 5 е 2, а 10 % 5 е 0 — затова n % 2 == 0 проверява за четност, а n % 10 дава последната цифра. При отрицателни числа трябва да сте нащрек: C# отрязва дробната част към нулата, така че -7 / 2 е -3 (не -4), а знакът на остатъка следва делимото: -7 % 2 е -1, докато 7 % -2 е 1. Двете операции са свързани с равенството (a / b) * b + a % b == a, което важи винаги. Практическо следствие: проверката n % 2 == 1 за нечетност е грешна за отрицателни числа — пишете n % 2 != 0, а при работа с цифри първо вземете Math.Abs(n). Остатък може да се взема и от дробни числа: 7.5 % 2 е 1.5.
Операторите за сравнение ==, !=, <, >, <=, >= сравняват два операнда и винаги връщат bool — true или false: 5 > 3 е true, а 5 == 3 е false. Внимавайте с двойния знак: == сравнява, а единичното = присвоява. Логическите оператори свързват булеви стойности: && (И) е true само ако двете страни са true, || (ИЛИ) — ако поне една е true, а ! (НЕ) обръща стойността. && и || използват съкратено изчисляване (short-circuit): ако лявата страна вече определя резултата, дясната не се изчислява изобщо, затова count != 0 && sum / count > 5 е безопасно и при count == 0. Пълните варианти &, | и ^ (изключващо ИЛИ) изчисляват винаги и двете страни. Още една клопка: дробните числа не се сравняват с ==, защото 0.1 + 0.2 == 0.3 е false заради двоичното представяне — сравнявайте разликата: Math.Abs(a - b) < 0.000001.
Когато в един израз има няколко оператора, редът им се определя от приоритета (precedence): 2 + 3 * 4 е 14, защото умножението се изпълнява преди събирането. Пълният ред отгоре надолу е: първични (x++, извикване на метод), унарни (-x, !x, ++x, преобразуване (double)x), мултипликативни (*, /, %), адитивни (+, -), сравнение (<, >, <=, >=), равенство (==, !=), &&, || и накрая присвояването. При еднакъв приоритет решава асоциативността (associativity): аритметичните и логическите оператори се изчисляват отляво надясно, затова 10 - 4 - 3 е 3, а 7 / 2 * 2.0 е 6, а не 7 — първо се изпълнява целочисленото 7 / 2. Присвояването е отдясно наляво: a = b = 0 първо дава 0 на b, после на a. Скобите имат най-висок приоритет и са безплатни: (2 + 3) * 4 е 20, а изразът за високосна година (year % 4 == 0 && year % 100 != 0) || year % 400 == 0 работи и без скоби, но със скоби се чете веднага.
Операторите ++ и -- увеличават или намаляват променлива с единица, но имат две форми с различен резултат в израз. Постфиксният i++ връща старата стойност и чак след това променя i, а префиксният ++i първо променя и връща новата: при int i = 5; изразът Console.WriteLine(i++) печата 5, а Console.WriteLine(++i) веднага след него — 7. На самостоятелен ред (i++;) двете форми са еднакви, а изрази като a++ + ++a имат точно определен резултат в C#, но никой не трябва да ги разгадава — използвайте по един ++ на ред. Съставните оператори за присвояване +=, -=, *=, /= и %= съкращават записа: score += 5 е същото като score = score + 5, а score /= 4 при int отново е целочислено деление. Компилаторът пази типа: int x = 10; x += 2.5; е грешка, защото double не се побира в int без изрично преобразуване.
Класът Math от пространството System събира математическите функции като статични методи — извикват се направо върху класа, без обект: Math.Sqrt(16). Най-често ще ви трябват Math.Abs(x) (абсолютна стойност), Math.Pow(x, y) (степен), Math.Sqrt(x) (квадратен корен), Math.Min(a, b) и Math.Max(a, b), както и константата Math.PI за окръжности: Math.PI * r * r. Запомнете типовете: Math.Pow и Math.Sqrt връщат винаги double, затова за цяло число пишете (int)Math.Pow(2, 10), а Math.Abs връща типа на аргумента. За премахване на дробната част има три различни метода: Math.Floor закръгля надолу (Math.Floor(-3.7) е -4), Math.Ceiling — нагоре (Math.Ceiling(-3.2) е -3), а Math.Truncate просто отрязва към нулата (Math.Truncate(-3.7) е -3, точно както (int)-3.7). И трите връщат double, макар стойността да е цяла. При положителни числа Floor и Truncate съвпадат — разликата се вижда само при отрицателни.
Math.Round(x) закръгля до най-близкото цяло, а Math.Round(x, 2) — до два знака: Math.Round(3.14159, 2) е 3.14. Изненадата идва точно по средата: по подразбиране .NET използва банково закръгляне (MidpointRounding.ToEven), при което .5 отива към четния съсед — Math.Round(2.5) е 2, а Math.Round(3.5) е 4. За училищното правило „5 и нагоре се закръгля нагоре“ подайте MidpointRounding.AwayFromZero: Math.Round(2.5, MidpointRounding.AwayFromZero) дава 3, а с брой знаци — Math.Round(x, 2, MidpointRounding.AwayFromZero). Форматът {x:F2} при извеждане само показва два знака, без да променя стойността в променливата. Задачите с изрази (включително практиката с аритметични изрази и Math) се решават по една и съща схема: запишете формулата на хартия, оградете със скоби всяка дроб и всеки сбор под корен, решете кои стойности са int и кои double, заменете степените и корените с Math.Pow и Math.Sqrt и накрая проверете програмата с данни, за които знаете отговора — например страни 3, 4, 5 за триъгълник или 212 °F за температура. Ако резултатът е грешен, изведете междинните стойности с Console.WriteLine и ще откриете къде целочисленото деление или липсващата скоба са променили сметката.
Златни правила
Скобите са безплатни, грешките — не
Щом в израза има повече от два оператора или дроб, сложете скоби дори когато приоритетът би свършил работа. (f - 32) * 5 / 9 се чете веднага; f - 32 * 5 / 9 е съвсем друга формула.
`int / int` е винаги `int`
Типът на резултата се решава от операндите, не от променливата отляво. За дробен резултат направете поне единия операнд double още преди делението: (double)sum / count или sum / 2.0.
Остатъкът носи знака на делимото
-7 % 2 е -1, а не 1. Проверявайте нечетност с n % 2 != 0, а цифрите на число вземайте от Math.Abs(n).
Защитното условие стои отляво
&& и || спират, щом резултатът е ясен. Пишете count != 0 && sum / count > 5, никога обратното — иначе делението се изпълнява преди проверката.
`Math.Round` закръгля към четно
При точно .5 резултатът е четният съсед: Math.Round(2.5) е 2. Когато ви трябва училищното правило, подайте MidpointRounding.AwayFromZero.
Бърз справочник
Приоритет на операторите (от най-висок към най-нисък)
| Ниво | Оператори | Асоциативност | Пример |
|---|---|---|---|
| Първични | x++, x--, f(x), a[i], x.y | отляво надясно | Math.Abs(n) % 10 — първо методът |
| Унарни | +x, -x, !x, ++x, --x, (T)x | отдясно наляво | (double)sum / count — първо преобразуването |
| Мултипликативни | *, /, % | отляво надясно | 7 / 2 * 2.0 → 6 |
| Адитивни | +, - | отляво надясно | 10 - 4 - 3 → 3 |
| Сравнение | <, >, <=, >= | отляво надясно | a + 1 < b * 2 — аритметиката е първа |
| Равенство | ==, != | отляво надясно | n % 2 == 0 |
| Условно И | && | отляво надясно | x > 0 && x < 10 |
| Условно ИЛИ | || | отляво надясно | a || b && c → a || (b && c) |
| Присвояване | =, +=, -=, *=, /=, %= | отдясно наляво | a = b = 0 — първо b, после a |
Най-полезните методи на класа Math
| Метод | Какво прави | Пример → резултат | Бележка |
|---|---|---|---|
Math.Abs(x) | Абсолютна стойност | Math.Abs(-7) → 7 | Връща типа на аргумента (int, double...) |
Math.Pow(x, y) | x на степен y | Math.Pow(2, 10) → 1024 | Винаги double; за цяло число: (int)Math.Pow(2, 10) |
Math.Sqrt(x) | Квадратен корен | Math.Sqrt(144) → 12 | Отрицателен аргумент дава NaN |
Math.Round(x), Math.Round(x, n) | Закръгля до цяло / до n знака | Math.Round(3.14159, 2) → 3.14 | При точно .5 закръгля към четно: Math.Round(2.5) → 2 |
Math.Round(x, MidpointRounding.AwayFromZero) | Училищно закръгляне на .5 | Math.Round(2.5, MidpointRounding.AwayFromZero) → 3 | С брой знаци: Math.Round(x, 2, MidpointRounding.AwayFromZero) |
Math.Floor(x) | Най-голямото цяло ≤ x (надолу) | Math.Floor(-3.7) → -4 | Връща double |
Math.Ceiling(x) | Най-малкото цяло ≥ x (нагоре) | Math.Ceiling(3.2) → 4 | Math.Ceiling(-3.2) → -3 |
Math.Truncate(x) | Отрязва дробната част към нулата | Math.Truncate(-3.7) → -3 | Същият резултат като (int)x, но от тип double |
Math.Min(a, b), Math.Max(a, b), Math.PI | По-малкото / по-голямото от две числа; числото π | Math.Max(3, 8) → 8; Math.PI → 3.14159... | За три числа: Math.Max(a, Math.Max(b, c)); Math.Clamp(x, 2, 6) ограничава в интервал |
Код за анализ и пренаписване
Приоритет, целочислено деление и ++ на практика
using System;
namespace OperatorsDemo
{
class Program
{
static void Main(string[] args)
{
// 1. Приоритет и асоциативност
int a = 2 + 3 * 4; // 14 - умножението е първо
int b = (2 + 3) * 4; // 20 - скобите променят реда
int c = 10 - 4 - 3; // 3 - отляво надясно: (10 - 4) - 3
double d = 7 / 2 * 2.0; // 6 - 7 / 2 е 3 (int), после 3 * 2.0
Console.WriteLine($"a={a}, b={b}, c={c}, d={d}");
// 2. Целочислено деление и остатък с отрицателни числа
Console.WriteLine($"7 / 2 = {7 / 2}, 7 % 2 = {7 % 2}"); // 3, 1
Console.WriteLine($"-7 / 2 = {-7 / 2}, -7 % 2 = {-7 % 2}"); // -3, -1
Console.WriteLine($"7 / -2 = {7 / -2}, 7 % -2 = {7 % -2}"); // -3, 1
Console.WriteLine($"7.5 % 2 = {7.5 % 2}"); // 1.5
// 3. Цифри на число
int n = -457;
int abs = Math.Abs(n);
int ones = abs % 10; // 7
int tens = abs / 10 % 10; // 5
int hundreds = abs / 100; // 4
Console.WriteLine($"Цифри на {n}: {hundreds} {tens} {ones}, сбор {hundreds + tens + ones}");
// 4. Инкремент: префиксен срещу постфиксен
int i = 5;
Console.WriteLine(i++); // 5 - връща старата стойност, после увеличава
Console.WriteLine(i); // 6
Console.WriteLine(++i); // 7 - първо увеличава, после връща новата стойност
// 5. Съставни оператори за присвояване
int score = 10;
score += 5; // 15
score *= 2; // 30
score -= 4; // 26
score /= 4; // 6 - целочислено!
score %= 4; // 2
Console.WriteLine($"score = {score}");
}
}
}Какво се случва тук?
-
a = 2 + 3 * 4дава14, защото*има по-висок приоритет от+; вbскобите го променят и резултатът е20. -
10 - 4 - 3е3: при еднакъв приоритет изчислението върви отляво надясно, т.е.(10 - 4) - 3, а не10 - (4 - 3). -
7 / 2 * 2.0изненадва с6:/и*са на едно ниво, затова първо се изпълнява целочисленото7 / 2, което дава3, и чак после3 * 2.0. Ако искахме7, трябваше7 * 2.0 / 2или7 / 2.0 * 2. - Отрицателните числа показват правилото: резултатът от
/се отрязва към нулата (-7 / 2е-3), а знакът на%е знакът на делимото (-7 % 2е-1, но7 % -2е1).%работи и сdouble:7.5 % 2е1.5. - За цифрите на
nпърво взимамеMath.Abs(n), иначе-457 % 10би дало-7. Изразътabs / 10 % 10се чете отляво надясно:457 / 10е45, после45 % 10е5— десетиците. -
Console.WriteLine(i++)печата5, защото постфиксната форма връща старата стойност и чак после увеличава; следващият ред показва вече6, а++iувеличава преди да върне и печата7. - Съставните оператори променят променливата на място:
score /= 4при26дава6, защото и тук делението е целочислено, аscore %= 4оставя остатъка2.
Класът Math в действие: геометрия и закръгляне
using System;
namespace MathDemo
{
class Program
{
static void Main(string[] args)
{
// 1. Разстояние между две точки и триъгълник по три върха
double x1 = 0, y1 = 0, x2 = 4, y2 = 0, x3 = 0, y3 = 3;
double a = Math.Sqrt(Math.Pow(x2 - x1, 2) + Math.Pow(y2 - y1, 2)); // 4
double b = Math.Sqrt(Math.Pow(x3 - x2, 2) + Math.Pow(y3 - y2, 2)); // 5
double c = Math.Sqrt(Math.Pow(x1 - x3, 2) + Math.Pow(y1 - y3, 2)); // 3
double p = (a + b + c) / 2; // 6
double area = Math.Sqrt(p * (p - a) * (p - b) * (p - c)); // 6 (формула на Херон)
Console.WriteLine($"Страни: {a}, {b}, {c}; лице: {area}");
// 2. Окръжност и степени
double r = 2.5;
double circleArea = Math.PI * r * r;
double circumference = 2 * Math.PI * r;
Console.WriteLine($"Лице на кръга: {circleArea:F2}, обиколка: {circumference:F2}"); // 19.63, 15.71
int kilobyte = (int)Math.Pow(2, 10); // Pow връща double, затова (int)
Console.WriteLine($"2 на степен 10 = {kilobyte}");
// 3. Floor, Ceiling, Truncate и Round с отрицателно число
double v = -3.7;
Console.WriteLine($"Floor: {Math.Floor(v)}, Ceiling: {Math.Ceiling(v)}, Truncate: {Math.Truncate(v)}, Round: {Math.Round(v)}");
// Floor: -4, Ceiling: -3, Truncate: -3, Round: -4
// 4. Банково закръгляне срещу училищно
Console.WriteLine($"Round(2.5) = {Math.Round(2.5)}, Round(3.5) = {Math.Round(3.5)}"); // 2, 4
Console.WriteLine($"AwayFromZero: {Math.Round(2.5, MidpointRounding.AwayFromZero)}"); // 3
Console.WriteLine($"Round(3.14159, 2) = {Math.Round(3.14159, 2)}"); // 3.14
// 5. Min, Max, Abs и ограничаване в интервал
int grade = 7;
int clamped = Math.Max(2, Math.Min(grade, 6)); // 6 - оценката остава в [2, 6]
int diff = Math.Abs(3 - 8); // 5
Console.WriteLine($"Ограничена оценка: {clamped}, разлика: {diff}, Clamp: {Math.Clamp(-1, 2, 6)}");
}
}
}Какво се случва тук?
- Разстоянието между две точки е корен от сбора на квадратите на разликите:
Math.Sqrt(Math.Pow(x2 - x1, 2) + Math.Pow(y2 - y1, 2)). Скобите околоx2 - x1са задължителни —Math.Powполучава вече изчислената разлика. Трите върха (0,0), (4,0) и (0,3) дават страни4,5и3. - Формулата на Херон
Math.Sqrt(p * (p - a) * (p - b) * (p - c))изисква скоби около всяка разлика; с полупериметърp = 6изразът под корена е6 * 2 * 1 * 3 = 36и лицето е6. -
Math.PI * r * rе лицето на кръг, а{circleArea:F2}показва резултата с два знака, без да променя стойността.Math.Pow(2, 10)връщаdouble1024, затова има изрично преобразуване(int), за да го запишем вint. - За
-3.7трите метода дават различни отговори:Math.Floorотива надолу към-4,Math.Ceilingнагоре към-3, аMath.Truncateотрязва дробната част и също дава-3.Math.Round(-3.7)е-4, защото числото не е точно по средата — банковото правило изобщо не се намесва. -
Math.Round(2.5)дава2, аMath.Round(3.5)—4: по подразбиране.5се закръгля към четния съсед. СMidpointRounding.AwayFromZeroполучаваме училищното3, аMath.Round(3.14159, 2)закръгля до два знака —3.14. -
Math.Max(2, Math.Min(grade, 6))ограничава стойността в интервала [2, 6]: вътрешниятMinреже отгоре, външниятMax— отдолу. Същото прави готовиятMath.Clamp(x, 2, 6), аMath.Abs(3 - 8)дава разстоянието5между две числа независимо от реда им.
Внимавай! Чести грешки
Грешките, които почти всеки прави в тази тема — виж разликата между грешния и правилния код.
Средна стойност с целочислено деление
Грешно
int sum = 17;
int count = 3;
double average = sum / count;
Console.WriteLine(average); // 5, а не 5.666...Правилно
int sum = 17;
int count = 3;
double average = (double)sum / count;
Console.WriteLine(average); // 5.666666666666667Типът на променливата отляво не влияе на деленето: sum / count вече е int със стойност 5, преди да стигне до average. Преобразувайте единия операнд в double преди деленето; (double)(sum / count) не помага, защото отрязването вече е станало.
Формула без скоби и дроб от цели числа
Грешно
double f = 212;
double celsius = 5 / 9 * (f - 32);
Console.WriteLine(celsius); // 0 - защото 5 / 9 е 0Правилно
double f = 212;
double celsius = (f - 32) * 5 / 9;
Console.WriteLine(celsius); // 1005 / 9 са две цели числа и дават 0, а всичко, умножено по нула, е нула. В правилния вариант (f - 32) е double, затова и умножението, и делението след него са дробни; същото постига и 5.0 / 9 * (f - 32).
Проверка за нечетно число с `== 1`
Грешно
int n = -3;
bool isOdd = n % 2 == 1;
Console.WriteLine(isOdd); // False, а -3 е нечетно!Правилно
int n = -3;
bool isOdd = n % 2 != 0;
Console.WriteLine(isOdd); // True-3 % 2 е -1, не 1 — знакът на остатъка следва делимото. Проверката != 0 работи и за положителни, и за отрицателни числа.
Закръгляне на `.5` с `Math.Round`
Грешно
double price = 2.5;
double rounded = Math.Round(price);
Console.WriteLine(rounded); // 2 - очаквахме 3Правилно
double price = 2.5;
double rounded = Math.Round(price, MidpointRounding.AwayFromZero);
Console.WriteLine(rounded); // 3По подразбиране Math.Round закръгля към четно (MidpointRounding.ToEven): 0.5 → 0, 1.5 → 2, 2.5 → 2, 3.5 → 4. За училищното правило подайте MidpointRounding.AwayFromZero, при брой знаци — Math.Round(x, 2, MidpointRounding.AwayFromZero).
Задачи за самостоятелна работа
Опитай първо сам — подсказката е там само ако наистина закъсаш.
Секунди в часове, минути и секунди
Прочетете от конзолата цяло число — брой секунди (например 3725). Изведете го като часове, минути и секунди във формат 1:02:05. Минутите и секундите винаги са с две цифри. Използвайте само / и %, без if.
Проверки без if
Прочетете цяло число year (година) и цяло число n. Без да използвате if, изведете четири реда с True или False: дали year е високосна (дели се на 4, но не на 100, освен ако се дели на 400); дали n е нечетно (трябва да работи и за отрицателни числа); дали n е трицифрено (по абсолютна стойност между 100 и 999); дали n завършва на 0 или 5. Проверете с 2024, 1900, 2000 и с n = -125.
Сметка за поръчка
Прочетете единична цена (double), брой (int) и процент отстъпка (int). Изчислете и изведете с два знака след десетичния знак: сумата преди отстъпка; приложената отстъпка в проценти, която не може да надвишава 50 (Math.Min) и не може да е отрицателна (Math.Max); сумата след отстъпката; крайната сума с 20% ДДС, закръглена до стотинка по училищното правило (MidpointRounding.AwayFromZero). Накрая изведете колко кашона по 12 броя са нужни, за да се опаковат всички бройки (Math.Ceiling). Проверете с цена 19.99, брой 7 и отстъпка 60: крайната сума трябва да е 83.96, а кашоните — 1.
Мини-тест за проверка
Отговори си наум (или на глас!) и чак тогава разкрий отговора.
1. Какво извежда кодът `int i = 5; Console.WriteLine(i++); Console.WriteLine(++i);`?
2. Какво дават `-7 / 2` и `-7 % 2` в C# и защо?
3. Защо `count != 0 && sum / count > 5` не гърми при `count == 0`, а същият израз с `&` вместо `&&` хвърля `DivideByZeroException`?
4. `Math.Round(2.5)` връща `2`, а `Math.Round(3.5)` — `4`. Грешка ли е това и как да получим `3` от `2.5`?
Речник на термините
Виж пълния речник на курса+, %, &&), а операндите са стойностите, върху които той действа. В a % b операторът е %, операндите са a и b.Math.Sqrt(a * a + b * b).&&, а && — преди ||.10 - 4 - 3 е 3), присвояването — отдясно наляво (a = b = 0).7 / 2 е 3, -7 / 2 е -3.7 % 3 е 1, -7 % 3 е -1.++ и --, които променят променлива с единица. Префиксната форма (++i) връща новата стойност, постфиксната (i++) — старата.&& и ||, при което дясната страна не се изчислява, ако лявата вече определя резултата. Позволява защитни проверки като x != 0 && 10 / x > 1.Math.Round: стойност точно по средата (.5) се закръгля към четния съсед — 2.5 става 2, 3.5 става 4. Задава се с MidpointRounding.ToEven; алтернативата е MidpointRounding.AwayFromZero.Провери знанията
Бърз тест с избор от отговори върху термините на модула — с точки и моментална обратна връзка.
Провери знанията си
9 въпроса върху термините от модула. Показваме определение — ти избираш правилния термин.
Материали от часовете
Задачи и тестове, давани в клас по тази тема.
Препоръки за този модул
- Преди да напишете формула в кода, препишете я на хартия с всички скоби и отбележете до всяка променлива дали е
intилиdouble. Деленето на две цели числа маркирайте веднага — точно там ще ви трябва2.0или(double). - Проверявайте програмата с данни, за които знаете отговора наизуст: страни 3, 4, 5 за триъгълник, 100 °C = 212 °F, 3600 секунди = 1 час. Ако отговорът е грешен, печатайте междинните стойности ред по ред, вместо да се взирате в крайната формула.
- Дръжте таблицата с приоритета на операторите подръка, но пишете код, който не я изисква: по един
++на ред, скоби около всяка смесена група от&&и||, междинни променливи с ясни имена вместо един израз на три реда. - Ако изходът показва
3,5вместо3.5, Windows е с български регионални настройки — тогава иdouble.Parseочаква запетая при въвеждане. Това не е грешка в кода; за красив изход използвайте формат{x:F2}, а за закръгляне на самата стойност —Math.Round.