Lab2 (1)

Laboratorul nr. 2

Elemente de baz ale limbajului Identificatori

Identificatorii limbajului C++, ca i n limbajul C standard, sunt formai cu ajutorul literelor, majuscule i minuscule i liniua de subliniere (underscore), _. Primul caracter al unui identificator nu poate fi o cifr. Se face deosebire ntre litere mari i litere mici (limbajul este case-sensitive). De exemplu:

Raza // valid mesaj // valid Mesaj // valid, diferit de numele anterior, mesaj _maxx // valid a5 // valid 5a // invalid

Din mulimea identificatorilor posibili, se remarc cuvintele cheie (reserved keywords) ale

limbajului, identificatori a cror semnificaie nu poate fi modificat de programator, ea fiind predefinit i repreyentnd nume de tipuri de date, instruciuni, etc. Acestea sunt prezentate n Tabelul nr. 1.

Tabelul nr. 1. Cuvinte cheie ale limbajului

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 Observaie: Cuvintele cheie din tabel care ncep cu semnul underscor reprezint variabile interne.

Pag. 1/13

Programare C/C++ - Laborator nr. 2

Tipuri de date fundamentale

Tipul unei date determin dimensiunea zonei de memorie ocupate i valorile pe care le poate lua. Tipurile datelor se pot grupa n tipuri fundamentale i tipuri derivate. Tipurile de date fundamentale cuprind tipurile aritmetice de baz i tipul void. Exist patru tipuri aritmetice de baz, specificate prin cuvintele cheie: char, int, float i double.

Gama de valori poate fi extins prin modificatori de tip desemnai prin cuvintele cheie: signed, unsigned, short, long. Tipurile ntregi ce se obin prin combinarea tipurilor de baz cu modificatorii de tip sunt prezentate n Tabelul nr. 2, iar cele reprezentate n virgul mobil n Tabelul nr. 3. Observaie: Modul de memorare al acestor tipuri de date depinde de varianta de implementare a

limbajului C/C++. De exemplu, tipul int este reprezentat pe 2 byte n unele versiuni i pe 4 byte n altele.

Tabelul nr. 2. Tipuri de date ntregi

Tip Spaiu de memorie ocupat Domeniu de valori

char = signed char 8 bii -128127

unsigned char 8 bii 0255

int = signed int = short int = signed short int 16 bii -3276832767

unsigned int = unsigned short int 16 bii 065535

long int = signed long int 32 bii -21474836482147483647

unsigned long int 32 bii 04294967295

Tabelul nr. 3. Tipuri de date n virgul mobil

Tip Spaiu de memorie ocupat Domeniu de valori

float 32 bii +/-(3.4E-383.4E+38) precizie 7 cifre

double 64 bii +/-(1.7E-3081.7E+308) precizie 15 cifre

long double 80 bii +/-(3.4E-49321.1E4932) precizie 19 cifre

Tipul fundamental void indic absena oricrei valori i se utilizeaz n urmtoarele situaii: declaraia unei funcii fr parametri sau care nu returneaz un rezultat, tipul pointer generic i conversii de tip cu operatorul cast pentru pointeri.

Iat cteva exemple de expresii care returneaz ca valoare spaiul de memorie ocupat de date de diferite tipuri:

sizeof (long int); // expresia returneaz valoarea 4 sizeof (unsigned char); // expresia returneaz valoarea 1 sizeof (double); // expresia returneaz valoarea 8

Pag. 2/13


Constante Constantele sunt valori fixe (numerice, caractere sau iruri de caractere), care nu pot fi modificate

n timpul execuiei programului. Tipul constantei este determinat de compilator pe baza valorii i sintaxei utilizate. Ele rmn n memorie pe toat durata execuiei programului.

Constante ntregi Tipul constantei este determinat pe baza valorii, sau prin utilizarea unui sufix (U sau u pentru

unsigned, respectiv L sau l pentru long). Constantele ntregi pot fi zecimale, octale sau hexazecimale.

Constante zecimale (baza 10)

Constantele zecimale se disting prin faptul c prima cifr este diferit de 0, cum ar fi:

