Sunteți pe pagina 1din 27

INTRODUCERE ÎN C++

Alina Bonto
CUPRINS
Introducere Code Blocks ...............................................................................................................................2
P r e z e n t a re a e c r a n u l u i m e d i u l u i d e p r o g r am a r e C OD E BL O C K S ...................................3
Elementele de bază ale limbajului de programare C++ ................................................................................8
Structura generală a unui program C++ ........................................................................................................9
Elementele de limbaj ................................................................................................................................. 11
Setul de caractere ...................................................................................................................................... 11
Identificatori............................................................................................................................................... 11
Cuvinte cheie (keywords)........................................................................................................................... 12
Separatori şi comentarii ............................................................................................................................. 12
Tipuri de date C/C++ .................................................................................................................................. 12
Citirea/scrierea datelor .............................................................................................................................. 15
Instrucţiunile limbajului C++ ..................................................................................................................... 18
Instrucţiunea if ....................................................................................................................................... 19
Instrucţiunea while ................................................................................................................................. 21
Instrucţiunea do while ............................................................................................................................ 22
Instrucţiunea for ......................................................................................................................................... 23
Bibliografie ................................................................................................................................................ 26

1
Introducere Code Blocks
Descărcare Code Blocks de la adresele:

http://www.cnlr.ro/~tucu/viewtopic.php?f=2&t=31
sau
http://www.codeblocks.org

Pentru a obţine un program executabil, trebuie parcurse următoarele etape:


• editarea programului sursă;
• compilarea programului sursă;
• editarea legăturilor programului sursă;
• lansarea în execuţie a programului executabil;
• depanarea interactivă a programului;
• memorarea programului sursă şi a programului executabil, pe un suport de informaţie.
Aceste operaţii pot fi asigurate de diferite programe precum:
• editor de texte;
• compilator;
• editor de legături;
• program depanator.

Aceste programe pot fi încorporate într-un mediu integrat numit mediu de programare. Pentru
crearea programelor C++ folosim un IDE.

Un IDE (Integrated Development Environment) este un program ce cuprinde un editor de text,


un compilator, debugger şi builder. De ex. CodeBlocks
Mediul de programare C++ recunoaşte următoarele extensii de fişiere:
• .exe – program executabil;
• .cpp – program sursă;
• .obj – program obiect;
• .lib – bibliotecă C++;
• .h – fişier antet.

2
Pr ez en tarea ec ran u l u i med i u l u i d e p rogra mare CO DE B L O CKS

Lansarea în execuţie a editorului Code Blocks se face apăsând dublu clik pe iconul:

si se va deschide pe ecran fereastra aplicaţiei.( daca este necesar închideţi ferestrele suplimentare
care apar). Ecranul editorului Code Blocks arata astfel:

Primul PROIECT (PROJECT)

Pentru a reuşi să scrieţi un program în limbajul C++ trebuie să deschidem mai întâi spațiu de
lucru. La un moment dat putem avea în lucru unul sau mai multe proiecte în spaţiul de lucru. Un
proiect este o colecție de una sau mai multe surse şi fișiere. Fișierele sursă sunt fișiere care conțin
codul sursă pentru programul tău. Un fişier care conţine un cod sursă scris în limbajul C ++ va
avea extensia .cpp. Configurarea unui proiect vă permite să urmăriți toate fișierele într-un mod
organizat.

Pas 1: Selectaţi de pe ecran opţiunea Create a new object

Pas 2: Se va deschide o fereastă ca în imaginea următoare din care veți selecta opţiunea Console
Application, după care apăsaţi butonul Go

3
Pas 3: Selectaţi opţiunea C+ +, după care apăsaţi butonul Next

Pas 3: În secţiunea Project Title scrieţi numele noului proiect, după care din secţiunea Folder
to create project in: se stabileşte locul în care se va salva noul proiect, iar la sfarşit selectaţi
butonul next.

4
Pas 4: Din secţiunea Compiler se alege compilatorul GNU GCC Compiler si se apasă butonul
Finish

