MARIUS TOMESCU

CARMEN FIFOR

Programarea calculatoarelor Introducere n C#

Editura Universitii Aurel Vlaicu Arad - 2010 -

PrefaC# este un limbaj de programare de nivel nalt, orientat obiect, care face parte din tehnologia software .Net, i reprezint un pas important n evoluia limbajelor de programare. Multe firme recurg la limbajul C# n procesele de implementare i dezvoltare software deoarece ofer un foarte bun suport pentru tehnologiile de vrf. Cursul de fa cuprinde att noiunile de baz ale limbajului C#, ct i unele elemente de nivel mediu i avansat. Cursul poate fi un instrument util pentru nsuirea i consolidarea cunotinelor pentru oricine dorete s neleag i s fie iniiat ntr-un limbaj de programare. Primele ase capitole cuprind noiuni de baz ale limbajului C#: tipuri de date i instruciuni elementare, care au rolul de a iniia studentul n limbajul de programare C# aducndu-l la un nivel mediu, noiuni introductive despre clase i folosirea fiierelor. Ultimul capitol (PROBLEME REZOLVATE) are un rol important n pregtire. n acest capitol sunt prezentate i explicate n detaliu programe de nivel mediu spre complex, cu scopul de a clarifica noiunile fundamentale de programare C#, explicaii menite a forma o gndire algoritmic riguroas. Sperm ca textul acestui curs s ofere o introducere plcut n programarea calculatoarelor i limbajul C#. Am ncercat s prezentm fiecare noiune ntr-o manier accesibil i interesant. Scopul acestui curs este de a va nva noiunile de baz ale programrii n C# i de realiza trecerea studentului de la un cunosctor al limbajului C# la un programator C#. Cursul se adreseaz n primul rnd studenilor din anul I, celor care studiaz un curs elementar sau academic de algoritmi, structuri de date i limbaje de programare. Octombrie 2010 Autorii

CUPRINS

CAPITOLUL I. INTRODUCERE N LIMBAJUL C#...................71.1 Conceptele de baz ale limbajului C#............................................................7 1.2 Structura unui program C#.............................................................................7 1.3 Metodele unui clase........................................................................................9 1.4 Comentarii....................................................................................................10 1.5 Declaraii......................................................................................................11 1.6 Blocuri de instruciuni..................................................................................11 1.7 Identificatori.................................................................................................11 1.8 Cuvinte cheie................................................................................................12 1.9 Tipuri de date ...............................................................................................13 1.10 Variabile.....................................................................................................14

CAPITOLUL II. EXPRESII I OPERATORI..............................172.1 Expresii.........................................................................................................17 2.2 Operatori aritmetici......................................................................................17 2.3 Operatori de atribuire...................................................................................17 2.4 Operatori relaionali.....................................................................................20 2.5 Operatori logici. Operatori logici la nivel de bii.........................................20 2.6 Operatorul condiional ?:..............................................................................21

CAPITOLUL III. INSTRUCIUNI................................................233.2 Instruciunea switch......................................................................................23 3.3 Instruciunea for...........................................................................................24 3.4 Instruciunea do-while..................................................................................25 3.5 Instruciunea while.......................................................................................26 3.6 Instruciunea foreach....................................................................................26 3.8 Instruciunea continue..................................................................................30 3.9 Instruciunea goto ........................................................................................30 3.10 Instruciunea return.....................................................................................32

CAPITOLUL IV. TIPURI DEFINITE DE UTILIZATOR..........334.1 Tipul enumerare...........................................................................................33 4.2 Tipul tablou .................................................................................................34 4.3 Conversii numerice.......................................................................................36

CAPITOLUL V. CLASE NOIUNI DE BAZ.........................395.1 Clasele. Noiuni de baz...............................................................................39 5.2 Cmpuri .......................................................................................................40 5.3 Metode .........................................................................................................41 5.4 Crearea variabilelor i instanelor unei clase................................................53 5.5 Membrii unei instane...................................................................................54 5.6 Modificatori de acces ..................................................................................54 5.7 Accesul privat sau public.............................................................................55