23 // tip int 23u // tip unsigned int 32768 // tip long int 77UL // tip unsigned long int

Constante octale (baza 8)

Constantele octale sunt valori avnd prima cifr 0. Cifrele 8 i 9 sunt ilegale.

-067 // tip int 067u // tip unsigned int 020000000 // tip long int 055ul // tip unsigned long 089 // eroare, prima cifr indic reprezentarea n octal i numrul // include cifrele 8 i 9

Constante hexazecimale (baza 16)

Constantele hexazecimale se disting prin prefixul 0x sau 0X. Pot conine cifre mai mari de 9 (af, sau AF).

0x7FFF // tip int 0X8000 // tip unsigned int 0xffu // tip unsigned int 0x10000 // tip long int 0xFFul // tip unsigned long int

Constante n virgul mobil

Constantele n virgul mobil sunt valori raionale a cror reprezentare conine n general urmtoarele cmpuri:

Pag. 3/13


parte ntreag punct zecimal parte fracionar e sau E i un exponent cu semn (opional) sufix de specificare a tipului: f sau F (foreaz tipul float) sau l sau L (foreaz tipul long

double). Se pot omite partea ntreag sau partea fracionar (dar nu amndou), punctul zecimal sau litera e

(E) i exponentul (dar nu amndou). Tipul implicit pentru constantele n virgul mobil este tipul double.

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)

Constante caracter

Constantele caracter sunt reprezentate de unul sau mai multe caractere ncadrate de apostrofuri, de exemplu: a,A,\n i ele sunt de tip char.

Pentru a specifica o serie de caractere neafiabile, delimitatorii (), (), caracterul (\), etc. se utilizeaz secvenele escape (secvene de evitare) (vezi Tabelul nr. 4).

Tabelul nr. 4. Secvene escape

Secven Caracter Descriere \a alarm (bell) sun alarma (bip)

\b BS backspace

\f FF form feed

\n LF line eed

\r CR carrige return

\t TAB tab orizontal

\v VT tab vertical

\\ \ back slash

\ apostrof

\ ghilimele

\? ? semnul ntrebrii

\o orice caracter ir de cifre octale

\xH orice caracter ir de cifre hexazecimale Exemple de utilizare a constantelor caracter:

Pag. 4/13


#include void main() { putchar('?'); // se afieaz caracterul '?' putchar(63); // se afieaz caracterul '?', 63 este valoarea corespunztoare n codul ASCII putchar('\077'); // se afieaz caracterul '?', valoare este reprezentat n octal putchar('\x3F'); // se afieaz caracterul '?', valoarea este reprezentat n hexazecimal }

Constante iruri de caractere

Constantele iruri de caractere sunt alctuite dintr-un numr oarecare de caractere, ncadrate ntre ghilimele.

irurile de caractere se memoreaz n tablouri de tipul char, cu dimensiune egal cu numrul de caractere cuprinse ntre ghilimele, la care se adaug terminatorul de ir \0.

Exemplu de constanta sir de caractere

Caracterele ce alctuiesc irul pot fi secvene escape:

\tMesaj 1\n\tMesaj 2 irurile constante adiacente se concateneaz i formeaz un singur ir:

Programare orientata pe obiecte

Pentru scrierea irurilor lungi se poate utiliza simbolul (\) care semnaleaz continuarea irului pe

rndul urmtor:

Exemplu de sir \ scris pe doua randuri

Structura unui program C/C++ Un program n C/C++ este o colecie de funcii. Structura general a unui program este: I < directive de preprocesare > II < declaraii globale > III definiii de funcii Un program n C/C++ conine cel puin o funcie, aceasta purtnd numele main. Cu aceasta ncepe

execuia programului.

Pag. 5/13


Directive de preprocesare Preprocesorul efectueaz operaii prealabile compilrii, indicate de directivele de preprocesare.

Acestea sunt precedate de caracterul #.

Directiva # define Directiva define este utilizat pentru a asocia un identificator cu un ir de caractere. n etapa de

precompilare fiecare apariie a identificatorului va fi nlocuit, caracter cu caracter, cu irul corespunztor. Forma general de utilizare a directivei define este:

#define nume sir de caractere

Exemple de defininiii:

#define TRUE 1 #define FALSE 0 #define NULL 0 #define MIN 10 #define MAX MIN+100 #define f(a,b) a+b Directiva preprocesor ncepe cu simbolul # i nu este terminata cu ';'. In mod uzual directivele

preprocesor sunt scrise la nceputul fiierului surs.

Observaii: Directiva #define : permite folosirea constantelor simbolice n programe uzual, dar nu obligatoriu, simbolurile sunt scrise cu litere mari nu se termin cu ';' apar n general la nceputul unui fiier surs fiecare apariie a simbolului este nlocuit de valoarea sa

Directiva #include

Directiva de preprocesare #include determin includerea unui fiier surs n alt fiier surs. Sintaxa

de utilizare are una din formele:

#include < nume_fisier >

#include nume_fisier

Pentru prima variant, fiierul va fi cutat ntr-un director predefinit care conine fiiere header puse la dispoziie de mediul de programare, cea de a doua va cuta fiierul pe calea specificat n numele fiierului. Dac nu e precizat calea fiierului, va fi cutat n directorul curent.

Pag. 6/13


Exemple: #include // fiierul e cutat n directorul predefinit #include c:\dir1\dir2\fis_meu1.h // fiierul este cutat pe calea c:\dir1\dir2\ #include fis_meu2.h // fiierul este cutat n directorul curent

Definiii de funcii

Sintaxa definiiei unei funcii este:

tip_rez nume_funcie ()

{ declaraii locale secven de instruciuni

} unde: tip_rez este un tip oarecare de dat i reprezint tipul rezultatului returnat de

funcie. Dac nu este specificat, implicit tipul rezultatului returnat este int. Pentru funciile care nu returneaz rezultat trebuie s se specifice tipul void.

nume_functie este un identificator. lista_parametri reprezint enumerarea declaraiilor parametrilor sub forma:

tip_parametru nume_parametru,

Observaii: Tipul parametrului poate fi orice tip valid de date. Nu este admis definirea unei funcii n blocul altei funcii i nu sunt permise salturi cu instruciunea goto n afara funciei.

Apelul funciei const din numele funciei urmat de lista de constante, variabile sau expresii asociate parametrilor ncadrat ntre paranteze ().

Att la definirea, ct i la apelul funciilor, parantezele () urmeaz ntotdeauna numele funciilor, chiar dac acestea nu au parametri.

Se folosete denumirea de parametri formali pentru identificatorii din lista de argumente din definiia funciei i parametri efectivi constantele, variabilele, expresiile din lista unui apel al funciei.

Parametrii formali reprezint variabile locale care au domeniu funcia i timpul de via corespunde duratei de execuie a funciei, deci valorile lor se memoreaz n stiv sau n registrele procesorului.

/* ----- Exemplificare privind structura unui program ---- Sa se intocmeasca un program in care se definesc trei functii pentru calculul patratului unui real, aria unui cerc, lungimea unui cerc. In functia main se exemplifica apelul acestor functii. */ // directive de preprocesare #include #include #define PI 3.14

Pag. 7/13


// declaratii globale float arie_cerc(float); // prototipul functiei arie_cerc() float lungime_cerc(float); float patrat(float); // definitii de functii void main(void) { // declaratii locale float raza; // instructiuni printf("\nIntroduceti raza:"); scanf("%f",&raza); printf("\nPatratul razei este: %f\n",patrat(raza)); printf("Aria cercului cu raza %f este %f\n", raza, arie_cerc(raza)); // apel al functiei arie_cerc printf("Lungimea cercului cu raza %f este %f\n", raza, lungime_cerc(raza)); } float patrat(float x) // definitia functiei patrat() { return x*x; } float arie_cerc(float r) // definitia functiei arie_cerc() { float arie; arie = PI * patrat(r); return arie; } float lungime_cerc(float r) // definitia functiei lungime_cerc() { float lungime; lungime = 2 * PI * r; return lungime; }

Exercitiu: S se ntocmeasc un program n care se definete o funcie pentru calculul ariei unui