Pas 5: Din partea dreapta a ecranului se deschide folderul Sources şi se deschide cu dublu click
fisierul main.cpp. Din acest moment puteţi începe să editaţi noul cod sursă. Spor la lucru!

5
Pas 6: După ce ați editat codul sursă programul trebuie verificat dacă este corect scris, din punct
de vedere sintactic (etapa de compilare - Build). Acest lucru se poate realiza astfel:

 din meniu superior selectăm în ordine optiunile: BuildBuild


 sau apăsând combinaţia de taste Shift+F9
 sau apasând pe icon-ul Build:

Atunci când programul nostru nu conţine erori de sintaxă în partea inferioară a ecranului ne
apare un mesaj de forma:

Pas 7: În acest moment putem lansa în execuţie programul nostru pentru a vedea rezultatele
obţinute astfel:

 din meniul superior selectăm în ordine opţiunile: BuildRun


 sau apăsând combinaţa de taste Ctrl+F10
 sau apăsând pe icon-ul Run:

sau

Compilare, rulare şi link-editare program sursă: Build  Build&Run sau tasta F9 sau

6
Pas 8: Închidere fereastră de compilare – Close

7
Elementele de bază ale limbajului de programare C++

Un limbaj de programare reprezintă un mijloc de comunicare între programator şi


calculator.
Informaţia ce trebuie comunicată este codificată printr-un program pe baza a trei
componente:
• un set de acţiuni, care acţionează asupra unui
• set de date într-o anumită
• secvenţă de acţionare.

Repere istorice în evoluţia limbajelor de programare:


• 1955 – FORTRAN (FORmula TRANslation)
• 1960 – ALGOL (ALGOrithmic Language)
• 1960 – COBOL (COmmon Business Oriented Language)
• 1971 – Pascal (Blaise PASCAL)
• 1972 – C
• 1980 – C++
• 1995 – Java

Limbajul de programare C++


La începutul anilor 70 a apărut limbajul C – creaţia lui Dennis Ritchie şi Brain Kernighan.
Limbajul C++ este creaţia lui Bjarne Stroustrup şi reprezintă o extensie a limbajului C care permite
programarea pe obiecte.

Realizarea unui program scris în C++ necesită parcurgerea a patru etape:


• editare – scrierea programului sursă, prin crearea unui fişier cu extensia .cpp;
• compilare – se aduce în memoria internă programul sursă, se verifică erorile şi se converteşte
acest program în program obiect, având extensia .obj;
• link-editare – se leagă programul obiect cu bibliotecile de sistem şi se transformă într-un program
executabil având extensia .exe;
• execuţie – se lansează în execuţie programul obiect: se efectuează citirea datelor, calculele şi
scrierea rezultatelor, formându-se fişierul.

8
Structura generală a unui program C++

Un program C++ este alcătuit din funcţii şi variabile. Are următoarea structură:

Unde:

# - directive pentru preprocesor


- indicații pentru compilator
< > indică compilatorului să caute fişiere ce trebuie introduse în program

Orice mediu de programare C++ dispune de un set de funcții predefinite, scrise de autorii
limbajului. Se plasează la începutul programului.

Sintaxa: #include<nume_header>

Directivele preprocesor sunt fişiere librării memorate separat şi care au extensia .h.

iostream este un fişier antet (header) care este utilizat pentru a gestiona intrările şi ieşirile
implicite de date (datele de intrare se vor prelua implicit de la tastatură şi datele de ieşire vor fi
afişate în mod implicit pe monitor). Librăria iostream face parte din biblioteca implicită a
limbajului C++.

În funcţie de alte opţiuni ale utilizatorului se vor insera în codul sursă şi alte fişiere antet cum ar
fi:

cmath – este un fişier care face parte din biblioteca standard a limbajului C, unde sunt definite
funcţiile matematice (cum ar fi radical din x –sqrt(x), ridicare la putere pow(a,b), modulul unui
număr abs(a),funcţiile trigonometrice, etc.

fstream - este un fişier în care sunt definite funcţiile de bază pentru lucru cu fişiere text.
Stream-urile implicite tastaura şi monitorul se vor schimba în fişiere text de intrare sau de ieşire.

!! Directivele nu se încheie cu ;

Std – este o prescurtare a cuvântului standard. În cadrul spațiului de nume std găsim
funcții simple pentru citirea și afișarea textului pe ecran, raportarea unor erori de logică ce apar în
timpul execuției programului. (pachet ce conține date utilizate de program)

După includerea în program a fişierelor header urmează o secţiune rezervată definirii de


tipuri de date şi variabile globale.

9
Definiţie 2: Definirile globale de variabile se fac la începutul programului şi acestea vor fi
cunoscute în toate funcţiile din program.

Definiţie 3: Definirile locale de variabile se fac în cadrul unei fucţii şi ele sunt cunoscute doar în
funcţia în care au fost definite.

În cazul programelor simple, care conţin doar funcţia main() nu este necesară definirea
globală a variabilelor.

Funcţiile utilizator :

 definirea oricărei funcţii este construită din antetul funcţiei şi corpul funcţiei
 antetul funcţiei conţine numele funcţiei, tipul rezultatului pe care funcţia îl calculează şi o
listă de parametri prin care funcţia comunică cu exteriorul ei, încadrată între paranteze
rotunde:

tip_rezultat nume_functie(lista de parametri)

Orice program C++ trebuie să conţină în mod obligatoriu o funcţie specială numită main.

Funcţia main() este o funcţie specială, mai este numită şi funcţia principală sau programul
principal.

int main()

Cuvântul-cheie int reprezintă o variabilă de tip număr întreg, parentezele rotunde arată faptul că
main este o funcție, toate funcțiile deosebindu-se de variabile și clase prin parantezele rotunde.

return 0;

Determină funcția main să se finalizeze. Este cel mai utilizat mod de încheiere a unui program în
consolă.

Funcția main fiind de tip int, aceasta trebuie să returneze o variabilă de tip întreg după executarea
ei. În cazul în care codul a fost executat corect, fără erori, funcția main va returna valoarea 0.

Acoladele sunt separatori ai funcției main, iar ce se află în interiorul lor este codul pe care funcția
main îl va executa la rularea programului.

Un program poate să conțină comentarii:

//comentariu pe un rând sau

/* comentariu pe
mai multe rânduri*/

10
Elementele de limbaj

Limbajul C++ este caracterizat de:


• sintaxă – formată din totalitatea regulilor de scriere corectă a programelor;
• semantică – reprezintă semnificaţia construcţiilor corecte din punct de vedere sintactic;
• vocabular – este format din totalitatea cuvintelor care pot fi folosite într-un program.

Vocabularul limbajului C++ este format din:


• setul de caractere;
• identificatori;
• cuvinte cheie;
• comentarii;
• separatori.

Setul de caractere utilizat pentru scrierea programelor este setul de caractere al codului
ASCII:
 litere mari şi mici ale alfabetului englez
 cifrele sistemului zecimal
 semnele matematice şi de punctuaţie şi separatori: +,-,*,/,%,<,>,=,#,!,&,|,?,^,(,),[,],{,},;

Identificatori

Definiţie: Identificatorii sunt acele construcții care au rolul de a denumi elemente ale programului
şi reprezintă nume de: constante, variabile, funcţii, etc.

Din punct de vedere sintactic un identificator este constituit dintr-o succesiune de litere
mari sau mici ale alfabetului englez, cifrele sistemului zecimal şi caracterul “_”, cu condiţia ca
primul caracter să nu fie o cifră.

Spre exemplu:

Identificatori corect scrişi Identificatori greşit scrişi


max_1 nume prenume
citire_vector 1max
_unu a+b

Numele variabilelor nu pot să înceapă cu o cifră.

Observaţii:

1. un identificator poate avea orice lungime, dar sunt luate în considerare doar primele 31
de caractere
2. În limbajul C++ se face diferenta dintre literele mari şi literele mici, din acest punct de
vedere spunem că limbajul este case-sensitive (identificatorii max_1 şi Max_1 sunt
diferiţi).
3. este recomandat ca identificatorii folosiţi să fie sugestivi, pentru a nu apela la comentarii
pentru a întelege scopul în care este folosit un identificator. Este util să construim
identificatori prin compunerea mai multor cuvinte, şi recomandat este ca iniţiala fiecărui
cuvânt să fie majusculă (Citire_Vector, Afisare_Matrice)

11
Cuvinte cheie (keywords)

Cuvintele cheie sunt identificatori speciali, rezervaţi limbajului C++, cu înţeles predefinit şi
care pot fi utilizaţi numai în construcţiile sintactice în care sunt definiţi. În limbajul C++ toate
cuvintele cheie se scriu doar cu litere mici.

Tabelul care cuprinde toate cele 32 de cuvinte cheie ale limbajului C++ este:

auto double int struct


break else long switch
case enum register typedef
char extern return union
const float short unsigned
continue for signed void
default goto sizeof volatile
do if static while

Separatori şi comentarii
Separatorii au rolul de a delimita unităţile lexicale dintr-un program.
Lista separatorilor admişi în limbajul C++ este:

 (,) parantezele rotunde încadrează lista de parametrii a unei funcţii, sau precizează
ordinea de efectuare a operaţiilor pentru evaluarea unei expresii.
 { } acoladele încadrează instrucţiunile compuse, care se mai numesc şi blocuri.
 [ ] parantezele drepte încadrează dimensiunile tablourilor
 " " ghilimelele încadrează şirurile de caractere
 ' ' apostrofii încadrează un singur caracter
 ; fiecare instrucţiune se încheie cu caracterul ;
 /* */ comentariile sunt încadrate de caracterele /* şi */ sau dacă dorim ca un singur rând
din codul sursă sa fie comentat, sau în dreptul unei instrucţiuni să apara un comentariu
folosim caracterele //. Comentariile sunt texte care vor fi ignorate în momentul execuţiei
programelor, dar au rolul de a clarifica si a face un cod sursă mai clar pentru cel care citeşte
acel cod.

Tipuri de date C/C++

Tipul de date reprezintă un concept foarte important în C/C++. Orice dată (constantă sau variabilă)
este de un numit tip. Tipul datei precizează ce valori poate avea acea dată și ce operații se pot face
cu ea.

În C/C++ tipurile de date sunt:

1. Tipuri simple
o Tipuri întregi
o Tipuri reale
o Tipul pointer
o Tipul bool
12
o Tipul void
2. Tipuri derivate
o Tipul tablou
o Tipul structură
o Tipul enumerare

Tipuri simple
Tipurile întregi

Tipurile întregi permit memorarea de valori întregi. Tipul de bază este int. O dată de tip int
poate memora valori întregi cuprinse între -231 și 231-1.

Tipurile întregi diferă prin numărul de octeți necesari pentru memorarea datei, tipul datei (cu
semn sau fără semn) și implicit intervalul de valori pe care le pate lua respectiva dată. Tipurile
întregi sunt:

Denumire tip Reprezentare Interval de valori -

-2147483648 ...
int 4 octeți cu semn -231 ... 231-1
2147483647

4 octeți fără
unsigned int 0 ... 232-1 0 ... 4294967295
semn

-2147483648 ...
long int 4 octeți cu semn -231 ... 231-1
2147483647

4 octeți fără
unsigned long int 0 ... 232-1 0 ... 4294967295
semn

short int 2 octeți cu semn -215 ... 215-1 -32768 ... 32767

2 octeți fără
unsigned short int 0 ... 216-1 0 ... 65535
semn

long long int 8 octeți cu semn -263 ... 263-1

unsigned long long 8 octeți fără


0 ... 264-1
int semn

char 1 octet cu semn -27 ... 27-1 -128 ... 127

1 octet fără
unsigned char 0 ... 28-1 0 ... 255
semn

13
Tipurile char și unsigned char memorează valori întregi. La afișarea unei date de acest tip
nu se va afișa numărul pe care îl memorează ci caracterul care are are codul ASCII egal cu acel
număr. Operația de citire a unei date de acest tip este similară.

Tipurile reale – în virgulă mobilă

Memorează valori reale, reprezentate prin mantisă și exponent. În acest mod se pot reprezenta
valori foarte mari, dar precizia reprezentării poate fi slabă – numărul de cifre semnificative
memorate poate fi mult mai mic decât numărul de cifre din număr.

Tipurile reale sunt:

 float – se reprezinta pe 4 octeți;


 double – se reprezinta pe 8 octeți;
 long double – se reprezinta pe 10 octeți;

Tipul void permite explicitarea faptului că o funcţie nu returnează nimic sau nu are nici un
parametru. Este tipul de dată vidă (fără tip specificat), utilizat în general pentru mărirea clarităţii
programelor.
Exemplu:
void salut(void)
{
cout<<“SALUTAM PROGRAMATORII IN LIMBAJUL C++!!!\<<endl;
}

Tipul pointer

O dată de tip pointer memorează o adresă de memorie – de exemplu adresa unei variabile. Vom
reveni asupra tipului pointer mai târziu.

Tipul bool

Anumite operații care se fac cu datele au ca rezultat valori de adevăr: adevărat sau false. În
anumite limbaje de programare există un tip de date care memorează exact aceste două valori.

14
În limbajul C++ există tipul bool. Acest tip conține două valori: literalii true și false. De
fapt, acestea sunt redenumiri ale valorilor 1 și 0.

Citirea/scrierea datelor
Citirea datelor reprezintă operaţia prin care una sau mai multe variabile primesc
valori prin introducerea lor de la tastatură sau prin extragerea lor de pe un suport extern
(adică dintr-un fişier text)
În fişierul antet iostream este definit acest stream (flux) de intrare a datelor de la tastatură,
denumit cin (console input). Atunci când dorim să citim datelele de la tastatură le vom extrage din
fluxul de intrare, folosind operatorul de extragere ”>>”. Din acest punct de vedere forma generală
a operaţiei de citire este:
cin>>nume_variabilă;

Dacă dorim să citim succesiv mai multe variabile, atunci putem utiliza operatorul de extragere
înlănţuit, adică:
cin>>nume_variabilă_1>>nume_variabilă_2>>…>>nume_variabilă_n;

Ex. cin>>x;

Prin afişarea sau scrierea datelor vom întelege operaţia prin care rezultatele
obţinute prin prelucrarea datelor de intrare vor fi afişate pe ecranul monitorului, fie vor fi
memorate într-un fişier text pe un suport extern de memorare.

15
În fişierul antet iostream este definit acest stream de ieşire a datelor de la tastatură,
denumit cout (console output). Atunci când dorim să afişăm datelele le vom extrage din fluxul de
ieşire, folosind operatorul de ieşire ”<<”. Din acest punct de vedere forma generală a operaţiei de
afişare este:
cout<<expresie;

Ca efect, se evalueză expresia, iar valoarea ei este convertită într-o succesiune de caractere care
vor fi afişate pe ecran. Şi operatorul de ieşire poate fi utilizat înlănţuit atunci cand dorim sa afişăm
mai multe date pe ecran:
cout<<expresie_1<<expresie_2<<expresie_3<<…<<expresie_n;

Ex. cout<<”s-a citit numărul x”;

Pentru afişarea unui text pe mai multe rânduri se foloseşte secvența Escape “\n” care are ca efect
mutarea cursorului la începutul rândului următor pe ecran. (salt la un rând nou).
Se poate utiliza şi manipulatorul numit endl (end line).

La scrierea în streamuri, datele de ieşire se acumulează într-un buffer (stream) care se goleşte
periodic, nefiind nevoie de accesarea discului la fiecare operaţie de scriere. Manipulatorul de
format endl, face flush stream-ului de ieşire, ceea ce forţează scrierea pe disc. Dacă aceasta se
întamplă într-un ciclu, atunci viteza scade catastrofal. (din Sfaturi de bună practică pentru
concurenţii OJI / ONI 2016)

Aplicații
1. Afişarea unui text:

2. Rescrieți exemplele de la punctul 1 utilizând secvența Escape.

16
3. Scrieți un program care cere introducerea valorii pentru un număr întreg x şi apoi îl afişează.

4. Se citesc de la tastatură două numere întregi a şi b. Scrieţi un program care calculează şi


afişează pe ecran suma lor.

5. Scrieţi un program care să afişeze pe ecran:

6. Să se realizeze o carte de vizită după modelul:


*************************
* Numele vostru *
* *
*************************
17
Instrucţiunile limbajului C++

Limbajul C++ consideră instrucţiunile ca fiind instrucţiuni simple şi instrucţiuni


compuse:
O instrucţiune simplă este de fapt o singură instrucţiune, cum ar fi aceea de atribuire sau
de apel a unei funcţii standard (de exemplu funcţia cout).
O instrucţiune compusă este alcătuită din două sau mai multe instrucţiuni incluse între
acolade.

Instrucţiunea expresie:
Are 3 forme:
a) instrucţiunea de atribuire
b) instrucţiunea de apel de funcţie
c) instrucţiunea de incrementare / decrementare