CAPITOLUL VI. PROBLEME REZOLVATE.............................596.1 ALGORITMI ELEMENTARI.....................................................................59 6.2 VECTORI.....................................................................................................90 6.3 MATRICI...................................................................................................113

BIBLIOGRAFIE.............................................................................125

CAPITOLUL I. INTRODUCERE N LIMBAJUL C#

1.1 Conceptele de baz ale limbajului C#Fiecare nou limbaj de programare este influenat ntr-o anumit msur de limbaje de programare deja existente. C# deriv direct din dou dintre cele mai de succes limbaje de programare pe plan mondial i anume C (inventat de ctre Dennis Ritchie n anii 70, rulnd iniial pe sistemul de operare Unix) i C++ (inventat de ctre Bjarne Stroustrup n 1979 pe baza limbajului C, noutatea fundamental fiind introducerea programrii orientate spre obiecte). De asemenea, se nrudete cu un alt limbaj mai nou i deopotriv de succes i anume limbajul Java (dezvoltat de ctre firma Sun Microsystems ncepnd cu anul 1991, avnd o sintax i o filozofie derivate din C+ +, contribuia fundamental fiind portabilitatea programelor, necesar odat cu dezvoltarea diverselor sisteme de operare i a Internetului). Chiar dac Java a rezolvat cu succes multe din problemele legate de portabilitate n Internet, C# a venit s rezolve una din facilitile care i lipseau i anume interoperabilitatea limbajelor de programare diferite, denumit i programare n limbaj mixt. Aceasta reprezint posibilitatea codului scris ntr-un anumit limbaj s lucreze mpreun cu codul scris ntr-un alt limbaj, necesar n special la crearea sistemelor software distribuite, de mari dimensiuni. C# este un limbaj de programare orientat-obiect conceput de Microsoft la sfritul anilor 90. Acesta fost conceput ca un concurent pentru limbajul Java. C# este un derivat al limbajului de programare C++ i a fost dezvoltat de o echip restrns de ingineri de la Microsoft, echip din care s-a evideniat Anders Hejlsberg (autorul limbajului Turbo Pascal i membru al echipei care a proiectat Borland Delphi). Limbajul C# este simplu, cu circa 80 de cuvinte cheie, i 12 tipuri de date predefinite. El permite programarea structurat, modular i orientat obiect, conform preceptelor moderne ale programrii profesioniste. Limbajul de programare C# a fost proiectat pe baza experienelor acumulate din celelalte limbaje de programare. ntregul limbaj C# se bazeaz pe conceptul de obiecte. n esen, structura unui program scris n C# este gndit pe mai multe niveluri, aa cum se arat n figura urmtoare.

Figura 1. ntr-un program C# vom avea cod de program n care se definesc metode, care sunt incluse n clase, care la rndul lor sunt incluse n nume de spaii.

1.2 Structura unui program C#Un program scris ntr-un limbaj de programare const din instruciuni n limba englez, denumite cod surs. O instruciune a unui limbaj de programare reprezint o comand dat

7

calculatorului. Totalitatea instruciunilor care descriu cum se rezolv o anumit problem se numete program. Structura unui program scris n limbajul C# este descris n figura urmtoare:

Figura 2. Structura unui program scris n limbajul C#

Urmtorul program C# afieaz pe ecran mesajul Hello World !:

Figura 3. Exemplu de program C#