triunghi pentru care se cunosc laturile. n funcia main() se determin i se afieaz valorile ariilor unor triunghiuri. Calculul ariilor se va face att cu valori constante, ct i cu valori citite de la tastatur.

Pag. 8/13


Variabile Toate variabilele trebuie declarate nainte de a fi folosite. Declaraia unei variabile (obiect) precizeaz numele (identificatorul) cu care va fi referit, cruia i

sunt asociate o serie de atribute, cum ar fi: tipul datei - poate fi tip fundamental sau definit de utilizator i determin structura, gama

de valori, dimensiunea spaiului ocupat n memorie; clasa de memorare - stabilete zona de memorie n care se va plasa informaia asociat

identificatorului (segment de date, registru, stiv, heap) i delimiteaz durata sa de alocare; domeniul - reprezint poriunea de program n care poate fi accesat informaia asociat

identificatorului, el fiind determinat de poziia declaraiei; durata de via - a identificatorului reprezint perioada ct exist efectiv n memorie i

este corelat cu clasa de memorie; legtura - precizeaz modul de asociere a unui identificator cu un anumit obiect sau

funcie, n procesul de editare a legturilor. Atributele se pot asocia identificatorilor n mod implicit, n funcie de poziia i sintaxa declaraiei

sau explicit prin utilizarea unor specificatori. Sintaxa declarrii de variabile impune specificarea tipului, avnd forma general:

tip_var nume_var; // - se declar o variabil sau

tip_var nume_var = valoare_initiala; // - se declar o variabil cu inializare sau

tip_var nume_var_1, nume_var_2,..., nume_var_n; // - se declar mai multe variabile // de acelai tip

unde tip_var este un specificator de tip de date oarecare, standard, pointer sau definit de utilizator. Exemple de declarare de variabile: float * r; // declararea variabilei r de tip pointer la float, unsigned int n; // declararea variabilei n de tip unsigned int double real=2.5; // declararea variabilei real de tip double, iniializat cu valoarea 2.5 char c1, c2=a, ch; // declararea a trei variabile de tip char, c1, c2 i ch, variabila c2 // fiind iniializat cu valoarea a

Poziia declaraiei determin cele dou domenii de existen fundamentale:

Domeniul bloc (local) - Identificatorii cu domeniu bloc se numesc locali i sunt rezultatul unor declaraii n interiorul unui bloc (au domeniul cuprins ntre declaraie i sfritul blocului) sau sunt parametrii formali din definiia unei funcii (au ca domeniu blocul funciei).

Domeniul fiier (global) - Identificatorii cu domeniu fiier se numesc globali i sunt declarai n afara oricror funcii (domeniul este cuprins ntre declaraie i sfritul fiierului).

Clasa de memorare se poate preciza prin specificatorii auto, static, extern, register. Aceti

specificatori precizeaz modul de alocare a memoriei i timpul de via pentru variabile i legtur pentru funcii i variabile.

Pag. 9/13


/* Exemplificarea atributelor variabilelor: - clasa de memorare - domeniu - durata de viata *************************************************************************/ #include #include int a=5; /* variabila globala - alocata in segmentul de date - durata de viata - executia programului - domeniu: fisier */ void f1(void) { printf("\na=%d",a); } void f2(void) { int a=7; /* variabila locala - alocata pe stiva - durata de viata - executia functiei - domeniu: functia */ printf("\na=%d", a); } void main() { int b=10, c=20; printf("\na=%d, b=%d, c=%d", a, b, c); { int b=100, d=1000; /* variabile locale - alocate pe stiva - durata de viata-executia blocului de instructiuni - domeniu: blocul de instructiuni */ printf("\na=%d, b=%d, c=%d, d=%d", a, b, c, d); } printf("\na=%d, b=%d, c=%d",a, b, c); // printf("\na=%d, b=%d, c=%d, d=%d", a, b, c, d); - eroare, variabila d nu mai exista !! puts("\nSe va executa functia f1"); f1(); puts("\nSe va executa functia f2");

Pag. 10/13


