main,dar nu sunt obligatorii
səhifə 4/55 tarix 07.05.2018 ölçüsü 4,6 Mb. #50260
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
Dostları ilə paylaş: