C# изборна дисциплина

Целите константи с тип по подразбиране могат да бъдат присвоени на променливи от тип byte/sbyte/short/ushort, ако тяхната стойност е в допустимите стойности на съответния тип. Цяла константа int, uint винаги може да бъде присвоена на long. Hexadecimal започват с 0x (oxFF = 255). В C# няма осмични константи (в C++ има), тъй като те се използват рядко. Символната константа е единичен символ заграден в апострофи. Може да е и буква от Кирилицата. За някой често се използват неграфични символи, а за служебните символи се ползват следните еднобуквени означения:

\a – system beep

\b – символа “backspace”

\f – за минаване на нова страница

\n – нов ред

\r – минаване в началото на същия ред

\t – хоризонтална табулация

\v – вертикална табулация

\0 – нулев байт

\’ – символа „’”

\” – символа „””

\{ и \} – съответно „”{ и „}”

\\ - символа „\”

Константа от тип низ от символи е последователност от символи заградена в кавички. Такива константи се използват често в метода WriteLine, т.е. могат да съдържат управляващи символи, които при извеждане се изпълняват. Допълнително в C# може да се започва с „@”, след което следва низ в кавички. Съдържимото на низовата константа се използва без модификация и може да включва два или повече реда, следователно в този случай могат да се използва управляващи символи за нов ред, табулация и т.н. без да се използват еднобуквените escape означения, но ако трябва да се изведат кавички се задават 2 кавички една до друга.

Console.WriteLine(@“Това е копираща низова константа

която включва

няколко реда”);

Ще се изведе на нов ред. Копиращите низови константи се извеждат в програмата така както са били въведени.

тип списък_от_имена_на_променливи;

„Тип” е произволен тип, включително тези типове, разгледани до сега. Типът определя колко бита се разпределят за стойността на променливата и как се представя тази стойност в C#. Всяка променлива трябва да се дефинира преди да се използва. Това е необходимо тъй като компилатора трябва да знае типа на променливата при компилация на израз, който я използва. Преди да се използва променлива на нея трябва да и се присвои стойност. Това става по два начина:

• 
  с отделна операция след дефинирането и;
  
• 
  при дефиницията и.
  

Стойността на израза която се присвоява на променливата трябва да е съвместима с типа и.

Пример:

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

double volume = 3.1416*radius*radius*height;

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

Както казахме, блокът е последователност от дефиниции и оператори затворени в {}. Той задава областта на видимост като определя възможността за достъп до променлива и нейния живот. Областта на видимост се задава с блока. Променливите могат да се дефинират на произволно място. В блока променливата се създава при дефинирането й и се унищожава в края на блока. Областта на видимост може да се влага – при всяко създаване на блок се създава вложена област като външната област е видима за вътрешната, но обекти от вътрешната не са видими за външната.

Най-важни области на видимост са определени от тези на класа и методите. Тялото на метода е блок. Параметрите на блока имат област на видимост блока – тя е защитена от достъп от извън блока – това е едно от правилата, осигуряващи инкапсулация.

Пример:

class ScopeDemo

{

public static void Main()

int x; //известна в метода Main()

x = 10;

if (x == 10)

int y = 20;

x = y * 2; //y е видима само вътре

}

y = 100; //грешка

}

}

Пример:

class VarIniDemo

{

public static void Main()

int x;

{

int y = -1; //y се инициализира всеки път при влизане в блока

y = 100;

}

//y=100 се губи при всеки край на интерпретацията в цикъла

}

В C# името на променлива, дефинирана във вътрешна област на видимост, не може да съвпада с името на променлива, дефинирана във външната област на видимост. В C/ C++ няма такова ограничение.

– - бинарно изваждане и унарен –;

–– - намаляване с единица.

Ако операндите при / са от цял тип, то делението е целочислено. В C# при операцията % операндите могат да са както от цял, така и от float тип.

Операциите ++ и – – могат да се записват както преди операнда, така и след него като постфикс.

++x и x++ са еквивалентни на x=x+1

– –x и x– – са еквивалентни на x=x – 1

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

int x, y;

x = 10;

Но ако операцията е след операнда, то C# променя с единица стойността на операнда след като тази променлива е използвана в останалата част на израза.

y=x++; //y=x; x=X+1;

В C# се използват следни операции за сравнение:

Резултатът от изпълнението на операциите за сравнение и на логическите операции е стойност от тип bool.

В C# операциите == и != могат да се прилагат с всички обекти. Операциите за сравнение могат да се прилагат към типове, чиито стойности са наредени, следователно те могат да се прилагат към всички числови типове данни, но те не могат да се прилагат към стойности от булев тип false и true, тъй като те в C# не са наредени (в C/ C++ false

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

Ако при изпълнение на операцията && първият операнд има стойност false, то резултатът ще е false независимо от стойността на втория операнд. При || ако първия операнд има стойност true, то резултатът ще е true независимо от втория операнд. Съществува разлика между & и | и && и ||. Тя се изразява в това, че при обикновените операции винаги се оценяват и първия и втория операнд. При бързите втория се оценява само при необходимост. В общия случай използването на && и || води до по-бързо изпълнение на програмата.