a) instrucţiunea de atribuire
variabila = expresie;
sau
variabila operator = expresie;
Exemplu:
int x, y, z;
z = x + 5 * y;
x + = 10; (semnificație: x = x + 10;)

b) instrucţiunea de apel de funcţie


nume_functie(pa1, pa2, . . . ,pan);
unde pa1, pa2, . . ., pan sunt parametrii actuali ai funcţiei (adică valorile cu care se va
lucra în funcţia respectivă la apelul funcţiei).

Exemplu:
maxim (int a, int b); // apelul functiei maxim care are doi parametri actuali de tip întreg

c) instrucţiunea de incrementare/decrementare

variabila ++;
++ variabila;
variabila --;
-- variabila;

Stă la baza celor mai mulți algoritmi. Forma cea mai des folosită este var++sau var--, în
traducere însemnând var+1, respectiv var-1.

Exemplu:
int i, j, k;
i++;
--j;
k++ + --i;

18
Instrucţiunea if (instrucţiune de decizie sau condiţională)

Are două forme:


if (expresie) instructiune;

if (expresie)
instructiune1;
else
instructiune2;

Aplicații - Instrucțiunea if

1. Se dau trei numere întregi a,b,c. Să se afişeze numerele în ordine crescătoare.


Exemplu: Dacă a = 12, b = 2, c = 9, atunci obţinem a = 2, b = 9, c = 12

