Documente online.
Username / Parola inexistente
  Zona de administrare documente. Fisierele tale  
Am uitat parola x Creaza cont nou
  Home Exploreaza
upload
Upload






























Tipuri

c


Tipuri



Orice nume (identificator) dintr-un program C++ are un tip asociat cu el. Acest tip determina ce operatii pot fi aplicate asupra numelui (adica la entitatea referita prin nume) si cum se interpreteaza aceste operatii. De exemplu:

int error_number;

float real(complex* p);

Intrucit error_number este declarat sa fie int, lui i se pot face atribuiri, poate fi folosit in expresii aritmetice, etc..

Functia real, pe de alta parte, poate fi aplicata cu adresa unui complex ca parametru al ei. Este posibil sa se ia adresa oricaruia din ei. Anumite nume, cum ar fi int si complex, sint nume de tipuri. Un nume de tip este utilizat pentru a specifica tipul unui alt nume intr-o declaratie. Singura alta operatie asupra unui nume de tip este sizeof (pentru a determina cantita­tea de memorie necesara pentru a pastra un obiect de acel tip) si new (pentru alocare de memorie libera pentru obiectele de tipul respectiv). De exemplu:

main()

Un nume de tip poate fi utilizat ca sa specifice explicit conversia de la un tip la altul (&3.2.4). De exemplu:

float f;

char* p;

long ll = long(p); // converteste p spre long

int i = int(f); // converteste f spre int

2.3.1. Tipuri fundamentale

C++ are un set de tipuri fundamentale ce corespund la cele mai comune unitati de memorie ale calculatoarelor si la cele mai fundamentale moduri de utilizare ale lor.

char

short int

int

long int , pentru a reprezenta intregi de diferite dimensiuni;

float

double ,pentru a reprezenta numere in flotanta;

unsigned char

unsigned short int

unsigned int

unsigned long int ,pentru a reprezenta intregi fara semn, valori logice, vectori de biti, etc..

Pentru o notatie mai compacta, int poate fi eliminat dintr-o combinatie de multicuvinte (de exemplu short este de fapt short int) fara a schimba intelesul; astfel long inseamna long int iar unsigned inseamna unsigned int. In general, cind un tip este omis intr-o declaratie, se presupune ca s-a omis int. De exemplu:

const a = 1;

static x;

fiecare defineste un obiect de tip int.

Intregul de tip caracter este cel mai potrivit pentru a mentine si manipula caractere pe un calculator dat; acest tip este de obicei pe 8 biti. Dimensiunile obiectelor din C++ sint exprimate in termeni multipli ai dimensiunii lui char, asa ca, prin definitie sizeof(char) = 1. Depinzind 939q1619j de hardware, un char este un intreg cu sau fara semn. Tipul caracter fara semn este sigur totdeauna fara semn (unsigned char) si utilizindu-l produce programe mai portabile, dar poate sa fie mai putin eficient decit daca este folosit ca tip char obisnuit.

Motivul pentru a funiza mai multe tipuri de intregi, mai multe tipuri de intregi fara semn si mai multe tipuri de flotante este pentru a permite programatorului sa utilizeze avantajos caracteristicile hardware. Pe multe masini exista diferente semnificative in cerintele de memorie, timpul de acces la memorie si viteza de calcul dintre diferite varietati a tipurilor funda­mentale. Cunoscind o masina, de obicei este usor a alege, de exemplu, tipul de intreg potrivit pentru o variabila particulara. A scrie cod de nivel inferior portabil cu adevarat este foarte greu. Ceea ce este garantat in legatura cu dimensiunile tipurilor fundamentale este:

sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long)

sizeof(float) <= sizeof(double)

Cu toate acestea, de obicei este rezonabil sa presupunem ca tipul char poate pastra intregi in intervalul 0..127 (el poate totdeauna pastra un caracter din setul de caractere al masinii), ca un short si un int au cel putin 16 biti, ca un int este apropiat de o dimensiune potrivita pentru aritmetica intregilor si ca un long are cel putin 24 de biti. A presupune mai mult este hazardos si chiar aceste reguli implicite nu se aplica universal (o tabela de caracteristici hardware pentru citeva masini se poate vedea in &r.2.6).

Tipurile de intregi fara semn sint ideale pentru a utiliza memoria ca un vector pe biti. Utilizarea unui intreg fara semn in locul unui int pentru a cistiga un bit in plus pentru a reprezen­ta intregi pozitivi aproape totdeauna nu este o idee buna. Incer­carea de a ne asigura ca anumite valori sint pozitive prin decla­rarea variabilelor de tip unsigned va fi ignorata prin reguli implicite de conversie. De exemplu:

unsigned surprise = -1;

este legal (dar compilatorul va face un avertisment despre el).

2.3.2. Conversie implicita de tip

Tipurile fundamentale pot fi amestecate liber in expresii. Oricind este posibil, valorile se convertesc asa ca sa nu se piarda informatie (regula exacta poata fi gasita in &r.6.6).

Exista cazuri in care informatia se poate pierde sau chiar distruge. Atribuirea unei valori de un tip la o variabila de un alt tip cu biti mai putini in reprezentarea ei este in mod nece­sar o sursa potentiala de erori. De exemplu, sa presupunem ca secventa urmatoare se executa pe o masina in care intregii se reprezinta in complement fata de doi si caracterele pe 8 biti:

int i1 = 256 +255;

char ch = i1; //ch == 255

int i2 = ch; //i2 == ?

Un bit (cel mai semnificativ) este pierdut in atribuirea ch = i1 si ch va pastra toti bitii 1 (adica 8 biti de 1); deci nu exista o cale ca acesta sa poata deveni 511 cind se atribuie lui i2! Dar care ar putea fi valoarea lui i2 ? Pe VAX, unde un caracter este cu semn, raspunsul este 255. C++ nu are un mecanism la executie care sa detecteze un astfel de tip de problema, iar detectarea la compilare este prea dificila in general, asa ca programatorul trebuie sa fie atent la acest fapt.

2.3.3. Tipuri derivate

Din tipurile fundamentale (si din tipurile definite de utilizator) se pot deriva alte tipuri folosind operatorii de declaratie:

* pointer

& adresa

[] vector

() functie

si mecanismul de definitie de structura. De exemplu:

int* a;

float v[10];

char* p[20]; //vector de 20 de pointeri spre caractere

void f(int);

struct str;

Regulile de compunere a tipurilor utilizind acesti operatori se explica in detaliu in &r8.3.4. Ideea de baza este ca declararea unui tip derivat oglindeste utilizarea lui. De exemplu:

int v[10]; //declara un vector

i = v[3]; //utilizeaza un element al vectorului

int* p; //declaratie de pointer

i = *p; //utilizeaza obiectul spre care se pointeaza

Toate problemele in intelegerea notatiei pentru tipuri derivate apar din cauza faptului ca * si & sint operatori prefix iar [] si () sint postfix, asa ca parantezele trebuie sa fie utilizate pentru a exprima tipuri in care precedenta operatorilor este incomoda. De exemplu deoarece [] are o prioritate mai mare decit *:

int *v[10]; //vectori de pointeri

int (*p)[10] //pointer spre vector

Poate fi plicticos sa utilizam o declaratie pentru fiecare nume pe care vrem sa-l introducem intr-un program, mai ales daca tipurile lor sint identice. Este posibil sa declaram diferite nume intr-o singura declaratie; in locul unui singur nume, decla­ratia pur si simplu contine o lista de nume separate prin virgu­la. De exemplu, se pot declara doi intregi astfel:

int x, y; //int x; int y;

Cind declaram tipuri derivate, trebuie sa observam ca opera­torii se aplica numai la nume individuale (si nu la orice alte nume din aceeasi declaratie). De exemplu:

int* p, y; //int *p; int y; nu int *y;

int x, *p; //int x; int *p;

int v[10], *p; //int v[10]; int *p;

Opinia autorului este ca astfel de constructii fac un program mai putin lizibil si ar trebui eliminate.

2.3.4. Void

Tipul void se comporta sintactic ca un tip fundamental. El poate totusi, sa fie utilizat numai ca parte a unui tip derivat; nu exista obiecte de tip void. Este folosit pentru a specifica ca o functie nu returneaza o valoare sau ca tip de baza pentru pointeri spre obiecte de tip necunoscut.

void f(); //f nu returneaza o valoare

void* pv; //pointer spre un obiect de tip necunoscut

Un pointer spre orice tip poate fi atribuit la o variabila de tip void*. Pentru inceput acesta nu pare prea util, deoarece un pointer void* nu poate fi indirectat dar aceasta restrictie este exact ceea ce face ca tipul void* sa fie util. El se utili­zeaza in primul rind pentru a transfera la functii pointeri despre care nu se poate face presupunere asupra tipului obiectu­lui spre care pointeza si pentru a returna obiecte fara tip dintr-o functie. Pentru a utiliza un astfel de obiect, trebuie sa se utilizeze conversia explicita de tip. Astfel de functii de obicei exista la cel mai inferior nivel al sistemului unde se manipuleaza resurse hardware reale. De exemplu:

void* allocate(int size);

void deallocate(void*);

f()

2.3.5. Pointeri

Pentru cele mai multe tipuri T, T* este tipul pointer spre T. Adica o variabila de tipul T* poate pastra adresa unui obiect de tipul T. Pentru pointeri spre vectori si pointeri spre functii exista notatii mai complicate:

int* pi;

char** cpp; //pointer spre pointer spre caractere

int (*vp)[10] //pointer spre vector de 10 elemente

int (*fp)(char,char*) //pointer spre o functie care are ca

//parametru (char, char*) si retur-

//neaza un int

Operatia fundamentala asupra unui pointer este indirectarea, adica referirea la un obiect pointat printr-un pointer spre el. Operatorul de indirectare este unarul * (prefixat). De exemplu:

char c1 = 'a';

char* p = &c1; //p pastreaza adresa lui c1

char c2 = *p; //c2 = 'a'

Variabila spre care pointeaza p este c1 si valoarea pastrata in c1 este 'a', asa ca valoarea lui *p atribuita lui c2 este 'a'.

Este posibil sa se faca unele operatii aritmetice cu poin­terii. Iata de exemplu o functie care calculeaza numarul de caractere dintr-un sir (nesocotind 0 care termina sirul):

int strlen(char* p)

Un alt mod de a gasi lungimea este ca la inceput sa gasim sfirsitul sirului si apoi sa scadem adresa inceputului sirului din adresa sfirsitului:

int strlen(char* p)

Pointerii spre functii pot fi extrem de utili; ei se discuta in (&4.6.7).

2.3.6. Vectori

Pentru un tip T, T[size] este tipul "vector de size elemente de tip T". Elementele sint indexate de la 0 la size-1. De exem­plu:

float v[3]; // un vector de 3 flotante: v[0],v[1],v[2]

int a[2][5]; // doi vectori de 5 intregi

char* vpc[32]; // vectori de 32 de pointeri spre caractere

Un ciclu pentru a scrie valori intregi pentru caracterele mici ar putea fi scris astfel:

extern int strlen(char*);

char alpha[] = "abcdefghijklmnopqrstuvwxyz";

main()

}

Functia chr() returneaza reprezentarea sub forma de caracter a unui intreg mic; de exemplu, chr(80) este "P" pe o masina care utilizeaza setul de caractere ASCII. Functia oct() produce o reprezentare octala a argumentului sau intreg, iar hex() produce o reprezentare hexazecimala a argumentului sau intreg; chr(), oct() si hex() sint declarate in <stream.h>.

Functia strlen() a fost utilizata pentru a numara carac­terele din alpha (vezi &2.4.4). Cind se utilizeaza setul de caractere ASCII, iesirea va arata astfel:

'a' = 97 = 0141 = 0x61

'b' = 98 = 0142 = 0x62

'c' = 99 = 0143 = 0x63

Sa observam ca nu este necesar sa se specifice dimensiunea vectorului alpha; compilatorul calculeaza numarul de caractere din sirul de caractere specificat ca initializator. Utilizind un sir ca un initializator pentru un vector de caractere este con­venabil, dar din nefericire este unica utilizare a sirurilor. Nu exista o atribuire similara a unui sir la un vector. De exemplu:

char v[9];

v = "a string"; // error

este o eroare deoarece atribuirea nu este definita pentru vec­tori.

Evident sirurile sint potrivite numai pentru a initializa vectori de caractere; pentru alte tipuri trebuie sa se utilizeze o notatie mai laborioasa. Aceasta notatie poate fi de asemenea utilizata pentru vectori de caractere. De exemplu:

int v1[] = ;

int v2[] = ;

char v3[] = ;

char v4[] = ;

Observam ca v4 este un vector de 4 (nu 5) caractere; nu este terminat printr-un zero, asa cum cer prin conventie toate ruti­nele de biblioteca. Aceasta notatie este de asemenea restrin sa la obiecte statice.

Tablourile multidimensionale sint reprezentate ca vectori de vectori si notind cu virgula pentru a separa limitele ca in alte limbaje de programare se obtine la compilare o eroare deoarece virgula (,) este un operator de succesiune (vezi &3.2.2). De exemplu, sa incercam:

int bad[5,2]; // error

int v[5][2]; //correct

