baze c++sructura unui program declarare variabilepdf.

Curs Programarea Calculatoarelor © Ovidiu Grigore
Structura unui program in C++
Programare = implementarea / rezolvarea unei probleme (sarcini) cu
ajutorul calculatorului.
Cod sursă = Editarea utilizând sintaxa unui limbaj de programare
(implementare) a unui algoritm (sau mai mulți) cu scopul
de a realiza una sau mai multe sarcina/obiective (task).
Programare structurată = împărțirea unui program in porțiuni care
realizează anumite sarcini specifice, parțiale si facile fata
de obiectivul inițial.

Limbaj / Programare structurata
• Divizarea programului se bazeaza pe descompunerea conceptuala a
algoritmului iniţial în sarcini mai simple, care să se poată
implementa în module cvasi-independente, între care interacţiunea să
fie redusă la minim.
• Modul de realizare  implementare procedurală/modulară
• Efecte:
- realizarea unor programe eficiente, clare, ușor de urmarit
- ușurează întregul proces de realizarea a unei aplicații software:
editare, compilare, depanare (corectare) erori, testare
reutilizare cod, modificarea facilă a aplicatiilor

Concepte de baza ale programării structurate:
1. Reutilizarea codului = modulele implementate, depanate, testate si
utilizate pentru o anumita sarcină (aplicatie) se pot folosi (fără efort
de proiectare/implementare) si pentru realizarea altor sarcini, în alte
aplicații.

Concepte de baza ale programării structurate:
2. Ascunderea / protejarea datelor = interacțiunea între exteriorul si
interiorul modulului este strict administrată de programator. Avem:
- date (locale) la care nu exista acces din exterior;
- date care sunt transmise din exterior către interior, care nu pot
fi modificate din modul;
- date transmise din exterior către interior a căror modificare se
va păstra in exteriorul modulului
- date transmise din interior spre exterior (rezultate)

• Realizarea structurii modulare a unui program se face, în general,
prin intermediul funcțiilor (Obs.: Mai sunt si alte mecanisme, care se
vor discuta mai târziu)
Un program în C++ este alcătuit din una sau mai multe funcții, dintre
care, în mod obligatoriu, una este funcția principală, main().
Funcția = bloc de instrucțiuni care poate fi apelat din orice alta parte a
programului, inclusiv din interiorul funcției respective

Instrucţiune = specifică o acţiune sau operaţie ce trebuie executată de
program.
Toate instrucţiunile din C++ se termina cu ';'
Obs.:
C++ nu recunoaşte spaţiile libere, tab-urile şi sfârşitul de linie ca
terminator şi ca urmare nu exista constrângeri în ceea ce priveşte
poziţia unei instrucţiuni în linie. De asemenea, tot ca urmare a
acestei reguli, se pot plasa două sau mai multe instrucţiuni pe
aceeaşi linie.

Bloc de instrucțiuni → grup (înșiruire) de instrucțiuni care poate
cuprinde la rândul său alte blocuri de instrucțiuni.
→ începe cu acoladă deschisă '{'
→ se încheie cu acoladă închisă '}'.
→ poate să cuprindă variabile proprii (locale),
care sunt disponibile numai în interiorul acelui bloc
→ declararea variabilelor locale se face poate
face oriunde în bloc, însă este indicat să se facă la începutul
blocului, pentru a fi administrate mai ușor .

Schema unui bloc de instrucțiuni:
{
instrucţiune 1;
instrucţiune 2;
……………………….
……………………….
instrucţiune N;
}
declaraţii de variabile locale blocului
{ BLOC
}
Declaratiile pot fi
facute oriunde in
bloc

Funcția = bloc de instrucțiuni căruia i se asociază un nume, are o lista
de parametrii (argumente) de apel si poate returna un rezultat.
→ poate fi apelată prin numele său de oriunde din program
tip_returnat nume_funcţie (listă parametrii)
{
}
secvenţă de declaraţii variabile locale funcţiei
Declaratiile pot
fi făcute
oriunde in bloc
secvenţă de instrucţiuni şi blocuri de instrucţiuni

