Limbajul c si C++ abc-doar

main,dar nu sunt obligatorii.

La redactarea liniilor de comanda se vor respecta urmatoarele reguli:

-argumentele sunt delimitate prin spatii goale (spatiu sau tab)

-sirurile dintre ghilimele se interpreteaza ca argument unic(token) chiar

daca contin si spatii goale si pot fi incluse in interiorul unui argument

-un sir cuprins intre ghilimele si precedat de \" este interpretat ca sir

de citatie literala.

-liniutele de demarcatie \ neurmate de ghilimele,se interpreteaza literal

-daca un numar par de liniute de separatie(\) este urmat de ghilimele,

atunci una dintre liniute va trece in argumentul ariei,pentru fiecare

pereche de liniute \\ iar ghilimelele vor fi interpretate ca delimitator

de sir.

-daca un numar impar de liniute de separatie este urmat de un semn de

ghilimele,atunci una dintre liniute va trece in argumenul ariei pentru

fiecare pereche de liniute(\\) iar semnul de ghilimele va fi interpretat

ca secventa de iesire din citat si car rezultat va fi inclus si el in

argumentul ariei respective.


-23-

Regulile enuntate sunt exemplificate in tabelul de mai jos:

Linia de comanda argument1 argument2 argument3

======================================================================

"a b c" d e a b c d e

----------------------------------------------------------------------

"ab\"c" "\\" d ab"c \ d

----------------------------------------------------------------------

a\\\b d"e f"g h a\\\b de fg h

----------------------------------------------------------------------

a\\\"b c d a\"b c d

----------------------------------------------------------------------

a\\\\"b c" d e a\\b c d e

----------------------------------------------------------------------

Aceste reguli au o importanta deosebita in editarea comenzilor,deoarece

absenta unui singur spatiu gol din comanda poate duce la citirea eronata

a intregii comenzi.Verificati cu atentie fiecare linie de comanda.
Intr-un program C variabilele si functiile se caracterizeaza in functie

de durata de existenta,spatiul in care actioneaza si modul in care sunt

legate.

Durata de existenta este determinata de identificatorul(modificatorul)

de arhivare.Cele declarate static,sunt globale si durata lor de existenta

este egala cu cea de executie a programului(cu valoare fixa).Cele decla-

rate automatic,au durata de existenta limitata la durata de executie a

a blocului de comenzi in care sunt continute.

Functiile o data declarate,au durata de viata pe toata durata de exe-

cutie a programului,dar argumentele functiei au durata de existenta limi-

tata la perioada de executie a functiei (daca nu sunt specificati explicit

prin static).

Spatiul sau "vizibilitatea" se refera la portiunea din program in care

pot fi apelate si este determinat prin identificatorul scope,care poate fi

function,file,block sau function prototipe si respectiv restrictioneaza

apelarea variabilei la o anumita functie,fila,bloc de functii sau la un

prototip de functie.Functiile declarate static sunt "vizibile" doar in

cadrul filei sursa,celelalte functii sunt globale.

Atunci cand un identificator este apelat din puncte diferite ale pro-

gramului,executia se intrerupe si controlul trebuie sa faca un salt la

adresa de memorie in care este arhivat identificatorul respectiv,sa preia

informatia si apoi sa revina la pozitia initiala.Aceste salturi poarta

numele de legare(linkage) si sunt reglementate prin trei tipuri de linker:

internal,external si no linkage.Valoarea implicita este external si per-

mite apelarea din orice punct al programului(inclusiv din file diferite).

Internal limiteaza apelarea la fila sursa respectiva,iar no linkage nu

permite apelarea din exteriorul functiei.

Pentru a simplifica munca programatorului,dar si cea a programului de

compilare,programul poate fi fragmentat in arii de memorie identificate

prin nume propriu (Name spaces).Acest fapt are semnificatie mai ales

pentru programele mari (greu de depanat).Astfel,in cadrul aceleiasi arii

de memorie,toti identificatorii trebuie sa poarte nume distincte pentru

a nu genera conflicte,dar in arii de memorie diferte,pot exista date(chiar

si tipuri diferite de date) care au acelasi identificator(nume) fara sa

genereze conflicte de compilare.

-24-

In limbajul C exista urmatoarele tipuri de spatii denumite:

1.Eticheta comezii(TAG):-face parte din comanda,urmeaza intotdeauna dupa

cuvantul cheie goto.Nu este necesar sa fie unice.

2.Structuri,uniuni,enumerari:-urmeaza intotdeuna dupa struc,union sau