Un program C# este format din una sau mai multe clase, grupate ntr-un spaiu de nume (namespace). Un spaiu de nume este o colecie de clase care au asociat un nume. Acesta poate cuprinde mai multe clase cu nume diferite avnd funcionaliti nrudite. Dou clase pot avea acelai nume cu condiia ca ele s fie definite n nume de spaii diferite. n cadrul aceluiai nume de spaiu poate aprea definiia unui alt nume de spaiu, caz n care avem de-a face cu spaii de nume imbricate. O clas poate fi identificat prin numele complet (nume precedat de numele spaiului sau spaiilor de nume din care face parte clasa respectiv, cu separatorul punct). n exemplul nostru, Simple.Program este numele cu specificaie complet a clasei Program. Codul i datele scrise n limbajul C# trebuie incluse ntr-o clas. Nu se pot defini variabile i nu se pot scrie declaraii nafara claselor. O clas este format din date i metode (funcii). Toate clasele deriv din clasa de baz denumit object. Apelarea unei metode n cadrul clasei n care a fost definit aceasta presupune specificarea numelui metodei. Apelul unei metode definite n interiorul unei clase poate fi invocat i din interiorul altei clase, caz n care este necesar specificarea clasei i apoi a metodei separate prin punct. Dac n plus, clasa aparine unui spaiu de

8

nume neinclus n fiierul curent, atunci este necesar precizarea tuturor componentelor numelui: spaiu.clas.metod sau spaiu.spaiu.clas.metod, etc. n programul nostru de mai sus se afl dou spaii de nume: unul definit (Simple) i unul extern inclus prin directiva using System;. Console.WriteLine reprezint apelul metodei WriteLine definit n clasa Console. Cum n spaiul de nume curent este definit doar clasa Program, deducem c definiia clasei Console trebuie s se gseasc n spaiul System. Altfel spus, denumirea complet ar fi System.Console.WriteLine, ceea ce ns, printre altele, ar fi incomod de redactat dac apare adesea ntr-un program. n cazul n care mai muli programatori lucreaz la realizarea unei aplicaii complexe, exist posibilitatea de a segmenta aplicaia n mai multe fiiere numite assemblies. ntr-un assembly se pot implementa mai multe spaii de nume, iar pari ale unui aceeai spaiu de nume se pot regsi n mai multe assembly-uri. Pentru o aplicaie consol, ca i pentru o aplicaie Windows de altfel, este obligatoriu ca una (i numai una) dintre clasele aplicaiei s conin un punct de intrare (entry point), i anume metoda (funcia) Main. S comentm programul de mai sus: linia 1: spune compilatorului c acest program utilizeaz tipuri de date i clase incluse n spaiul de nume System. n cazul nostru se va folosi clasa Console. linia 3: se declar un nou spaiu de nume, numit Simple. Noul spaiu de nume ncepe la acolada deschis din linia 4 i extinde pn la acolada nchis din linia 12. Orice tip declarat n aceast seciune este membru al spaiului de nume Simple. linia 5: orice program C# este alctuit din una sau mai multe clase. n aceast linie este declarat un nou tip de clas, denumit Program. Orice membrii declarai ntre acoladele care ncep n linia 6 i se termin n linia 11 sunt membrii care alctuiesc aceast clas. linia 7: n aceast linie este declarat metoda (funcia) Main ca membru al clasei Program. n acest program, metoda (funcia) Main este doar un membru al clasei Program. Main este o funcie special utilizat de compilator ca punctul de intrare n program. linia 9: Conine doar o singur declaraie simpl; aceast linie constituie corpul funciei Main. Aceast declaraie folosete clasa numit Console, amintit mai sus, care aparine spaiului de nume System i este folosit pentru operaiile de intrare/ieire. Aici se apeleaz metoda WriteLine din aceast clas, pentru afiarea mesajului dorit pe ecran. Fr folosirea directivei din linia 1 - using System compilatorul nu are de unde s tie unde se gsete clasa Console.

1.3 Metodele unui claseO metod este un bloc de cod format dintr-o serie de instruciuni care conduc la realizarea unei aciuni. O metod este asemntoare cu funciile, procedurile sau subrutinele din limbajul C, C++ sau Pascal cu anumite excepii. O metod este o funcie coninut nuntrul unei clase. Metoda Main() Orice aplicaie scris n limbajul C# trebuie s conin o metod numit Main(), care reprezint punctul de intrare n aplicaie. n acest exemplu metoda Main() nu preia nici un 9