Structura unui program
directive de preprocesare (includere module antet)
main()
{
. . . . . . . . . . . . . . . . . .
}
declaraţii variabile globale
declaraţii tipuri de date, prototipuri de funcţii
fct_1()
{ . . . . . . . . . . . . . . . . . .
}
. . . . . . . . . . . . . . . . . . . . . . . .
fct_N()
{ . . . . . . . . . . . . . . . . . .
}

Funcția main() este funcția cu care începe execuția programului.
Execuția programului = parcurgerea succesiva, secvențială a
instrucțiunilor funcției main()
main = cuvânt cheie, rezervat.  Se poate folosi strict numai pentru
definirea funcției principale.

Elemente ale limbajului C++
Afisarea unui mesaj in C++
Exemplu: #include <iostream.h>
void main()
{
cout << “Primul meu mesaj” << endl;
}
Obs.:  cout este un obiect definit din clasa ostream
echivalent cu “ variabila definita din tipul de date ostream ”
 << este un operator binar (ca de ex.: a + b) în care conținutul
operandului drept este transferat operandul stâng (cout).
Sintaxa: cout << OperandDrept

Elemente ale limbajului C++
Citirea datelor in C++
Exemplu: #include <iostream.h>
void main()
{ int a;
cin >> a;
cout << “a = “ << a << endl;
}
Obs.:  cin este un obiect definit din clasa istream
echivalent cu “ variabila definita din tipul de date istream ”
 >> este un operator binar (ca de ex.: a + b) în care conținutul
operandului stâng (cin) este transferat în operandul drept.
Sintaxa: cin >> OperandDrept

Limbajul de programare C++
Directive de preprocesare
Preprocesarea  etapa de prelucrare la nivel de text a codului sursa
înaintea etapei de compilare (verificare sintaxă).
 există operații care se fac automat, precum
eliminarea spațiilor albe, eliminarea comentariilor, etc
 există operații forțate, introduse de programator
folosind directive de preprocesare = comenzi care
încep cu simbolul #

Limbajul de programare C++. Directive de preprocesare
#include Includerea fisierelor sursa
Sintaxa: #include < fisier_sursa >
#include " fisier_sursa "
Descriere:
- Efectul  includerea totala a fișierului sursa in locul directivei.
- Diferența intre cele doua forme este locul unde este căutat fișierul sursa:
< > fișierul este căutat in directoarele standard (specificate prin
opțiuni sau prin variabile de mediu in funcție de compilator).
" " fișierul este căutat întâi in directorul curent, apoi, daca nu este
găsit, in directoarele standard.
-> permite si specificarea caii complete către fișierul inclus; in
acest caz, nu se mai face căutarea si in directoarele standard.

Exemple:
// include fisierul iostream.h
// din directoarele standard
#include <iostream.h>
// include fiserul ListeSimple.h;
// cautarea se face intai in directorul curent
// apoi in directoarele standard
#include “liste.h”
// include fisierul Masive.cpp din directorul
// c:Biblioteci; daca fisierul nu exista nu
// mai este cautat in alta parte si se genereaza
// o eroare de compilare
#include "C:BiblioteciFunctii1.cpp"

Bibliotecile de funcții = colecție de funcții deja implementate și
compilate, pe care utilizatorul le poate folosi direct fără a mai fi
nevoie să le implementeze (reutilizare cod).
Codul obiect al funcțiilor se adaugă codului sursă propriu in
etapa de linkeditare
Fisiere header (extensie .h) = fisiere in care se declară (uneori se
definesc) prototipul funcțiilor, tipuri de date, etc., definite în
fișierele sursa ale bibliotecii.