int bad = v[5,2]; // error

int good = v[4][1]; // correct

O declaratie char v[2][5]; declara un vector cu doua elemente; fiecare din ele este un vector de tip char [5]. In exemplul urmator, primul din acei vectori este initializat cu primele 5 litere iar cel de al doilea cu primele 5 cifre:

char v[2][5] = ;

main()

}

va produce:

v[0][0]=a v[0][1]=b v[0][2]=c v[0][3]=d v[0][4]=e



v[1][0]=0 v[1][1]=1 v[1][2]=2 v[1][3]=3 v[1][4]=4

2.3.7. Pointeri si Vectori

In C++, pointerii si vectorii sint foarte strinsi legati. Numele unui vector poate de asemenea, sa fie utilizat ca un pointer spre primul sau element, asa ca exemplul cu alfabetul ar putea fi scris astfel:

char alpha[] = "abcdefghijklmnopqrstuvwxyz";

char* p = alpha;

char ch;

while(ch = *p++);

cout << chr(ch) << "=" << ch

<< "=0" << oct(ch) << "\n";

Declaratia lui p ar putea de asemenea sa fie scrisa:

char* p = &alpha[0];

Aceasta echivalenta este utilizata extensiv in apelurile de functii, in care un argument vector este totdeauna pasat ca un pointer la primul element al vectorului; astfel in acest exemplu:

extern int strlen(char*);

char v[] = "Annemarie";

char* p = v;

strlen(p);

strlen(v);

este transferata aceeasi valoare la strlen in ambele apeluri.

Rezultatul aplicarii operatorilor +, -, ++, -- la pointeri depinde de tipul obiectului spre care pointeaza pointerul. Cind un operator aritmetic se aplica la un pointer spre un tip T, p este presupus ca pointeaza spre un element al vectorului de obiecte de tip T; p+1 inseamna elementul urmator al acelui vector iar p-1 elementul precedent. Aceasta implica faptul ca valoarea lui p+1 va fi cu sizeof(T) mai mare decit valoarea lui p. De exemplu:

main()

va produce:

char* 1

int* 4

deoarece caracterele ocupa un octet fiecare si intregii ocupa fiecare 4 octeti pe masina mea. Valorile pointer au fost conver­tite spre long inainte de a face scaderea utilizind conversia explicita de tip (&3.2.5). Ele au fost convertite spre long si nu spre tipul int deoarece exista masini pe care un pointer nu incape intr-un int (adica sizeof(int) < sizeof(char*)).

Scaderea de pointeri este definita numai cind ambii pointeri pointeaza spre elemente ale aceluiasi vector (desi limbajul nu are un mod de a se asigura ca acest lucru este adevarat). Cind se scade un pointer dintr-un altul, rezultatul este numarul de elemente al vectorului dintre cei doi pointeri (un intreg). Se poate adauga un intreg la un pointer sau scadea un intreg

dintr-un pointer; in ambele cazuri rezultatul este o valoare pointer. Daca acea valoare nu pointeaza spre un element al acelu­iasi vector, ca si vectorul initial, rezultatul utilizarii va­lorii respective este nedefinit. De exemplu:

int v1[10];

int v2[10];

int i = &v1[5] - &v1[3]; // 2

i = &v1[5] - &v2[3]; // rezultat nedefinit

int* p = v2 + 2; // p==&v2[2]

p = v2 - 2; // *p nedefinit

2.3.8. Structuri

Un vector este un agregat de elemente de un acelasi tip; o structura este un agregat de elemente de orice tip. De exemplu:

struct address;

defineste un tip nou numit address care consta din elementele de care avem nevoie pentru a trimite o scrisoare la cineva (address nu este in general destul pentru a gestiona toate scrisorile, dar este suficient pentru un exemplu). Sa observam punct-virgula de la sfirsit este unul din foarte putinele locuri din C++ unde este necesar sa o avem dupa o acolada inchisa, asa ca lumea este inclinata sa o uite.

Variabilele de tip adresa pot fi declarate exact ca si alte variabile, iar elementele individuale pot fi accesate utilizind operatorul '.'(punct). De exemplu:

address jd;

jd.name = "Jim Dandy";

jd.number = 61;

Notatia utilizata pentru initializarea vectorilor poate de asemenea sa fie utilizata pentru variabile de tip structura. De exemplu:

address jd = ,7974};

Utilizind un constructor (&5.2.4) este de obicei mai bine. Sa observam ca jd.state nu poate fi initializat prin sirul "NJ". Sirurile sint terminate prin caracterul '\0' asa ca "NJ" are trei caractere, adica unul in plus decit ar incapea in jd.state.