argument din linia de comand i nu returneaz explicit un indicator de stare a terminrii programului. Toate liniile de cod care formeaz corpul metodei Main() vor fi executate automat atunci cnd programul este rulat. Clasa Console Clasa Console aparine de spaiul de nume System. Cele dou metode (funcii de afiare pe ecran) Write i WriteLine afieaz pe consol (ecran) argumentele din parantez. n cazul metodei WriteLine, dup afiare se trece la linie nou. Urmtoarea linie de cod este un exemplu al utilizrii metodei Write:Console.Write("Acesta este un text."); Output string

Codul scris mai sus produce urmtoarea ieire pe ecran: Acesta este un text. Un alt exemplu este urmtorul cod, care afieaz pe ecran trei iruri de caractere:System.Console.Write ("This is text1."); System.Console.Write ("This is text2."); System.Console.Write ("This is text3.");

Acest cod produce urmtoarea ieire:This is text1. This is text2. This is text3.

Sintaxa metodei Write i WriteLine este urmtoarea:Console.WriteLine(FormatString, SubVal0, SubVal1, SubVal2, ... );

Dac exist mai muli parametrii, acetia sunt separai prin virgul. Primul parametru trebuie s fie ntotdeauna un ir de caractere i este denumit ir de formatare (format string). irul de formatare poate conine marcatori de substituie (substitution markers). Un marcator de substituie marcheaz poziia n formatul irului unde o valoare se substituie atunci cnd irul este afiat pe ecran. Un marcator este un numr natural cuprins ntre acolade, i care reprezint poziia numeric a valorii care urmeaz a fi substituit i care ncepe de la 0. Parametrii care urmeaz dup irul de formatare se numesc valori de substituie (substitution values). Urmtorul cod conine doi marcatori de substituie, numrul 0 i 1, i dou valori de care urmeaz a fi substituite, 3 i 6.Substitution markers Console.WriteLine("Doua exemple de intregi sunt {0} si {1}.", 3, 6); Format string Substitution values

Acest cod produce pe ecran: Doua exemple de intregi sunt 3 si 6. Un marcator nu trebuie s refere o valoare de la o poziie mai lung dect lista valorilor ce trebuie substituite, n caz contrar se produce o eroare. Urmtorul exemplu reflect aceast situaie:Poziia 0 Poziia 1 Console.WriteLine("Doi intregi: {0} si {2}.", 3, 6); // Eroare! Nu exist poziia 2.

1.4 ComentariiComentariile sunt buci de text care sunt excluse de la compilarea programului i care servesc la introducerea n program a unor explicaii referitoare la pri ale acestuia. 10

comentariu pe un rnd prin folosirea // Tot ce urmeaz dup caracterele // sunt considerate, din acel loc, pn la sfritul rndului drept comentariu:// Acesta este un comentariu pe un singur rnd

comentariu pe mai multe rnduri prin folosirea /* i */ Orice text cuprins ntre simbolurile menionate mai sus se consider a fi comentariu. Simbolurile /* reprezint nceputul comentariului, iar */ sfritul respectivului comentariu:/* Acesta este un comentariu care se ntinde pe mai multe rnduri */

1.5 DeclaraiiO declaraie simpl este o instruciune n cod surs care descrie un tip de date sau care i spune programului s execute o aciune. O instruciune simpl se termin cu caracterul punct i virgul ;. Urmtorul exemplu de cod cuprinde dou instruciuni simple. Prima instruciune definete variabila cu numele var1 i o iniializeaz cu valoarea 5. A doua instruciune afieaz valoarea variabilei var1 pe ecran:int var1 = 5; System.Console.WriteLine("Valoarea lui var1 este {0}", var1);