enum si fac parte din specificatorul de tip de date.

3.Membri ai structurilor si uniunilor:-denumirile trebuie sa fie unice in

cadrul structurii sau uniunii respective dar nu trebuie sa fie unice

pentru intregul program.

4.Identificatori ordinari(date):-au vizibilitate limitata,asa ca pot fi

utilizati cu acelasi nume,dar in structuri diferite.

EXEMPLU: struct student {

char student[20];

int class;

int id;

} student;

identificatorul "student" apare ca nume al unei structuri,ca membru al

sau si ca variabila,fara sa genereze conflict de interpretare.
DECLARATII SI TIPURI DE DATE
O declaratie cuprinde atributele si interpretarea unui set de identi-

ficatori(constante,variabile functii etc.).Atunci cand o declaratie deter-

mina si arhivarea de date in cadrul unui obiect sa a unei functii,poarta

numele de definitie.

O declaratie contine numele identificatorilor,specificatorii pentru

tipul de date asupra carora actioneaza si lista de atribute optionale.

EXEMPLU: int const *fp

-declara variabila denumita fp ca si pointer nemodificabil(const) cu

valoare intreaga (int).

Daca se declara mai mult decat un singur element,se va utiliza o lista in

care elementele sunt separate prin virgula.

Un identificator poate fi modificat prin paranteze drepte [] pentru a

declara o arie,prin asterix * pentru a declara un pointer sau prin paran-

teze pentru a declara o functie.

Un element poate fi redeclarat de mai multe ori,dar nu poate fi definit

decat o singura data(definitia poate totusi sa apara pe file diferite ale

programului).

Daca nu se specifica tipul datelor,se va considera valoarea implicita,care

este int.

Specificatorii de arhivare a functiilor si variabilelor declarate sunt

urmatorii: auto,register,static,extern,typedef si __declspec si determina

daca variabilele au durata de viata limitata sau globala.

TIPURI DE DATE:-exista cinci tipuri fundamentale de date; char(date de tip

caracter),int(numere intregi),float(numere reale in virgula mobila),double

(numere reale in virgula mobila cu dubla precizie adica 10E+308 zecimale)

si void(date nule-nu au asociata nici un fel de valoare).

Tipurile fundamentale de date pot fi modificate prin modificatorii:signed,

unsigned,long si short pentru a forma tipurile de date;unsigned char,

signed char,short int,long int,signed short int,unsigned long int etc.

Modificatorii determina lungimea spatiului de memorie rezervat pentru

datele din tipul respectiv(intre 1 si 10 octeti adica 8-80 biti).


-25-

Asadar limbajul C utilizeaza urmatoarele tipuri de date: char,unsigned

char,signed char,int,unsigned int,signed int,short int,unsigned short int,

signed short int,long int,signed long int,unsigned long int,float,double

si long double.

Limbajul (si compilatorul C++) accepta un set extins de tipuri de date,

prezentate sintetic in tabelul de mai jos:

TIPUL DE DATE OCTETI ALTE NUME DOMENIUL DE VALORI

=======================================================================

int * signed depinde de sistem

signed int

------------------------------------------------------------------------

unsigned int * unsigned depinde de sistem

------------------------------------------------------------------------

__int8 1 char -128 la 127

signed char

------------------------------------------------------------------------

__int16 2 short -32768 la 32757

short int

signed short int

------------------------------------------------------------------------

__int32 4 signed -2147483648 la

signed int 2147483647

------------------------------------------------------------------------

__int64 8 none -9223372036854775808 la

9223372036854775807

-------------------------------------------------------------------------

char 1 signed char -128 la 127

-------------------------------------------------------------------------

unsigned char 1 none 0 la 255

-------------------------------------------------------------------------

short 2 short int -32768 la 32767

signed short int

-------------------------------------------------------------------------

unsigned short 2 unsigned short int 0 la 65535

------------------------------------------------------------------------

long 4 long int -2147483548 la

signed long int 2147483647

------------------------------------------------------------------------

unsigned long 4 unsigned long int 0 la 4294967295

------------------------------------------------------------------------

enum * none la fel ca si int

-------------------------------------------------------------------------

float 4 none 3,4 E-38 la 3,4 E+38

--------------------------------------------------------------------------

double 8 none 1,7 E-308 la 1,7 E+308

--------------------------------------------------------------------------

long double 10 none 1,2 E-4932 la 1,2 E+4932

-------------------------------------------------------------------------

void * none none

-------------------------------------------------------------------------

-26-

Tipul datelor se va alege in functie de domeniul de valori preconizat

