Documente Academic
Documente Profesional
Documente Cultură
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
Aceste programe pot fi încorporate într-un mediu integrat numit mediu de programare. Pentru
crearea programelor C++ folosim un IDE.
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:
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 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:
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:
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++
8
Structura generală a unui program C++
Un program C++ este alcătuit din funcţii şi variabile. Are următoarea structură:
Unde:
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)
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:
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.
/* comentariu pe
mai multe rânduri*/
10
Elementele de limbaj
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:
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:
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.
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.
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:
-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
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ă.
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.
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;
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:
16
3. Scrieți un program care cere introducerea valorii pentru un număr întreg x şi apoi îl afişează.
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;)
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ă)
if (expresie)
instructiune1;
else
instructiune2;
Aplicații - Instrucțiunea if
19
2. Să se calculeze valoarea funcţiei f(x), ştiind că x este un număr real introdus de la
tastatură:
#include <iostream>
#include <cmath>
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";
}
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.
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.
do
instructiune
while (expresie);
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;
}
Pseudocod: Program
#include<iostream>
întreg numar0,total0; using namespace std;
execută int main()
totaltotal+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.
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;
}
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;
}
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
26