1.6 Blocuri de instruciuniUn bloc de instruciuni cuprinde 0 sau mai multe instruciuni cuprinse ntre acolade {}. Exemplu:{ int var1 = 5; System.Console.WriteLine("Valoarea lui var1 este {0}", var1); }

Un bloc este folosit de obicei acolo unde mai multe instruciuni definesc o aciune. Un bloc de instruciuni nu se termin cu punct i virgul ;.Terminating ; Terminating ; {int var2 = 5; System.Console.WriteLine("The value of var1 is {0}", var1); } No terminating ;

1.7 IdentificatoriPrin nume dat unei variabile, clase, metode etc. nelegem o succesiune de caractere care ndeplinete urmtoarele reguli: numele trebuie s nceap cu o liter sau cu unul dintre caracterele _ i @; primul caracter poate fi urmat numai de litere, cifre sau un caracter de subliniere; numele care reprezint cuvinte cheie nu pot fi folosite n alt scop dect acela pentru care au fost definite; cuvintele cheie pot fi folosite n alt scop numai dac sunt precedate de @; 11

dou nume sunt distincte dac difer prin cel puin un caracter (fie el i liter mic ce difer de aceeai liter majuscul); Convenii pentru nume: n cazul numelor claselor, metodelor, a proprietilor, enumerrilor, interfeelor, spaiilor de nume, fiecare cuvnt care compune numele ncepe cu majuscul; n cazul numelor variabilelor dac numele este compus din mai multe cuvinte, primul ncepe cu minuscul, celelalte cu majuscul. Simbolurile lexicale reprezentnd constante, regulile de formare a expresiilor, separatorii de liste, delimitatorii de instruciuni, de blocuri de instruciuni, de iruri de caractere etc. sunt n mare aceiai ca i n cazul limbajului C++. Secvene escape Secvenele escape permit specificarea caracterelor care nu au reprezentare grafic i reprezentarea unor caractere speciale precum backslash, apostrof, etc. Secvenele escape predefinite n C# sunt: \b : Backspace (BS) \t : Tab orizontal (HT) \n : Linie noua (LF) \f : Pagina noua (FF) \r : Inceput de rnd (CR) \" : Ghilimele \ : Apostrof \\ : Backslash Literali copie la indigo Un astfel de literal ncepe cu caracterul @ urmat de un ir de caractere cuprins ntre ghilimele. Specificul acestui literal const n faptul c acesta va putea fi reprezentat exact aa cum este scris, inclusiv dac se ntinde pe mai multe rnduri. Pentru a afia va trebui folosit (ghilimele duble). Exemplu:Console.Write (@Ne place informatica mult);

Pe ecran va aprea:Ne place informatica mult

1.8 Cuvinte cheieAcestea sunt cuvinte speciale care au o semnificaie bine definit i care nu pot fi folosite dect n scopul pentru care au fost create. abstract as base bool break const continue decimal default delegate extern false finally fixed float int interface internal is lock 12 out override params private protected short sizeof stackalloc static string typeof uint ulong unchecked unsafe

byte case catch char checked class

do double else enum event explicit

for foreach goto if implicit in

long namespace new null object operator

public readonly ref return sbyte sealed

struct switch this throw true try

ushort using virtual void volatile while

Figura 4. Cuvintele cheie din C#