Entitățile definite in biblioteci pot fi utilizate in programul propriu
numai după includerea lor folosind directiva de preprocesare
#include <nume_header>
Exemplu: #include <iostream>
int main()
{ cout << “Mesaj” << endl;
. . . . . . . . .

#define Constante simbolice
Sintaxa: #define nume_macro sir_caractere
Descriere:
- Efectul  înlocuirea la nivel de text (înaintea compilarii) a șirului de
caractere nume_macro cu șirul de caractere
sir_caractere
Excepție: nu se înlocuiesc aparițiile din cadrul unor constante de tip sir,
in comentarii sau in componenta unui alt identificator

Reguli:
-> pentru introducerea unui sir_caractere pe mai multe linii, se
va folosi caracterul la sfarsitul fiecarei linii ce urmeaza a fi
continuata
-> daca sir_caractere lipsește, atunci textul specificat
prin nume_macro va fi eliminat din codul sursa
-> o constanta simbolica poate fi redefinita în cadrul aceluiași fișier
folosind încă o data directiva define:
#define nume_macro alta_sir_caractere

Reguli:
-> Valabilitatea unei definiri se încheie in următoarele cazuri:
• la sfârșitul fișierului sursa
• la invalidarea simbolului prin intermediul directive:
#undef nume_macro

Exemplu: #include <iostream>
#define PI 3.14159
int main()
{ cout << “PI este: ”<< PI << endl;
Tema: Ce se întâmplă la compilare?
#include <iostream>
#define PI
int main()
{ int PI = 2;
cout << “PI este: ”<< PI << endl;
. . . . . . . . . . . . . . . . . .

Tema: Sa se scrie codul dupa etapa de preprocesare:
#define DIM_VECTOR 20
#define TIP double
#define MESAJ "Calcul suma"
#define SEPARATOR cout
<< "----------------"
<< endl;
TIP suma(TIP v[], int n)
{ if (n > DIM_VECTOR)
cout << "dimensiunea este mai mare ca DIM_VECTOR" << endl;
TIP suma = 0;
for (int i = 0; i < n; i++)
suma += v[i];
return suma;
}
void main()
{ TIP v[DIM_VECTOR] = {1.1, 3.23, 6.62};
int n = 3;
cout << MESAJ;
SEPARATOR;
suma(v, 3);
}

#define Macrodefiniții
Sintaxa: #define macro(parametrii) text_corp
Descriere: secvențe de cod parametrizate care sunt înlocuite in textul
sursa
- Efectul  Macrodefinițiile sunt expandate in textul sursa înainte de
compilare in doua etape:
• apelul macrodefiniției din codul sursa este înlocuit cu
corpul acesteia
• parametrii macrodefiniției sunt înlocuiți cu valorile primite
ca parametrii
Obs.: parametrii sunt nume fara tip

Exemplu:
#define MAX(x,y) (x>y ? x : y)
int a = 7, b = 10, c;
c = MAX(a,b);
Înainte de verificarea sintactica, ultima linie este modificata la nivel de
text, ajungând:
c = (a>b ? a : b);

Obs.: Trebuie să avem grijă cum alcătuim macrodefiniția și cum o apelam,
pentru ca înlocuirea sa fie corecta, altfel eroare nu este semnalată.
Exemplu:
#define PATRAT(x) x*x;
int x = 2, y;
y = PATRAT(x+5) // Care este rezultatul ??

Obs.: Trebuie să avem grijă cum alcătuim macrodefiniția și cum o apelam,
pentru ca înlocuirea sa fie corecta, altfel eroare nu este semnalată.
Exemplu:
#define PATRAT(x) x*x;
int x = 2, y;
y = PATRAT(x+5) // Care este rezultatul ??
Macrodefiniția va fi expandată la textul:
y = x+5*x+5;
Care va fi evaluată, ținând cont de ordinea operațiilor:
y = 2+5*2+5 = 2+10+5 = 17 !!!!

In cadrul corpului macrodefinițiilor de pot utiliza operatori speciali:
#param nume -> convertește parametrul nume într-o constantă de
tip sir de caractere
Exemplu / Temă: Sa se scrie codul expandat și ce afișează codul
#define ATENTIONARE(EXPRESIE)
if (EXPRESIE)
cerr << "ATENTIE: "#EXPRESIE << endl;
int main()
{ int nc = 0; // = 10 ?
ATENTIONARE(nc == 0)
. . . . . . . . .

In cadrul corpului macrodefinițiilor de pot utiliza operatori speciali:
##param nume -> operator de concatenare pentru simboluri; permite
crearea de simboluri noi (nume de funcții sau de variabile) pe baza
parametrului nume
Exemplu:
#define FUNCTIE_SUMA(TIP)
TIP suma_##TIP(TIP vector[], int nrElem)
{TIP suma = 0;
for (int i = 0; i < nrElem; i++)
suma += vector[i];
return suma;
}
Se vor genera functiile suma_int si suma_double, folosind sintaxa
FUNCTIE_SUMA(int)
FUNCTIE_SUMA(double)

#if ... Compilare condiționată
Sintaxa: #if expresie_1
sectiune_1
#elif expresie_2
sectiune_2
. . . . . . . .
#else
sectiunie_n
#endif
 expresie_i este o expresie formata din constante sau simboluri
definite cu #define; expresia este considerata adevărată daca este
diferita de 0;
 părțile #elif si #else sunt opționale;
 sectiune_n reprezintă o secvență de cod de inclus in codul sursa
al programului in funcție de valoarea expresiei;

Exemplu:
#define DIM_VECTOR 21
int main()
{ int nc = 0;
#if defined DIM_VECTOR && DIM_VECTOR < 20
cout << "Suma vector " << DIM_VECTOR << " elemente";
#elif defined DIM_VECTOR && DIM_VECTOR < 30
cout << "Difer. vector " << DIM_VECTOR << " elemente";
#else
cout << "Vector prea mare" << endl;
return nc;
#endif
. . . . . . . . . . . . . . . .

In cadrul expresiilor se poate folosi cuvântul cheie defined pentru a
testa daca un anumit simbol de preprocesare a fost definit
(de exemplu: #if defined DIM_VECTOR ... ).
Daca se dorește doar testarea existentei unei constant simbolice se
pot folosi directivele:
#ifdef echivalentă cu #if defined
#ifndef echivalentă cu #if !defined

Cazuri de utilizare:
 Compilarea selective a unor porțiuni din codul sursa doar in pentru
versiunile de depanare:
int CalculSuma(int v[], int n)
{
#ifdef _DEBUG
cout << "Calcul suma pentru vector cu "
<< n << " elemente." << endl;
#endif
int suma = 0;
for (int i = 0; i < n; i++)
suma += v[i];
#ifdef _DEBUG
cout << "Suma este " << suma << endl;
#endif
return suma;
}

Compilarea selective a unor porțiuni din codul sursa doar in pentru
versiunile de depanare:
Similar:
#define _DEBUG 1 // 0 pentru veriune release
. . . . . .
#if _DEBUG
cout<<“Bloc inclus in Sesiune de depanare<<endl;
#endif //DEBUG

 Evitarea dublei incluziuni a fisierelor header:
#ifndef LISTE_H
#define LISTE_H
#include "C:ListeListe.h"
#endif //LISTE_H

Teme:
Explicati urmatoarele programe:
A. #define MKSTR( x ) #x
int main ()
{
cout << MKSTR(HELLO C++) << endl;
return 0;
}
B. #define concat(a, b) a ## b
int main()
{
int xy = 100;
cout << concat(x, y);
return 0;
}

Obs.: C++ oferă urmatoarele macrodefiniții predefinite:
Macro Descriere
__LINE__ Numarul liniei curente la momentul compilarii
__FILE__ Numele fisierului codului sursa la momentul compilarii
__DATE__ Conține sub forma de string month/day/year, data la care s-
a făcut translatarea de la cod sursa la cod obiect
__TIME__ Conține sub forma de string hour:minute:second ,
reprezentând ora la care s-a facut compilarea

Obs.: C++ oferă urmatoarele macrodefiniții predefinite:
int main ()
{
cout << "Value of __LINE__ : " << __LINE__ << endl;
cout << "Value of __FILE__ : " << __FILE__ << endl;
cout << "Value of __DATE__ : " << __DATE__ << endl;
cout << "Value of __TIME__ : " << __TIME__ << endl;
return 0;
}

namespace = Spații de nume
Un program folosește diverse nume (identificatori) asociate variabilelor,
funcțiilor, etc.
Problema: Odata cu creșterea complexității aplicațiilor, cu
administrarea distribuită a dezvoltării acestora (echipe de
dezvoltatori), a aparut problema posibilității de a se suprapune
(defini, folosi) aceleași nume definite in diverse module de catre
diverși membri ai echiupelor de dezvoltare => dorința de izola spațiile
de definiție/acces la numele proprii, definite de fiecare programator,
de elimina posibilitățile de utilizare incrucișată.
Soluția: utilizarea spațiilor de nume proprii, mecanismului de
protejare/ascundere a numelor definite de fiecare programator, sau
definite in biblioteci dezvoltate de altii și utilizate in aplicația proprie.

Definirea spațiilor de nume proprii:
namespace numeSpatiu
{ definiții nume_proprii_Spatiului
}
Apelarea numelui din afara spațiului de nume se face prin operatorul de
rezoluție:
numeSpatiu::nume_propriu_Spatiului
Obs.: Definirea unui spatiu de nume fara nume:
namespace
{ definiții nume_proprii_Spatiului
}
include toate numele definite acolo in spatial global

Includerea unui spațiu de nume (in intregime) in programul propriu =
toate numele spațiul de nume specificat sunt cunoscute, fără a mai
specifica spatiu de nume din care provin:
using namespace numeSpatiu
Se poate include un singur nume defint intr-un anumit spatiu de nume:
using numeSpatiu::nume_def_in_Spatiu

Exemple:
void main()
{ int a;
std::cin >> a;
std::cout << “a = “ << a << std::endl;
}
sau:
using namespace std;
void main()
{ int a;
cin >> a;
cout << “a = “ << a << endl;
}

Exemple:
#include <iostream>
int var = 98;
namespace Constante
{ const double PI = 3.14159;
const double E = 2.71828;
int var = 8;
double d = 72.9;
void TiparesteValori();
namespace Sp_Interior
{ int var = 2;
}
}
namespace
{ double d = 88.22;
}

Exemple:
#include <iostream>
int var = 98;
namespace Constante
{ const double PI = 3.14159;
const double E = 2.71828;
int var = 8;
double d = 72.9;
void TiparesteValori();
namespace Sp_Interior
{ int var = 2;
}
}
namespace
{ double d = 88.22;
}
int main()
{ cout << "d= " << d; //TEMA
cout << "n(global) var = " << var;
cout << "n PI = " << Constante::PI
<< "n E = "<< Constante::E
<< "n var = “ << Constante::var
<< "n Nume sp interior = "
<< Constante::Sp_Interior::var
<< endl;
Constante ::TiparesteValori();
return 0;
}
void Constante::TiparesteValori()
{ cout << "n In TiparesteValori():"
<< “n var = “ << var
<< "n PI = " << PI
<< "n E = “ << E
<< "n d = " << ::d //TEMA
<< "n (global) var = “ << ::var
<< "n Nume sp interior = "
<< Sp_Interior::var << endl;
}

baze c++sructura unui program declarare variabilepdf.

Recommended

Recommended

More Related Content

Similar to baze c++sructura unui program declarare variabilepdf.

Similar to baze c++sructura unui program declarare variabilepdf. (20)

baze c++sructura unui program declarare variabilepdf.