pentru variabila sau functia declarata.Astfel variabilele declarate

implicit sau explicit ca int,nu vor putea opera cu numere reale,sau cu

numere extrem de mari.In acelasi timp insa,pentru operatii cu numere

intregi (de exemplu numerele de ordine dintr-o lista) este inutil sa se

utilizeze tipul de date long int sau long double deoarece nu va avea ca

efect decat alocarea inutila de memorie din spatiul memoriei de lucru.

EXEMPLU: daca initializati o variabila ca long double,aceasta va aloca

10 octeti din spatiul de memorie doar pentru variabila respectiva,iar

daca renuntati la variabila dupa o operatie simpla,cei 10 octeti vor

ramane neutilizati,fragmentand inutil spatiul de memorie(Utilitarul defrag

din System Tools Windows elimina aceste spatii de fragmentare).

Inainte sa declarati o variabila,este bine sa analizati tot domeniul

probabil de valori si doar apoi sa alegeti tipul de date convenabil.

SPECIFICATORII DE ACCES (const,volatile)

Pentru a preciza daca datele de un anumit tip vor avea o valoare con-

stanta pentru toata perioada de derulare a programului,sau vor putea lua

valori modificabile(din registrul de valori),se utilizeaza doi specifica-

tori denumiti "calificatori de tip".Acesti specificatori sunt: const in

cazul in care datele vor avea o valoare constanta si volatile in cazul

in care datele vor avea valori modificabile.

Cei doi specificatori pot sa apara o singura data in cadrul unei decla-

ratii,se pot asocia oricarui tip de date dar nu pot sa apara dupa prima

virgula(atunci cand se declara liste de variabile).

EXEMPLE: typedef volatile int; // este corect

typedef int i,volatile vi // nu este corect

O anumita variabila poate fi declarata cu ambii specificatori simultan,

caz in care variabila respectiva nu va putea fi modificata din interiorul

programului(fata de care va fi const) dar va putea fi modificata de catre

un proces asincron(din afara programului,fata de care va fi volatile)

TIPURI DE DECLARATII

Variabilele declarate pot fi izolate,sau pot fi grupate in mai multe

tipuri de structuri ordonate care manipuleaza blocuri de date in ansamblu:

Variabile simple:- sunt variable izolate de tip int sau float

EXEMPLE: int x int y int z,q int const pq

Arii:-sunt variabile compuse dintr-o colectie de date de acelasi tip

EXEMPLE: char A[2][3]; // aria are 2 linii si trei coloane

float matrix[10][15]; //aria va avea 150 de elemente

Pointeri:-sunt variabile care apeleaza alte variabile si contin o adresa

de memorie (in loc de valori sau date)

EXEMPLE: char *message //declara pointerul message

int *pointers[10] //declara o arie de 10 pointeri

Enumerari:-sunt variabile de tip int ce contin un set de constante int

EXEMPLU: enum zile

{

luni,

marti, //este ca o structura in care

miercuri, //toate elementele sunt de tip

joi, // const int

vineri

} zilelucratoare;


-27-

Structuri:-sunt variabile compuse din colectii de date ce pot fi si de

tip diferit(caractere,numere intregi sau in virgula mobila)

EXEMPLU: struct client

{

char nume[20];

int id;

float suma;

long class;

} temp;

structura contine patru membri: nume este o arie din 20 de ele-

mente de tip caracter,id este un numar intreg,suma este un numar

real iar class este un numar intreg(pe 32 de biti)

Uniuni:-sunt variabile compuse din valori de diferite tipuri dar care

ocupa acelasi spatiu de memorie (partajeaza memoria)

EXEMPLU: union numere

{

int x;

float y;

}

poate opera atat cu numere intregi cat si cu numere reale

Uniunile pot fi inticate in structuri.

EXEMPLU: struct str

{

int a,b;

union

{

char c[4];

long l;

float f;

};

char c_nume[10];

} nr_str;
Intelegerea acestor tipuri de declarare a variabilelor este mai facila

pentru cei care cunosc limbajul FoxPro.Fata de limbajul FoxPro,limbajul C

acopera o gama mult mai larga de combinatii de date formatate,un domeniu

de valori mult mai extins si flexibilitatea de a combina date cu format

diferit in cadrul unor structuri manipulate unitar.Pentru incepatori,poate

fi util sa desenati pe hartie schema tipurilor de date cu care lucrati,

inainte de a declara si grupa datele in structuri,arii sau uniuni.Cu cat

incarcati programul cu variabile si date inutile,cu atat programul va