1.9 Tipuri de daten limbajul de programare C# exist dou tipuri de date: tipuri valoare i tipuri referin. Tipurile valoare includ tipurile simple (char, int, float, etc), tipurile enumerare i structur acestea coninnd direct datele referite i sunt alocate pe stiv sau inline ntr-o struct. Tipurile referin includ tipurile clas, interfa, delegat i tablou, toate avnd proprietatea c variabilele de acest tip stocheaz referine ctre obiecte. Toate tipurile de date sunt derivate (direct sau nu) din tipul System.Object. Tipuri predefinite Limbajul C# conine un set de 15 tipuri predefinite, pentru care nu este necesar includerea vreunui spaiu de nume via directiva using: string, object, tipurile ntregi cu semn i fr semn, tipuri numerice n virgul mobil, tipurile bool i decimal. Tipul string este folosit pentru manipularea irurilor de caractere codificate Unicode; coninutul obiectelor de tip string nu se poate modifica. Clasa object este rdcina ierarhiei de clase din .NET, la care orice tip (inclusiv un tip valoare) poate fi convertit. Tipul bool este folosit pentru a reprezenta valorile logice true i false. Tipul char este folosit pentru a reprezenta caractere Unicode, reprezentate pe 16 bii. Tipul decimal este folosit pentru calcule n care erorile determinate de reprezentarea n virgul mobil sunt inacceptabile, de exemplu n calcule monetare, el punnd la dispoziie 28 de cifre zecimale semnificative. Pentru a semnala c un literal n virgul mobil este de tip decimal, se va pune la sfritul acestuia litera m sau M. Exemplu: decimal dcm=123.456m; Pentru a semnala c un literal n virgul mobil este de tip float, se va pune la sfritul acestuia litera f sau F, altfel se va subnelege c este de tip double i ar putea aprea erori. Exemplu: float flt=345.678F;Denumir e Explicaie Valori reprezentate

sbyte byte short ushort int uint long ulong

ntreg cu semn pe 8 bii ntreg fr semn pe 8 bii ntreg cu semn pe 16 bii ntreg fr semn pe 16 bii ntreg cu semn pe 32 bii ntreg fr semn pe 32 bii ntreg cu semn pe 64 bii ntreg fr semn pe 64 bii 13

-128 127 0 255 -32768 32767 0 65535 -2.147.483.648 2.147.483.647 0 4.294.967.295 -9.223.372.036.854.775.808 9.223.372.036.854.775.807 0

float double bool char decimal object string dynamic

real cu precizie simpl real cu precizie dubl logic caracter Unicode 128 de bii, valoare real cu precizie de 28 de zecimale semnificative clasa de baz din care deriv toate tipurile secven de caractere Unicode tip folosit pentru assembly-urile din limbaje dinamiceFigura 5. Tipuri predefinite n C#

18.446.744.073.709.551.615 1.5x10-45 3.4x1038 5x10-324 1.7x10308 true, false U+0000 U+ffff 1.0x10-28 7.9x1028 System.Object System.String

Fiecare tip de date din C# i are corespondentul n tipul .Net (tipurile din spaiul de nume System). Tipuri definite de utilizator Tipurile care pot fi definite de utilizatori sunt de 6 feluri. O parte dintre acestea vor fi discutate n paginile urmtoare. class; struct; array; enum; delegate; interface.

1.10 VariabileUn limbaj de programare trebuie s permit programului s stocheze i s manipuleze date. n timpul execuiei unui program, datele sunt temporal stocate n memorie. O variabil este un nume dat unei locaii de memorie folosit de un tip particular de date n timpul execuiei programului. Astfel, fiecrei variabile i se asociaz un tip de dat i o valoare. C# prevede patru categorii de variabile, fiecare dintre acestea vor fi discutate n detaliu: Variabile locale; Cmpuri; Parametrii; Elemente de tablou. Declararea variabilelor. n C# variabilele sunt declarate astfel: ;

Exemplu:Tip

Nume variabil

int var2;

Codul de program de mai sus rezerv o arie de 4 bytes(octei) n memoria RAM, pentru stocarea valorii unei valori de tip ntreg, care va fi referit n program cu ajutorul identificatorului var2. Variabilele pot fi iniializate la declarare sau mai trziu:bool isReady = true; float percentage = 87.88, average = 43.9;

14

char digit = '7';

Dup declararea tipului unei variabile, aceasta poate fi iniializat cu o valoare. Iniializarea unei variabile se face cu ajutorul semnului egal (=) plasat ntre numele variabilei i valoarea acesteia, aa cum se arat n continuare:iniializare int var2 = 17;