Obiectele structura sint adesea accesate prin pointeri folosind operatorul ->. De exemplu:

void print_addr(address* p)

Obiectele de tip structura pot fi atribuite, pasate ca si argumente la functie si returnate ca rezultat al unei functii. De exemplu:

address current;

address set_current(address next)

Alte operatii plauzibile cum ar fi compararea (== si !=) nu sint definite. Cu toate acestea, utilizatorul poate defini astfel de operatori (vezi cap. 6).

Nu este posibil sa se calculeze dimensiunea unui obiect de tip structura pur si simplu insumind membri ei. Motivul pentru aceasta este ca multe masini necesita ca obiecte de un anumit tip sa fie alocate numai la anumite adrese (un exemplu tipic este faptul ca un intreg trebuie sa fie alocat la o adresa de cuvint) sau pur si simplu pentru a trata astfel de obiecte mult mai eficient. Aceasta conduce spre "goluri" in structuri. De exemplu (pe masina mea): sizeof(address) este 24 si nu 22 cit ne-am astepta.

Sa observam ca numele unui tip devine disponibil pentru utilizare imediat dupa ce el a fost intilnit si nu numai dupa declararea completa. De exemplu:

struct link;

Nu este posibil sa se declare obiecte noi de tip structura pina cind nu s-a terminat complet declaratia, deci

struct no_good;

este o eroare (compilatorul nu este in stare sa determine di­mensiunea lui no_good). Pentru a permite ca doua (sau mai multe) tipuri structura sa se refere unul la altul, pur si simplu se admite ca sa se declare ca un nume este numele unui tip structu­ra. De exemplu:

struct list; // to be defined later

struct link;

struct list;

Fara prima declaratie a lui list, declaratia lui link ar produce o eroare sintactica.

2.3.9. Echivalenta tipurilor

Doua tipuri structura sint diferite chiar daca ele au aceeasi membri. De exemplu:

struct s1;

struct s2;

sint doua tipuri diferite, asa ca

s1 x;

s2 y = x; // error: type mismatch

Tipurile structura sint de asemenea diferite de tipurile fundamentale, asa ca:

s1 x;

int i = x; // error: type mismatch

Exista un mecanism pentru a declara un nume nou pentru un tip, fara a introduce un obiect nou. O declaratie prefixata prin cuvintul cheie typedef declara nu o noua variabila de un tip dat, ci un nume nou pentru tip. De exemplu:

typedef char* pchar;

pchar p1,p2;

char* p3 = p1; Aceasta poate fi o prescurtare convenabila.

2.3.10. Referinte

O referinta este un nume pentru un obiect. Prima utilizare a referintelor este aceea de a specifica operatiile pentru tipuri definite de utilizator (ele se discuta in cap. 6). Ele pot fi de asemenea utile ca argumente de functii. Notatia X& inseamna referinta la X. De exemplu:

int i = 1;

int& r = i; // r si i acum se refera la acelasi obiect

int x = r; // x = 1

r = 2; // i = 2

O referinta trebuie sa fie utilizata (trebuie sa fie ceva pentru ce este el nume). Sa observam ca initializarea unei re­ferinte este ceva cit se poate de diferit de atribuirea la ea.

In ciuda aparentelor, nici un operator nu opereaza asupra unei referinte. De exemplu:

int ii = 0;

int& rr = ii;

rr++; // ii se incrementeaza cu 1

este legal, dar r++ nu incrementeaza referinta rr; ++ se aplica la un int, care se intimpla sa fie ii. In consecinta, valoarea referintei nu poate fi schimbata dupa initializare; ea totdeauna se refera la obiectul cu care a fost initializata pentru a-l denumi. Pentru a primi un pointer spre obiectul notat prin re­ferinta rr, se poate scrie &rr.

Implementarea unei referinte este un pointer (constant) care este indirectat de fiecare data cind el este utilizat. Aceasta face initializarea unei referinte trivial cind initializatorul este o lvaloare (un obiect la care se poate lua adresa vezi &r5). Cu toate acestea, initializatorul pentru T& este necesar sa nu fie o lvaloare sau chiar de tip T. In astfel de cazuri:

[1] Intii, se aplica conversia de tip daca este necesar (vezi &r6.6.8 si &r8.5.6);

[2] Apoi valoarea rezultat este plasata intr-o variabila temporara;