functiona mai lent si va creste probabilitatea unui conflict de date.

Atunci cand construiti structuri de date complexe,sa aveti in vedere

faptul ca datele respective vor trebui sa fie manipulate in bloc,la fie-

care operatie asupra membrilor.Un program,este cu atat mai frumos cu cat

este mai simplu.

Pentru a simplifica si mai mult munca procesorului,datele de acelasi

tip se pot grupa in file diferite,astfel incat programul sa nu fie nevoit

sa execute nenumarate salturi intre comanda de citire a datelor si locatia

de memorie la care sunt arhivate.Procedand astfel,puteti elimina acele

minute plicticoase in care calculatorul afiseaza...PROCESSING...


-28-

Limbajul C++,a introdus un nou tip de declaratie a variabilelor,struc-

turat in clase denumite prin class.O clasa poate fi definita prin unul

dintre cuvintele cheie class,struct sau union si are rolul de grupa mai

multe variabile de acelasi fel sau de tip diferit,pentru a permite o

gestionare si manevrare mai usoara a blocurilor de memorie.Acest gen de

programare se numeste "programare structurata" sau "programare orientata

pe obiect".Un exemplu intuitiv il reprezinta ferestrele din mediul

Windows(care sunt obiecte software) sau elementele mobile ale unui joc de

platforma(fiecare personaj din joc este un obiect software).

Dupa cum a-ti sesizat deja,ficare tip de data aloca un anumit spatiu

de memorie,un anumit numar de octeti,care vor fi utilizati in cadrul pro-

gramului doar pentru variabila respectiva.La spatiul initial se mai pot

adauga un anumit numar de octeti prin specificatorii si modificatorii

fiecarui tip de date si respectiv se mai adauga un grup de octeti destinat

strict pentru gestionarea si manevrarea variabilei respective.Astfel,la

fiecare variabila declarata,programul aloca un spatiu de memorie format

din unul sau mai multe grupuri de octeti(clustere).In cazul structurilor

formate din mai multe variabile,acest spatiu devine din ce in ce mai mare

si mai complex structurat.Pentru executia unei aplicatii,programul utili-

zeaza un spatiu de memorie in care obiectele declarate vor fi aduse si

combinate asemanator cu un joc de puzzle.Daca variabilele sunt grupate sub

forma de structuri(obiecte),atunci programul are de efectuat un numar mult

mai mic de operatii,iar combinatiile discriminative sunt mult mai putine,

iar ca rezultat,creste foarte mult viteza de executie a programului.

Limbajul C++,nu a fost destinat pentru operatii aritmetice simple ci

pentru aplicatii grafice sau pentru calcule complexe,motiv pentru care

utilizeaza foarte mult declaratiile de tip clasa de variabile (obiectele).

Toate clasele declarate vor purta un nume,unic pentru fila respectiva

de program,nume care defineste obiectul respectiv si caruia i se asociaza

o singura definitie.Se definesc la fel ca si structurile.

EXEMPLU: class Punct

{

public:

unsigned x,y;

};

O clasa contine unul sau mai multi membri.Fiecare membru al unei clase

poate fi: o functie,o constanta(date),o alta clasa intricata sau o uniune

o enumerare,un camp de biti,un specificator de acces de tip "friend",sau

un specificator de tip.

EXEMPLU: class BufferedIO

{

public:

enum IOError { None,Access,General };

class BufferedInput //este o clasa intricata

{

public:

int read();

int good() {return _inputerror ==None;}

IOError _inputerror;

};

};

-29-

INTERPRETAREA DECLARATIILOR COMPLEXE

Pentru declararea unor variabile cu ajutorul unui numar mare de modi-

ficatori se pot utiliza semnele de punctuatie,sau se poate un declara un

tip nou de date prin typedef(tip de date definit de catre utilizator).

In interpretarea semnelor de punctuatie,parantezele drepte si rotunde

(care sunt modificatori spre dreapta ai identificatorilor) au precedenta

fata de semnul asterix(care este modifica identificatorul spre stanga).

EXEMPLU: char *(*(*var)() )[10];

7 6 4 2 1 3 5

Pentru a se facilita interpretarea expresiei(vezi ordinea numerelor) se

poate utiliza citirea din interior spre exterior,pornind de la identifi-

cator,citind parantezele si apoi semnele asterix.

Expresia din exemplu se citeste dupa cum urmeaza(vezi numerele):

1 -este declaratia identificatorului var (numele variabilei)

2 -este un pointer (variabila este un pointer)

3 -returneaza valoarea unei functii