Variabilele locale neiniializate au valori nedefinite i prin urmare nu pot fi folosite pn cnd nu au atribuit o valoare. ncercarea de a utiliza o variabil neiniializat va produce o eroare la compilare. Declararea mai multor variabile de acelai tip. Se pot declara mai multe variabile ntr-o declaraie. Toate variabilele dintr-o declaraie de variabile, trebuie s fie de acelai tip. Numele variabilelor trebuie separate prin virgul iniializarea acestora se poate face cu ajutorul semnului =. n urmtorul cod de program se declar se declar, mai multe variabile de tip ntreg i respectiv real:// Declaraii de variabile cu iniializare i fr int var3 = 7, var4, var5 = 3; double var6, var7 = 6.52;

Tip

Tip diferit

int var8, float var9; //Error!

Ultima declaraie este invalid deoarece sunt declarate dou variabile de tipuri diferite, n aceeai instruciune. Utilizarea valorii unei variabile. Numele unei variabile reprezint valoarea stocat de variabil. Se poate utiliza valoarea prin folosirea numelui variabilei. De exemplu, valoarea variabilei var este luat din memorie i plasat n poziia numelui variabilei, astfel:Console.WriteLine("{0}", var);

n C# (la fel ca i n celelalte limbaje de programare moderne), variabilele trebuie declarate naintea folosirii acestora. Urmtorul cod de program va da eroare la compilare, deoarece variabila numr nu este iniializat:static void Main() { int numr; //numr = 18; Console.WriteLine(numr); // error }

n cazul n care se vor terge cele dou // care preced comentariul din linia 4, codul poate fi compilat fr eroare. O variabil de un tip valoare conine efectiv o valoare. Cnd se declar o variabil de un tip valoare, compilatorul aloc n stiv numrul de octei corespunztori tipului, iar programatorul lucreaz direct cu aceast zon de memorie. O variabil de tip referin este o referin care, atunci cnd nu este null, refer un obiect de tipul specificat, alocat n memoria heap. 15

1.11 Constante. Constantele sunt variabile a cror valoare, odat definit, nu poate fi schimbatde ctre program. Constantele sunt declarate astfel: const double PI = 3.142;

16

CAPITOLUL II. EXPRESII I OPERATORI2.1 ExpresiiExpresiile reprezint niruiri de operatori i operanzi. Operanzii pot fi: literali (constante), variabile, apeluri de metode, elemente de tablou, etc. Operatori

2.2 Operatori aritmeticiOperand

+ * / % ++ --

Descriere Adunare Scdere nmulire mprire Restul sau modulo Adunare cu 1 Scdere cu 1

Notaii prefixate sau postfixate Se d urmtoarea linie de cod: int num1 = 10; Urmtoarele instruciuni sunt echivalente:num1++; num1 = num1 + 1; num1 += 1;

Ambii operatori ++ i pot fi utilizai n form prefixat sau postfixat. n forma prefixat,num1 = 3; num2 = ++num1; // num1 = 4, num2 = 4

compilatorul va incrementa prima dat variabila num1 cu 1 i apoi va atribuii aceast valoare variabilei num2. n forma postfixat,num2 = num1++; // num1 = 4, num2 = 3

compilatorul prima dat va atribuii valoarea variabilei num1 la variabila num2 i apoi incrementeaz variabila num1 cu 1.

2.3 Operatori de atribuireOperand Descriere = Atribuire simpl += Atribuire aditiv -= Atribuire substractiv *= Atribuire multiplicativ /= Atribuire cu mprire %= Atribuire cu modulo O atribuire compus are forma: op= i este echivalent cu: 17

= op ,

iar op poate fi unul din operatorii: *, /, %, +, -, , &, |, ^

Exemplu:int i=0; i += 15; echivalent cu i = i + 15;