Ще разгледаме пример при който използването на && води до предотвратяване на деление на 0.

int n,d;

…

If(d!=0 && (n%d)==0)

Console.WriteLine(d+” е делител на ”+n);

}

//Понякога в операциите and и or винаги трябва да се оцени втория операнд”

…

If(p & ++i<100)

Console.WriteLine(“i=”+i);

}

Операцията за присвояване:

Типът на променливата трябва да е съвместим с типа на израза.

int x, y, z;

x = y = z = 34 + 66;

В C#, както и в C/C++, се използват съставни операции за присвояване с общ вид:

променлива операция=израз;

Те са съвместими с операциите +, –, *, /, %, &, |, ^.

Съставните операции имат две преимущества: те се записват по-кратко и се компилират по-бързо. Ако типовете на операндите при операция = са различни, то типа на израза от дясно се преобразува автоматично към типа на променливата отляво при условие че са изпълнение следните изисквания:

1. 
   двата типа са съвместими;
   
2. 
   допустимата стойност на типа от ляво обхваща допустимата стойност на типа от дясно (преобразуването е разширяващо).
   

long L;

D=L;//автоматично преобразуване от long в double

L=D;//не може автоматично (преобразуването не е разширяващо)

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

(тип)израз; – при изпълнение типа на израза се преобразува към „тип”

double x, y;

byte b;

int i;

x=10.0;

i=x/y; //грешка

i=(int)(x/y); //свиващо преобразуване към цяло число – реже се дробната част

b=(byte)i;

ch=(char)b; //между ch и b няма съвместимост

Израз в C# е синтактично и семантично допустима комбинация от константи, променливи, операции, обръщения към функции и методи и кръгли скоби. Съществува възможност в един израз да се използват две или повече различни типове данни, ако те са съвместими. Например в един израз могат да се използват данни от тип short и от тип long, тъй като са числени и съвместими. Различните типове се преобразуват към един и същи тип в съответствие с правилата за автоматично преобразуване на типовете в израз.

Ще разгледаме алгоритъма за преобразуване определен от аритметичните операции:

1. 
   Ако единия операнд е от тип decimal, то другия също се преобразува с изключение на long или double. Тогава възниква грешка.
   
2. 
   Ако единия операнд е double, то другия се преобразува към тип double.
   
3. 
   Ако единия операнд има тип float, то и другия се преобразува към float.
   
4. 
   Unsigned long – другия се преобразува към ulong, освен когато е short, long, signed byte или int. В такъв случай дава грешка.
   
5. 
   Long – другия се преобразува към long.
   
6. 
   Unsigned int, а другия signed byte, short, int – и двата стават long.
   
7. 
   Unsigned int – другия се преобразува към unsigned int.
   
8. 
   Ако от правилата от 1 до 7 не са приложими и двата стават int.
   

byte b; int i;

b=10;

i=b*b;

char ch1=’a’, ch2=’b’;

ch1=(char)(ch1+ch2);

…

int broi, suma;

….

sr_uspeh = (double)(suma/broi);

Програма за пресмятане на сумите за ежемесечно изплащане по взет кредит

using System;

class RegPay

{

public static void Main()

decimal Principal, IntRate, PayPerYear, NumYears, Payment;

decimal numer, denom;

double b, e; //b->oснова e->степенен показател в Pow()

Principal=10000.00m; //размер на кредита

IntRate=0.075m; //7.5% лихва

PayPerYear=12m; // изплащания на годинa

NumYears=5m; //срок за погасяване на кредита в години

numer=IntRate*(Principal/PayPerYear);

e=(double)-(PayPerYear*NumYears);

b=(double)(IntRate/PayPerYear) + 1;

denom=1-(decimal)Math.Pow(b, e);

Payment=numer/denom;

Console.WriteLine(“Сума за ежемесечно изплащане: {0:C}”, Payment);

}

}

В тази програма се извършват финансови пресмятания. Затова се използва тип decimal. Също така се демонстрира използването на операцията за явно преобразуване на типа и метода Pow от библиотеката на С#. Този метод реализира операцията повдигане в степен като и двата аргумента трябва да са от тип double и връщания резултат е от тип double.

който изчаква въвеждането на символ от клавиатурата и след това връща резултат. Резултатът е от цял тип, затова той трябва да се преобразува явно в тип char. По подразбиране, реда, въведен от клавиатурата, се записва в буфер след натискане на enter. Например:

char ch;

ch=(char)Console.Read();

Console.WriteLine(“Въведеният символ е:” + ch);

Символът enter също се въвежда в буфера.

Условният оператор if има следния общ вид:

if (израз) оператор1 [оператор2] //оператор2 може да го няма

Изразът „израз” трябва да има булева стойност. Оператор 1 и оператор 2 могат да бъдат съставен оператор или блок. Те могат да бъдат и друг условен оператор, при което се получава влагане на условни оператори if. При това влагане е възможно не еднозначно тълкуване, което се отстранява от следното правило: текста на вложените оператори if се превежда отляво надясно като всяко срещнато else се съчетава в един оператор с най-близкото преди него несъчетано if след оператора или блока, на който if е разположен else. Пример:

if (i == 10)

{

if (j < 20)

if (k > 100)

c = d;

else

}

else

Препоръчва се влагането на if да става след else. Пример:

if (e1)

S1;

S2;

else if (en)

Sn;

else

Изразите се оценяват от горе надолу. При намиране на първия израз със стойност true, се изпълнява асоциирания с него оператор, а останалата част се пропуска. Ако нито един от изразите не приема стойност true, то се изпълнява Sn+1. Ако той отсъства и всички изрази имат стойност „неистина”, то вложеният if не изпълнява никакви действия, т.е. той е еквивалентен на празния оператор. Пример:

int x;

double y;

if (x==1)

y=5*y+6;

else if (x==2)

y=y*y+2*y-1;

else if (x==3)

y=Math.Pow(y, 5);

else

Принципите на работа на вложения if и на оператора за избор на вариант switch се различават, затова в много случаи, използването на switch е по-ефективно. switch съществено се различава от същия в С++. Общ вид на switch

switch (израз_селектор)

{

case израз1 : оператори

case израз2 : оператори

break;

………………

break;

break;

Изразът селектор трябва да е от цял тип – char, byte, short или int или от тип string, който ще разгледаме по-нататък. Изразът селектор не може да бъде с плаваща точка. Много често той е променлива. израз1, израз2, …, изразn са константни изрази и имат тип, съвместим с типа на израза селектор. Тези изрази в един блок трябва да имат различно стойности. При изпълнение на оператор switch, стойността на израза селектор последователно се сравнява със стойностите на константните изрази от списъка. При съвпадение се изпълняват операторите, асоциирани със съответния константен израз. Операторите след default се изпълняват тогава, когато няма съвпадения на израза селектор с нито един от константните изрази. Вариантът default не е задължителен. Ако той отсъства, тогава switch е еквивалентен на празния оператор. Операторът break е задължителен ( !!! ) и изпълнението му предава управлението на оператора след switch. В С# е забранено предаването на управлението между отделните варианти, т.е. алтернативи. Това позволява по-ефективна работа на компилатора и на съставената от него програма. В С/С++ и Java един вариант може да предава управлението на друг вариант.

В С#, както в С/С++ две и повече алтернативи могат да бъдат свързани с една и съща последователност от операции. Например:

switch(i)

{

case 1:

case 3:

break;

оператори

break;

}

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

bool done;

…

if (x<10)

else if (y!=0)

…

else if (!done)

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

for (израз1; израз2; израз3)

Оператор

Обикновено израз1 инициализира управляващата променлива на цикъла, израз3 задава стъпката, с която се изменя управляващата променлива при всяко изпълнение на тялото на цикъла. Условието за продължаване на цикъла се проверява преди изпълнението на тялото на цикъла. Затова тялото на цикъла може да не се изпълни нито веднъж. Да съставим програма, която пресмята корен квадратен на числата от 1 до 99 и направената грешка при това пресмятане.

using System;
class SqrRoot

{

static void Main()

double num, sroot, rerr;

for (num = 0; num < 100; num++)

{

sroot = Math.Sqrt(num);

rerr = num - sroot * sroot;

Console.WriteLine("Грешката е равна на" + rerr);

Console.WriteLine();

}

}

}

Операторът за цикъл for може да съдържа няколко управляващи променливи. Например:

for (int i=0, j=10; i

оператор

for (;;) //безкраен цикъл

оператор

Тялото на цикъла може да бъде празния оператор. Например – пресмятане сумата на числата от 1 до 5:

for (int i=0; i<=5; suma+=i++);

Много често управляващата променлива се използва само в рамките на оператора за цикъл. Тогава е удобно тя да бъде дефинирана при нейната инициализация в израз1. Например:

int fact=1, n;

…

for (int i=1; i

fact*i;

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

Операторът за цикъл while има следния общ вид:

while (израз)

Условието за продължаване на цикъла се проверява преди изпълнението на тялото на цикъла.Следователно тялото на цикъла може да не се изпълни нито веднъж.

char ch;

while(ch<=’z’)

{

Console.Write(ch+ “ “);

}

using System;

{

public static void Main()

int e;

for (int i = 0; i < 10; i++)

{

result = 1;

while (e > 0)

{

result *= 2;

}

Console.WriteLine("2 на {0} степен = {1}", i, result);

}

}

Operator

„Израз” е булев. Операторът се изпълнява по следния начин:

Тук условието се проверява след като е изпълнено тялото на цикъла. Следователно, то се изпълнява поне веднъж. Пример за продължаване на цикъла докато не бъде въведен символ ‘q’:

char ch;

do

{

ch = (char)Console.Read();

}

while (ch != 'q');

char ch;

{

Console.WriteLine("Въведете символ: ");

}

while (ch != '\n' || ch!=’\r’);

using System;

{

public static void Main()

for (int i = 2; i <= 100; i++)

{

Console.Write("Делители на {0} са : ", i);

{

if (i % j == 0)

Console.Write("{0} ,", j);

}
}

Console.WriteLine();

}

}

}