[3] In final, adresa acestuia se utilizeaza ca valoare a initializatorului.

Consideram declaratia:

double& dr = 1;

Interpretarea acesteia este:

double* drp; // referinta reprezentata printr-un pointer

double temp;

temp = double(1);

drp = &temp;

O referinta poate fi utilizata pentru a implementa o functie care se presupune ca schimba valoarea argumentelor sale.

int x = 1;

void incr(int& aa)

incr(x); // x = 2;

Semantica transferului de argumente se defineste ca si pentru initializare, asa ca atunci cind este apelata functia de mai sus argumentul aa a lui incr() devine un alt nume pentru x. Cu toate acestea, pentru a avea un program mai lizibil este cel mai bine sa eliminam functiile care isi modifica argumentele. Este adesea preferabil sa se returneze o valoare dintr-o functie in mod explicit sau sa se returneze un pointer spre argument.

int x = 1;

int next(int p)

x = next(x); // x = 2

void inc(int* p)

inc(&x); // x = 3

Referintele pot fi de asemenea utilizate pentru a defini functii care pot fi utilizate atit in parttea stinga cit si in partea dreapta a unei atribuiri. Din nou, multe din cele mai interesante utilizari ale referintei se afla in proiectarea tipurilor netriviale definite de utilizator. Ca de exemplu, sa definim un tablou asociativ simplu. Intii noi definim struct pair prin:

struct pair;

Ideea de baza este ca un sir are o valoare intreaga asociata cu el. Este usor sa se defineasca o functie, find() care mentine o data structurata ce consta dintr-o pereche pentru fiecare sir diferit ce a fost prezentat. O implementare foarte simpla (dar ineficienta) ar fi urmatoarea:

const large = 1024;

static pair vec[large+1];

pair* find(char* p)

/* mentinerea unui set de "pair": se cauta p, se returneaza

"pair"-ul respectiv daca se gaseste, altfel se returneaza

un "pair" neutilizat */

Aceasta functie poate fi utilizata prin functia value() care implementeaza un tablou de intregi indexat prin siruri de carac­tere:

int& value(char* p)

return res_val;

}

Pentru un parametru sir dat, value() gaseste obiectul intreg respectiv (nu valoarea intregului corespunzator); ea returneaza o referinta la el. Aceasta s-ar putea utiliza astfel:

const MAX = 256; //mai mare decit cel mai mare cuvint

main() //numara aparitiilor fiecarui cuvint de la intrare

Fiecare pas al ciclului citeste un cuvint de la intrarea standard cin in buf (vezi cap.8), iar apoi se pune la zi contorul asociat cu el prin find(). In final tabela rezultata de cuvinte diferite de la intrare, fiecare cu numarul sau de aparitii, este imprimat. De exemplu, dindu-se intrarea aa bb bb aa aa bb aa aa

programul va produce:

aa : 5

bb : 3

Este usor sa se perfectioneze aceasta intr-un tip de tablou asociativ propriu folosind o clasa cu operatorul de selectie [] (vezi &6.7).

2.3.11. Registrii

Pe orice arhitectura de masina obiectele (mici) pot fi accesate mai rapid cind se plaseaza intr-un registru. Ideal, compilatorul va determina strategia optima pentru a utiliza orice registru disponibil pe masina pe care se compileaza programul. Totusi, acest task nu este trivial, asa ca uneori este util ca programatorul sa dea compilatorului aceasta informatie. Aceasta se face declarind un obiect registru. De exemplu:

register int i;

register point cursor;

register char* p;

Declaratiile de registrii ar trebui utilizate numai cind eficienta este intr-adevar importanta. Declarind fiecare variabi­la ca variabila registru se va ingreuna textul programului si se poate chiar marii dimensiunea codului si timpul de executie (de obicei sint necesare instructiuni de a incarca un obiect si de a memora un obiect dintr-un registru). Nu este posibil sa se ia adresa unui nume declarat ca registru si nici nu poate fi global un astfel de nume.






Document Info


Accesari: 952
Apreciat: hand-up

Comenteaza documentul:

Nu esti inregistrat
Trebuie sa fii utilizator inregistrat pentru a putea comenta


Creaza cont nou

A fost util?

Daca documentul a fost util si crezi ca merita
sa adaugi un link catre el la tine in site


in pagina web a site-ului tau.




eCoduri.com - coduri postale, contabile, CAEN sau bancare

Politica de confidentialitate | Termenii si conditii de utilizare



});

Copyright © Contact (SCRIGROUP Int. 2024 )