Cursul nr. 2 -...

10/5/2016

1

Cursul nr. 2

NOŢIUNI INTRODUCTIVE PENTRU LIMBAJELE

DE ROGRAMARE C/C++

ELEMENTE DE BAZA ALE LIMBAJELOR C/C++

Identificatori

Semne de punctuaţie şi caractere speciale

Spaţii albe

Structura programului C/C++

Directive de preprocesare

Primul program C/C++

Utilizarea comentariilor

Tipuri de date fundamentale

CONSTANTE

NOŢIUNI INTRODUCTIVE

Categorii de limbaje de programare:

Limbaje de nivel coborât, dependente de calculator.

Limbaj (cod) maşină - limbajul pe care computerul îl înţelege

în mod direct;

Limbaj de asamblare presupune existenţa unui program

numit assembler (asamblor) care să traducă programele în

limbaj maşină. Asamblorul înlocuieşte codarea mnemonică

(cum ar fi ADD) cu coduri binare corespunzătoare limbajului

maşină

• exemple: LOAD-0000, ADD-0001

Limbaje de nivel înalt, independente de calculator (exemple:

• Fortran (FORmula TRANslation) – 1955, IBM, pentru probleme

tehnico-ştiinţifice

• Cobol – 1959, pentru probleme economice

• Programarea structurată apare prin anii 70 (Pascal, C, etc)

• Programare orientată pe obiecte prin anii 80 (C++, Java, etc)

10/5/2016

2


Categorii de limbaje de programare:

Dupa modul de “traducere” limbajele de programare pot fi:

Limbaje compilate: C, C++, Pascal, Java;

Translatorul se numeşte compilator, iar mecanismul folosirii

unui astfel de limbaj este următorul: programul sursă este

tradus integral în limbajul maşină, iar rezultatul este un fişier

executabil

Limbaje interpretate: PHP, Javascript, Prolog, Matlab

Translatorul poartă denumirea de interpretor şi funcţionează în

felul următor: preia prima comandă din codul sursă, o traduce în

limbajul maşină şi o execută, apoi a doua comandă şi tot aşa.


Limbajul C - a fost dezvoltat la începutul anilor 1970 de Ken

Thompson şi Dennis Ritchie, odată cu scrierea nucleului

sistemului de operare UNIX. Limbajul C este un limbaj simplu şi

portabil. Este implementat pe marea majoritate a platformelor de

calcul existente azi şi este unul dintre cele mai populare limbaje

de programare.

Limbajul C++ - a fost dezvoltat la sfârşitul anilor ’80, odată cu

dezvoltarea tehnicii de programare orientată pe obiecte (OOP-

Object Oriented Programming); este construit pe baza limbajului

C completat cu facilităţi de creare şi utilizare a claselor.

10/5/2016

3


Limbajul C - a fost dezvoltat la începutul anilor 1970 de Ken

limbaj de nivel mediu, portabil, structurat, flexibil

produce programe eficiente ( lungimea codului scăzută,

viteză de execuţie mare )

set bogat de operatori multiple facilităţi de reprezentare şi

prelucrare a datelor

utilizare extensivă a apelurilor de funcţii şi a pointerilor

verificare mai scăzută a tipurilor - loose typing - spre

deosebire de PASCAL

permite programarea la nivel scăzut - low-level - , apropiat de

hardware

Este utilizat în multiple aplicaţii, în care nu predomină caracterul

numeric:

programe de sistem

proiectare asistată de calculator

grafică

prelucrare de imagini

aplicaţii de inteligenţă artificială.


Programele scrise în C/C++:

Sunt alcătuite din una sau mai multe funcţii (trebuie să conţină cel

puţin o funcţie şi aceasta să se numească main ).

Nu este permisă crearea şi declararea unei funcţii în interiorul altei

funcţii.

Folosind variabile locale, se pot scrie proceduri care să realizeze o

sarcină specifică şi care să nu cauzeze efecte secundare nedorite

în alte părţi ale codului.

Principalele etape parcurse pentru obţinerea unui program

executabil sunt:

10/5/2016

4


Un mediu de programare C conţine:

Un editor de text –folosit pentru creearea şi modificarea codului sursă C

Un compilator – pentru a converti programul C în cod înţeles de

calculator. Procesul de compilare cuprinde: �

• o fază de precompilare (macroprocesare) în care are loc

expandarea macrodefiniţiilor si compilarea condiţională si includerea

fisierelor

• compilarea propriu-zisă în urma careia se generează cod obiect

Compilarea din linia de comandă în GCC se face cu:

gcc –c prog.c prog.c→prog.o

Editor de legături –leagă la codul obiect anumite funcţii de bibliotecă

(de exemplu intrări/ieşiri) extrase dintr-o bibliotecă de funcţii, creindu-se

un program executabil.

gcc -o prog prog.o prog.o→prog.exe

Fişiere biblioteci de funcţii (.lib, .dll) – sunt fişiere de funcţii gata

compilatecare se adaugă (se leagă) la program. Există biblioteci pentru:

funcţii matematice, şiruri de caractere, intrări/ieşiri.

Fişiere antet (header files) – datele şi funcţiile conţinute în biblioteci

sunt declarate în fişiere antet asociate bibliotecilor.


Fişiere antet (header files) – datele şi funcţiile conţinute în biblioteci sunt

declarate în fişiere antet asociate bibliotecilor.

Prin includerea unui fişier antet compilatorul poate verifica corectitudinea

apelurilor de funcţii din biblioteca de funcţii asociată (fără ca aceste funcţii

să fie disponibile în momemtul compilării).

Un fişier antet este inclus printr-o directivă cu sintaxa: #include Aceasta

caută fişierul antet într-un director special de fişiere incluse (include).

#include “nume.h” Caută fişierul antet în directorul current.

#include <nume.h> Aceasta caută fişierul antet într-un director

special de fişiere incluse (include).

#include “nume.h” Caută fişierul antet în directorul current.

Bibliotecă Fişier antet

matematică math.h

Siruri de caractere string.h

Intrări/ieşiri stdio.h

10/5/2016

5


Depanarea programului (debugging) = localizarea şi

înlăturarea erorilor acestuia.

Erori de sintaxa – sunt semnalate la compilarea/link-

editarea programului

• Cele mai frecvente erori de sintaxă se referă la: lipsa

terminatorului de instrucţiune ;, neechilibrarea

parantezelor, neînchiderea şirurilor de caractere, etc.

• Erorile detectate de către editorul de legături sunt

referinţele nerezolvate (apelarea unor funcţii care nu au

fost definite, sau care se află în biblioteci care nu au fost

incluse).

Erori de logica – se detecteaza la executia programului, in

faza de testare


#include <stdio.h>

int main(int argc, char* argv[])

{

printf("Hello World!\n");

return 0;

}

- Directivă de

preprocesare - este inclus

fisierul “stdio.h” din care

este preluata functia de

afisare printf().

-Definitia

funcţiei

main() Antetul

functiei main()

Apelul unei functii

de afisare a unui

mesaj pe ecran Instructiunea return

încheie execuţia

funcţiei main şi

întoarce valoarea

Rezultatul executiei programului:

10/5/2016

6

Identificatori

Identificatorii sunt formaţi cu ajutorul caracterelor alfanumerice

şi liniuţa de subliniere (underscore), “_”.

Identificatorii denumesc tipuri de date, variabile, funcţii,

operatori, instrucţiuni etc.

Primul caracter al unui identificator nu poate fi o cifră.

Exemple:

Raza // valid

raza // valid

mesaj // valid

_maxx // valid

a5 // valid

5a // invalid, primul caracter este cifră

A_B_C // valid

A%B // invalid, caracterul % nu poate fi folosit într-un

// identificator arie cerc // invalid, spaţiul este separator, deci se iterpretează

// ca fiind doi identificatori: unul este arie, celălalt cerc

Identificatori

Cuvinte cheie ale limbajului C

auto break case char const continue

default do double else enum extern

float for if int long register

return short signed sizeof static struct

switch typedef union unsigned void volatile

while

10/5/2016

7

Identificatori

Cuvinte cheie ale limbajului C++

_asm asm auto break case _cdecl

cdecl char class const continue _cs

default delete do double _ds else

enum _es _export extern _far far

_fastcall float for friend goto _huge

huge if inline int _interrupt interrupt

_loadds long _near near new operator

_pascal pascal private protected public register

return _saveregs _seg short signed sizeof

_ss static struct switch template this

typedef union unsigned virtual void volatile

while

Semne de punctuaţie şi caractere speciale

Semne de punctuaţie şi caractere speciale constituie un set de

caractere cu diferite utilizări, care în funcţie de poziţia ocupată în textul

programului sursă pot determina acţiunile care vor fi executate.

[ ] ( ) { } * , : = ; ... #

Unele caractere pot desemna operatori (ca de exemplu [ ] * , =), altele

delimitează zone în alcătuirea codului sursă.

Spre exemplu, caracterul ; (punct şi virgulă) marchează sfârşitul unei

instrucţiuni, iar { şi } (paranteze acolade) marchează începutul şi

respectiv sfârşitul unui bloc de instrucţiuni.

Caracterul # însoţeşte numai directivele de preprocesare.

10/5/2016

8

Spaţii albe

Spaţiile albe sunt caractere speciale care, deşi nu sunt afişabile, produc

efecte în afişarea textului.

Aceste caractere sunt:

space (are valoarea 32 în codul ASCII)

tab (are valoarea 9 în codul ASCII)

newline (are valoarea 10 codul ASCII)

vertical-tab (are valoarea 11 în codul ASCII)

formfeed (are valoarea 12 în codul ASCII)

carriage-return (are valoarea 13 în codul ASCII)

Aceste caractere sunt interpretate ca separatori când sunt plasate între

entităţi diferite ale programului sau ca şi caractere dacă intră în

alcătuirea şirurilor de caractere.

Sunt situaţii în care aceste caractere se folosesc pentru a creşte

lizibilitatea programului sursă, caz în care ele vor fi ignorate de

compilator.

Spaţii albe

/ ******************************************************************************************

Se citesc de la tastatura 3 valori reale. Se determina maximul dintre cele 3 valori

*******************************************************************************************/

#include <stdio.h>

#include <conio.h>

void main(void)

{

double a, b, c, max;

puts("\nIntroduceti trei valori reale:");

scanf("%lf%lf%lf", &a, &b, &c);

if (a>b)

if (a>c)

max = a;

else

max = c;

else

if (b>c)

max = b;

else

max = c;

printf("\nmax = %lf", max);

getch();

}

10/5/2016

9

Spaţii albe

#include <stdio.h>

#include <conio.h>

void main(){double a,b,c,max;puts("\nIntroduceti trei valori reale:");

scanf("%lf%lf%lf",&a,&b,&c);if (a>b)if (a>c) max=a; else max=c;

else if (b>c) max=b;else max=c; printf("\nmax=%lf",max);getch(); }


Acţiunile efectuate de un program C/C++ se pot grupa respectând

algoritmul transpus, programul fiind structurat în module, fiecare având

un rol bine definit.

Fiecare acţiune este determinată de o instrucţiune.

O succesiune de instrucţiuni poate fi grupată într-un bloc numit funcţie.

Structura generală a unui program este :

I < directive de preprocesare >

II < declaraţii globale >

III definiţii de funcţii

Zonele I şi II sunt opţionale, dar cea de a III-a este obligatoriu să existe.

10/5/2016

10


Definiţia unei funcţii are următoarea structură:

<tip_r> nume_functie (< lista_parametri >)

{

<declaratii locale >

secventa de instructiuni

}

De retinut !

Funcţiile în C/C++ nu pot include definirea altor funcţii.


Exemple de definiţii de funcţii

1.

void functia_1(void)

{

printf(“Se executa functia 1”);

}

- funcţia nu preia

parametri şi nu

întoarce nici un

rezultat.

2.

void functia_2(int parametru)

{


printf(”\nparametru = %d”, parametru);

}

- funcţia preia un

parametru şi nu

întoarce nici un

rezultat.

3.

int functia_3(int parametru_1, int parametru_2)

{


return (parametru_1+ parametru_2);

}

- funcţia preia doi

parametri şi întoarce

un rezultat.

10/5/2016

11


Apelul (lansarea în execuţie) acestor funcţii se face astfel:

1. functia_1( ); - apelul funcţiei fără parametri.

2. functia_2(100); -apelul funcţiei cu un parametru;

valoarea preluată de parametru este 100.

3. functia_3(100, 500);

-apelul funcţiei cu doi parametri;

valorile preluate de parametri sunt 100 şi

respectiv 500; funcţia întoarce valoare,

600 (100+500), valoare ce poate fi

utilizată într-o expresie.


I. Zona

directivelor de

preprocesare

II. Zona

declaraţiilor

globale

III. Definiţii de

funcţii

#include <stdio.h>

#include <conio.h>

#define PI 3.1415

float aria(float);

float lungime(float);

int r = 5;

void main(void)

{

float raza, a, l;

printf("\nIntroduceti valoarea razei: ");

scanf("%f", &raza);

a = aria(raza);

l = lungime(raza);

printf("\nCercul are:");

printf("\nraza = %f ", raza);

printf("\naria = %f ", a);

printf("\nlungimea = %f", l);

printf("\nCercul are:");

printf("\nraza = %d ", r);

printf("\naria = %f ", aria(r));

printf("\nlungimea = %f", lungime(r));

getch();

}

Secvenţă de

instrucţiuni

float aria(float r)

{ float a;

a = PI * r * r;

return a;

}

float lungime(float r)

{ float l;

l = 2 * PI * r;

return l;

}

Declaraţii locale

funcţiei main()

10/5/2016

12


De retinut !

Programul sursă poate fi alcătuit din una sau mai multe funcţii.

Un program poate fi alcătuit din unul sau mai multe fişiere sursă

Fişierele sursă pot fi compilate separat, legăturile între acestea fiind

realizate în faza de link-editare pentru a genera un singur fişier

executabil.


Preprocesorul efectuează operaţii prealabile compilării, indicate de

directivele de preprocesare. Acestea sunt precedate de caracterul #.

Directiva # define - utilizată pentru a asocia un identificator cu un şir de

caractere. În etapa de precompilare fiecare apariţie a identificatorului va fi

înlocuită, caracter cu caracter, cu şirul corespunzător.

#define nume sir_de_caractere

#define TRUE 1

#define FALSE 0

#define NULL 0

#define MIN 10

#define MAX MIN+100

#define SQUARE(a) a*a

#define f(a, b) a+b

• permite folosirea constantelor simbolice în programe;

• uzual, dar nu obligatoriu, simbolurile sunt scrise cu litere mari;

• fiecare apariţie a simbolului este înlocuită, caracter cu caracter, cu valoarea sa.

10/5/2016

13


Directiva #include - determină includerea unui fişier sursă în alt fişier sursă.

#include < nume_fisier >

#include “ nume_fisier ”

#include <stdio.h> // fişierul e căutat în directorul predefinit

#include “c:\dir1\dir2\fis_meu1.h” // fişierul este căutat pe calea c:\dir1\dir2\

#include “fis_meu2.h” // fişierul este căutat în directorul curent

De retinut !

Directivele preprocesor încep cu simbolul #

Directivele preprocesor NU se termină cu ';'

În mod uzual, directivele preprocesor sunt scrise la începutul

fişierului sursă


La scrierea programelor sursă este util în numeroase situaţii să se

introducă anumite comentarii care să explice eventuale secvenţe de

instrucţiuni.

Comentariile sunt ignorate de compilator, putând conţine orice text, ele fiind

utile doar programatorului.

Comentariile se pot scrie astfel:

comentarii pe un rând – sunt precedate de caracterele //

comentarii pe mai multe rânduri – sunt marcate între caracterele /* şi */

10/5/2016

14


//exemplificarea utilizării comentariilor

/*

Acesta este un comentariu scris pe mai multe linii.

Comentariile sunt ignorate de compilator.

*/

#include <stdio.h>

int main()

{

// comentariu pe o linie

printf("Salut !\n");

printf("Salut !\n");

return 0; // instrucţiunea return încheie execuţia unei funcţii

printf("Salut !\n"); /* aceasta linie nu se va executa

deoarece se afla după

instrucţiunea return */

}


Tipul unei date determină

dimensiunea zonei de memorie ocupată;

valorile pe care le poate lua.

Tipurile datelor se pot grupa în:

tipuri fundamentale;

tipuri derivate;

tipuri definite de utilizator

10/5/2016

15


Tipurile de date fundamentale cuprind:

tipurile aritmetice de bază

tipul void.

Există patru tipuri aritmetice de bază, specificate prin cuvintele cheie:

char

int

float

double

Gama de valori poate fi extinsă prin modificatori de tip desemnaţi prin

cuvintele cheie:

signed

unsigned

short

long

Tipul fundamental void indică absenţa oricărei valori şi se utilizează în

următoarele situaţii: declaraţia unei funcţii fără parametri sau care nu

returnează un rezultat, tipul pointer generic şi conversii de tip cu

operatorul cast pentru pointeri.


Tipuri de date întregi

Tip Spaţiu de

memorie ocupat

Domeniu de valori

char = signed char 8 biţi -128 … 127

unsigned char 8 biţi 0 … 255

int = signed int = short int =

signed short int

16 biţi /

32 biţi

-32768…32767 /

-2147483648…2147483647

unsigned int =

unsigned short int

16 biţi /

32 biţi

0…65535/

0…4294967295

long int = signed long int 32 biţi -2147483648…2147483647

unsigned long int 32 biţi 0…4294967295

10/5/2016

16


Tipuri de date în virgulă mobilă

Tip Spaţiu de memorie

ocupat

Domeniu de valori

float 32 biţi +/-(3.4E-38…3.4E+38)

precizie 7 cifre

double 64 biţi +/-(1.7E-308…1.7E+308)

precizie 15 cifre

long double 80 biţi +/-(3.4E-4932…1.1E+4932)

precizie 19 cifre


Se poate determina numărul de octeţi utilizaţi în reprezentarea unei date

folosindu-se operatorul sizeof.

Sintaxa de utilizare a acestui operator este:

sizeof ( nume_tip_data )

Exemple:

sizeof (long int); // expresia returnează valoarea 4

sizeof (unsigned char); // expresia returnează valoarea 1

sizeof (long double); // expresia returnează valoarea 10

10/5/2016

17

CONSTANTE

Constantele sunt valori fixe (numerice, caractere sau şiruri de

caractere), care nu pot fi modificate în timpul execuţiei programului.

Constantele pot fi precizate prin:

constante literale (scrise caracter cu caracter, de exemplu

constanta 1230

constante cu nume (de exemplu folosind directiva #define).

Constantele pot fi:

numerice;

caractere;

şiruri de caractere.

Constantele numerice sunt reprezentate conform tipurilor de date

fundamentale, fie ca valori numerice întregi, fie ca valori reale cu

reprezentare în virgulă mobilă

CONSTANTE

Constante numerice întregi

Constante zecimale (baza 10)

Constante octale (baza 8)

Constante hexazecimale (baza 16)

Constante zecimale (baza 10)

23 // tip int

+123 // tip int

-123 // tip int

-555L // tip long int

23u // tip unsigned int

32768U // tip unsigned int

77UL // tip unsigned long int

2147483648 // tip double; reprezintă o valoare numerică

// întreagă, dar depăşeşte domeniul de valori

// long int

10/5/2016

18

CONSTANTE

Constante octale (baza 8)

-067 // tip int

067u // tip unsigned int

020000000 // tip long int

055ul // tip unsigned long

089 // eroare, prima cifră indică reprezentarea în

// octal şi numărul include cifrele 8 şi 9

Constante hexazecimale (baza 16)

0x7FFF // tip int

0X8A0L // tip long int

0xffu // tip unsigned int

0xFFul // tip unsigned long int

0xFFFFFFFFu // tip unsigned long int

CONSTANTE

Constante în virgulă mobilă – conţin următoarele câmpuri:

parte întreagă

punct zecimal

parte fracţionară

e sau E şi un exponent cu semn (opţional)

sufix de specificare a tipului: f sau F (forţează tipul float) sau l

sau L (forţează tipul long double)

Exemple:

2.1 // valoare 2,1 (tip double)

11.22E5 // valoare 11,22 x 105 (tip double)

-.33e-2 // valoare –0,33 x 10-2 (tip double)

.5 // valoare 0,5 (tip double)

1. // valoare 1 (tip double)

1.f // valoare 1 (tip float)

0.L // valoare 0 (tip long double)

10/5/2016

19

CONSTANTE

Constante caracter - sunt reprezentate de unul sau mai multe caractere

încadrate de apostrofuri, de exemplu: ‘a’, ’A’, ’\n’ şi sunt de tip char.

Pentru a specifica o serie de caractere neafişabile precum şi delimitatorii (‘), (“),

caracterul (\), etc. se utilizează aşa numitele secvenţele escape (secvenţe de

evitare)

Secvenţă Valoare (hexa) Caracter Descriere

\a 0x07 alarm (bell) semnal sonor

\b 0x08 BS backspace

\t 0x09 TAB tab orizontal

\n 0x0A LF linefeed

\v 0x0B VT tab vertical

\f 0x0C FF formfeed

\r 0x0D CR carriage return

\” 0x22 ” ghilimele

\’ 0x27 ’ apostrof

\? 0x3F ? semnul întrebării

\\ 0x5C \ backslash

\o - orice caracter şir de cifre octale

\xH - orice caracter şir de cifre hexazecimale

CONSTANTE

#include <stdio.h>

#include <conio.h>

void main()

{

putch(’?’); // se afişează caracterul ‘?’

putch(63); // se afişează caracterul ‘?’ , 63 fiind valoarea

// corespunzătoare în codul ASCII

printf(“\n%c”,’\077’); // se afişează caracterul ‘?’

printf(“\n%c”,’\x3F’); // se afişează caracterul ‘?’

}

10/5/2016

20

CONSTANTE

Constante şir de caractere

Constantele şiruri de caractere sunt alcătuite dintr-un număr

oarecare de caractere, încadrate între ghilimele.

Şirurile de caractere se memorează în tablouri de tipul char, cu

dimensiune egală cu numărul de caractere cuprinse între ghilimele,

la care se adaugă caracterul ‘\0’ care are valoarea 0 în codul ASCII

şi se numeşte terminator de şir.

Alocarea în memorie a unui şir de caractere constant:

Exemple: “\tMesaj 1\n\n\tMesaj 2”

“Programare” “orientata pe”

”obiecte”

Cursul nr. 2 -...

Documents

Transcript of Cursul nr. 2 -...