Pas 1: Date de intrare: a, b, c numere întregi


Date de iesire: a, b, c în ordine crescătoare

Pas 2: Analiza problemei


1) Comparăm primele două numere a şi b, dacă a este mai mare decât b atunci vom
interschimba cele două valori.
2) Comparăm următoarele două numere b şi c, dacă b este mai mare decât c atunci vom
interschimba cele două valori.
3) Comparăm din nou cele două numere a şi b, dacă a este mai mare decât b atunci vom
interschimba cele două valori.

Pas 3: Scrierea algoritmului în pseudocod: Pas 4: Implementarea algoritmului în


limbajul de programare C++:
#include <iostream>
using namespace std;
int main()
{
int a,b,c,aux;
cin>>a; cin>>b; cin>>c;
if(a>b){
aux=a;
a=b;
b=aux;
}
if(b>c){
aux=b;
b=c;
c=aux;
}
if(a>b){
aux=a;
a=b;
b=aux;
}
cout<<a<<" "<<b<<" "<<c;
}

19
2. Să se calculeze valoarea funcţiei f(x), ştiind că x este un număr real introdus de la
tastatură:

Scrierea algoritmului în pseudocod: Implementarea algoritmului în limbajul de


programare C++:

#include <iostream>
#include <cmath>

using namespace std;