f2(); } Declaraia static a unei variabile locale foreaz durata static fr a modifica domeniul de

existen. Variabilele statice sunt alocate n segmentul de date, rmn alocate pe tot parcursul execuiei programului, dar domeniul de utilizare al lor este doar blocul n care au fost declarate. Ele sunt iniializate la alocarea n memorie, nu la fiecare execuie a blocului. i pstreaz valoarea ntre dou apeluri succesive ale blocurilor care le conin, asigurndu-se n acelai timp o protecie, dar ele nu pot s fie accesate din blocuri care nu constituie domeniul lor de existen. Variabilele statice pot fi declarate cu iniializare, n caz contrar, implicit se iniializeaz cu valoarea 0, similar variabilelor globale.

#include int fct() { static int a=2; // se declar o variabil local funciei, cu alocare static return (a++); } void main(void) { int n; n=fct(); printf (\n Prima atribuire : n= %d, n); n=fct(); printf (\n A doua atribuire : n= %d, n); }

Programul afieaz:

Prima atribuire : n= 3 // la primul apel al funciei, variabila a are valoarea // iniial 2, ea fiind apoi incrementat A doua atribuire : n= 4 // la al doilea apel al funciei, variabila a are la nceput // valoarea 3 (valoare datorat apelului anterior al // funciei), valoarea fiind apoi incrementat

Observaie: Se pot declara variabilele const. Acestea nu pot fi modificate pe parcursul execuiei unui program, ele trebuind s fie iniializate n momentul declarrii. Instruciunile care ncearc modificarea variabilelor const genereaz erori la compilare.

const int a=99; // declaraia variabilei a const a = a+1; // eroare, a este const a+=5; // eroare, a este const

Pag. 11/13


Operaii de intrare/ieire pentru consol Operaii la nivel de caracter

Funcii pentru operaii de citire caracter:

int getch (void); // definit n conio.h int getche (void); // definit n conio.h int getchar (void); // definit n stdio.h

Funcii pentru operaii de afiare caracter: int putch (int); // definit n conio.h int putchar (int); // definit n stdio.h

Exemplu:

/* Functii intrare - iesire pentru caractere */ /* Sa se intocmeasca un program in care: -se declara 3 variabile de tip char sau int -se citesc valori pentru cele trei variabile cu functiile getch(), getche(), respectiv getchar() -se afiseaza continutul variabilelor folosind functiile putch() sau putchar() Obs. Se vor afisa mesaje care sa ajute la intelegerea desfasurarii programului. *******************************************************************************/ #include #include void main(void) { char c1,c2,c3; // declaratii de variabile puts("Introdu un caracter:"); c1=getch(); puts("\ncaracterul tastat este:"); putch(c1); puts("\nIntrodu un caracter:"); c2=getche(); puts("\ncaracterul tastat este:"); putch(c2); puts("\nIntrodu un caracter:"); c3=getchar();

Pag. 12/13


puts("\ncaracterul tastat este:"); putch(c3); putch('\n'); }

Operaii cu iruri de caracter

Operaii de citire iruri de caractere:

char* gets (char *); // definit n stdio.h

Operaii de afiare iruri de caractere: int puts (char *); // definit n stdio.h

Exemplu:

/* ----- Functii intrare - iesire pentru siruri de caractere ----- */ /*Sa se intocmeasca un program in care: -se declara 2 siruri de caractere cu initializare -se afiseaza continutul sirurilor cu functia puts -se citesc valori pentru cele doua siruri cu functia gets() -se afiseaza din nou continutul folosind functia puts Obs. Se vor afisa mesaje care sa ajute la intelegerea desfasurarii programului. *****************************************************************************/ #include void main(void) { char sir1[30]="primul sir"; char sir2[30]="al doilea sir"; puts("sir1:"); puts(sir1); puts("sir2:"); puts(sir2); puts("\nIntrodu un sir de caractere:"); gets(sir1); puts("\nIntrodu un sir de caractere:"); gets(sir2); puts("sir1:"); puts(sir1); puts("sir2:"); puts(sir2); }

Pag. 13/13

Lab2 (1)

Documents

Transcript of Lab2 (1)