Exemplu:using System; class FormattingNumbers { static void Main() { int val = 10; val += 10; Console.WriteLine("val val -= 5; Console.WriteLine("val val *= 10; Console.WriteLine("val val /= 3; Console.WriteLine("val val %= 8; Console.WriteLine("val Console.ReadLine(); } }

+=10 este {0}", val); -=5 este {0}", val); *=10 este {0}", val); /=3 este {0}", val); %=8 este {0}", val);

//val = 20 //val = 15 //val = 150 //val = 50 //val = 2

Citirea datelor de la tastatur i scrierea datelor la consol Citirea unui ir de caractere de la tastatur se face cu metodele Console.Read() sau Console.ReadLine(). Afiarea datelor pe ecran se face cu metodele Console.Write() sau Console.WriteLine(). Diferena dintre cele dou const n trecerea la linie nou n cazul metodelor care se termin cu Line. Exemplu:using System; namespace ConsoleApplication { class Program { public static void Main() { float a, b; string sir; Console.Write("Dati valoarea pentru variabila a="); sir = Console.ReadLine(); a = float.Parse(sir); Console.Write("Dati valoarea pentru variabila b="); sir = Console.ReadLine(); b = float.Parse(sir); Console.Write("Suma dintre a={0} i b={1} este {2}", a, b, a+b); Console.ReadLine(); } } }

Exemplul de mai sus se poate scrie i astfel: 18

using System; namespace ConsoleApplication { class Program { public static void Main() { float a, b; Console.Write("Dati valoarea pentru variabila a="); a = float.Parse(Console.ReadLine()); Console.Write("Dati valoarea pentru variabila b="); b = float.Parse(Console.ReadLine()); Console.Write("Suma dintre a={0} i b={1} este {2}", a, b, a+b); Console.ReadLine(); } } }

Pentru tipurile numerice, metoda ToString produce o reprezentare ir de caractere a unui numr. Ea poate fi folosit i cu civa parametrii, care permit diverse formatri ale afirii valorii numerice ca i ir de caractere. n C# exist predefinite o mulime de modaliti pentru formatarea afirii valorilor numerice. Lista complet a acestora se poate gsi la adresele de Internet: http://msdn.microsoft.com/en-us/library/dwhawy9k.aspx http://msdn.microsoft.com/en-us/library/0c899ak8.aspx Practic este vorba de nite specificatori de format, reprezentai de obicei de o liter, ns pot fi i cifre sau alte caractere (# % . ,). De exemplu, specificatorul de format c (sau C) va face ca valoarea numeric afiat s conin i un simbol monetar.decimal value = 123.456m; Console.WriteLine(value.ToString("C2")); Va afia: $123.46

Complementara metodei ToString este metoda Parse. Metoda Parse se folosete astfel:variabil = tipul_variabilei.Parse(input_string);

unde tipul_variabilei poate fi oricare tip de date predefinit n C#. Exemplu:int k = int.Parse("12345"); double dd = double.Parse(" -1,234.5678 "); Console.WriteLine("k={0} dd={1}", k, dd);

Exemplu:using System; class Program { static void Main() { int a = 55000; int b = 676; double c = 555.4;

19

double d = 50870.1155; string a1 = a.ToString(); string a2 = a.ToString(); Console.WriteLine(a1 + " " string b1 = b.ToString(); string b2 = b.ToString(); Console.WriteLine(b1 + " " string c1 = c.ToString(); string c2 = c.ToString(); Console.WriteLine(c1 + " " string d1 = d.ToString(); string d2 = d.ToString(); Console.WriteLine(d1 + " " Console.ReadLine(); } }

+ a2);

// 55000 55000

+ b2);

// 676 676

+ c2);

// 555.4 555.4

+ d2);

// 50870.1155 50870.1155

2.4 Operatori relaionaliOperand==

!= > < >= v2); Console.WriteLine("{0}3 && {1}3 || {1}