int main()
{
float x,f;
cin>>x;
if(x <=-7)
f = -6 * x + 20;
else
if(x >-7 && x <= 0)
f = x + 30;
else
f = sqrt(x) + 2;
cout<<"f = "<<f;
}

3. Scrieți un program care rezolvă ecuația de gradul întâi de forma ax+b=0. Dacă a ≠ 0 se va afişa
soluția, în caz contrar se va afişa mesajul “nu există soluții”. Dacă a=b=0 se va afişa mesajul “o
infinitate de soluții”.

#include <iostream>
using namespace std;
int main()
{
double a,b,x;
cout<<"a="; cin>>a;
cout<<"b="; cin>>b;
if (a!=0)
{ x=-b/a;
cout<<"x="<<x;
}
else
if (b==0)
cout<<"o infinitate de solutii ";
else cout<<"nu sunt solutii";
}

4.Scrieți un program care va afişa calificativul obținut în urma examenului de compentențe


digitale. Astfel:
20
P<=10, fara punctaj
11<=p<=30 incepator
31<=p<=55 mediu
56<=p<=74 avansat
p>=75 experimentat

5.Se citesc 4 numere de la tastatură. Să se determine dacă suma lor este pozitivă.
6. Se citesc 3 numere de la tastatură. Să se determine dacă produsul lor este pozitiv.
7. Se citeşte un număr de la tastatură, întreg şi pozitiv de maxim 5 cifre. Să se determine câte
cifre are numărul. Exemplu: n=123 are 3 cifre.

Instrucţiunea while (instrucţiune repetitivă cu test iniţial)

Are următoarea formă:


while (expresie)
instructiune;

unde instrucţiune poate fi:


 instrucţiunea vidă
 instrucţiunea simplă
 sau instrucţiunea compusă

Funcţionarea unei astfel de instrucţiuni se bazează pe evaluarea expresiei date şi executarea


repetată a instrucţiunii cât timp expresia este îndeplinită.
Aplicații instrucțiunea while
1. Se citeşte un număr n. Să se afişeze suma cifrelor numărului n.
Pseudocod: Program C++:
întreg n,s #include<iostream>
citeste n using namespace std;
s0 int s,n;
| cat timp n!=0 executa int main ()
|ss+n%10 {
| nn/10; s=0;
|▄ cout<<"n=";cin>>n;
scrie s while(n!=0)
{
s=s+n%10;
n=n/10;
}
cout<<s;
}

21
2. Scrieți un program care afişează cmmdc a două numere a şi b citite de la tastatură.(Algoritmul
lui Euclid)
3. Scrieți un program care afişează cmmdc a două numere a şi b citite de la tastatură.(Algoritmul
lui Nicomahus)
4. Scrieți un program care afişează cmmmc a două numere a şi b citite de la tastatură.
(cmmmc=a*b/cmmdc)
5. Se citeşte un număr întreg a. Să se scrie un program care să verifice dacă numărul citit este sau
nu palindrom.
Numim palindrom un număr care este egal cu oglinditul său. De exemplu dacă se citeşte
pentru a valoarea 121 atunci algoritmul va afişa „este palindrom", iar dacă va citi 122 va
afişa „nu este palindrom".
6. Să se scrie un program care citeşte un număr şi numără câte cifre pare şi câte impare are
numărul.
7. Se citeşte un număr natural n. Să se calculeze suma cifrelor numărului n.
8. Se citeşte un număr natural n. Să se calculeze produsul cifrelor numărului n.

Instrucţiunea do while (instrucţiune repetitivă cu test final)

Are următoarea formă:

do
instructiune
while (expresie);

unde instrucţiune poate fi:


 instrucţiunea vidă
 instrucţiunea simplă
 instrucţiunea compusă

Funcţionarea unei astfel de instrucţiuni se bazează pe executarea repetată a instrucţiunii cât


timp condiţia este îndeplinită.

Aplicații instrucțiunea do while

1. Fie un număr natural n de cinci cifre. Să se scrie un algoritm care să calculeze suma cifrelor
numărului dat.
Exemplu:
Pentru n = 20178, se va afişa valoarea s = 2+0+1+7+8 = 18

22
Pseudocod: Program

natural n, s #include<iostream>
citeşte n using namespace std;
s <- 0 int main()
execută {
s <- s + n % 10 int n, s;
n <- n / 10 cin>>n;
cât timp n! = 0 s = 0;
scrie s do
{
s = s + n % 10;
n = n / 10;
}while( n != 0 );
cout<<s;
}

2. Să se scrie un program care tipăreşte numerele naturale de la 0 la 9 şi suma lor pe


parcurs.

Pseudocod: Program
#include<iostream>
întreg numar0,total0; using namespace std;
execută int main()
totaltotal+numar; {
scrie numar, total;
int numar = 0, total = 0;
numar++;
do{
cât timp (numar< 10);
total = total + numar;
cout<<"numar = "<<numar++<<" total =
"<<total<<"\n";
}while (numar<10);
}

Instrucţiunea for

Este una dintre cele mai “puternice” instrucţiuni ale limbajului C/C++, datorită formei sale.

Forma instrucțiunii este:

for(expresie1; expresie2; expresie3)


instructiune;

expresie1 – reprezintă secvenţa de iniţializarea a ciclului


expresie2 – reprezintă condiţia de terminare a ciclului
expresie3 – reprezintă secvenţa de reiniţializare a ciclului
instrucţiune - corpul ciclului

23
Funcţionarea instrucţiunii for are loc astfel:
 Se porneşte ciclul repetitiv prin iniţializarea sa, adică prin execuţia expresia1
 iar apoi se evaluează expresia2 şi dacă este adevărată se execută corpul ciclului, adică
 instrucţiune
 după aceea se execută expresia3, şi se reia evaluarea expresiei2.

Observaţie:
expresia1, expresia2, expresia3 pot să lipsească, dar este obligatorie prezenţa semnelor: “;”.
for(;;)  while(1) – buclă infinită

Instrucţiunea for este de fapt o variantă particulară a instrucţiunii while, forma echivalentă este:

expresie1;
while(expresie2)
{
instructiune;
expresie3;
}

Aplicații instrucțiunea for


1. Fie un număr natural n. Să se scrie un algoritm care să calculeze factorialul numărului
dat.
Exemplu:
Pentru n = 5, se va afişa valoarea p = 1*2*3*4*5=120.

Pseudocod Program C++

natural n, p, i #include<iostream>
citeşte n using namespace std;
p <- 1 int main()
pentru (i=1,n) execută {
p <- p * i unsigned int n, p, i;
scrie p cin>>n;
p = 1;
for(i = 1; i<=n; i++)
p = p * i;
cout<<p;
}

2. Să se scrie un program care afişează tabla înmulţirii de la 1 la 10.


#include <iostream>
using namespace std;

int main()
{
for(int i=0;i<=10;i++)
{
cout<<"Inmultirea cu "<<i<<"."<<endl;
24
for(int j=0;j<=10;j++)
{
cout<<j<<"*"<<i<<"="<<j*i<<endl;
}
cout<<endl;
}
return 0;
}

25
Bibliografie

1. Coord. Semenescu Augustin – Informatică, Bucureşti, Ed. Niculescu, 2015


2. Moraru Pavel Florin – Informatică pentru liceu şi Bacalaureat, Sibiu, Ed. Donaris, 2003
3. https://sites.google.com/site/eildegez/
4. http://www.pbinfo.ro
5. http://olimpiada.info/oji2011/OJI_ONI_good_practice.pdf
6. www.runceanu.ro/
7. http://www.ududec.com/

26