kooze
Moderator
 Inregistrat: acum 18 ani
Postari: 57
|
|
Download =>
The C Programming Language
Brian W. Kernighan
Dennis M. Ritchie
C O N T I N U T
Prefata....................................................... 3
Capitolul 0. Introducere...................................... 4
Capitolul 1. Initiere......................................... 7
1.1 Pornirea............................................... 7
1.2 Variabile si aritmetica................................ 8
1.3 Instructiunea For...................................... 10
1.4 Constante simbolice.................................... 11
1.5 O colectie de programe utile........................... 11
1.6 Tablouri............................................... 15
1.7 Functii................................................ 16
1.8 Argumente - apelul prin valoare........................ 17
1.9 Tablouri de caractere.................................. 18
1.10 Domenii. Variabile externe............................. 19
1.11 Rezumat................................................ 21
Capitolul 2. Tipuri de date, operatori si expresii............ 22
2.1 Nume de variabile...................................... 22
2.2 Tipurile si marimea datelor............................ 22
2.3 Constante.............................................. 22
2.4 Declaratii............................................. 23
2.5 Operatori aritmetici................................... 24
2.6 Operatori relationali si logici........................ 24
2.7 Conversii de tip....................................... 25
2.8 Operatori de incrementare si decrementare.............. 27
2.9 Operatori logici pe biti............................... 28
2.10 Operatorul si expresii de asignare..................... 29
2.11 Expresii conditionale.................................. 30
2.12 Pondere si ordine de evaluare.......................... 30
Capitolul 3. Controlul executiei............................. 32
3.1 Instructii si blocuri.................................. 32
3.2 If-else................................................ 32
3.3 Else-if................................................ 33
3.4 Switch................................................. 33
3.5 Bucle - while si for................................... 34
3.6 Bucle do-while......................................... 36
3.7 Break.................................................. 37
3.8 Continue............................................... 38
3.9 Goto-uri si etichete................................... 38
Capitolul 4. Structura programelor si functiilor............. 39
4.1 Notiuni de baza........................................ 39
4.2 Functii ce returneaza ne-intregi....................... 41
4.3 Argumentele functiilor................................. 42
4.4 Variabile externe...................................... 42
4.5 Reguli despre domenii.................................. 45
4.6 Variabile statice...................................... 47
4.7 Variabile registru..................................... 48
4.8 Structura de bloc...................................... 48
4.9 Initializare........................................... 49
4.10 Recursivitate.......................................... 50
4.11 Preprocesorul C........................................ 51
Capitolul 5. Pointeri si tablouri............................ 53
5.1 Pointeri si adrese..................................... 53
5.2 Pointeri si argumente de functii....................... 54
5.3 Pointeri si tablouri................................... 55
5.4 Aritmetica adreselor................................... 57
5.5 Pointeri la functii pe caractere....................... 58
5.6 Pointerii nu sint intregi.............................. 60
5.7 Matrici multi-dimensionale............................. 61
5.8 Matrici de pointeri; pointeri la pointeri.............. 62
5.9 Initializarea matricilor de pointeri................... 63
5.10 Comparatie Pointeri - Matrici multi-dimensionale....... 64
5.11 Argumente ale liniei de comanda........................ 64
5.12 Pointeri la functii.................................... 66
Capitolul 6. Structuri....................................... 69
6.1 Notiuni de baza........................................ 69
6.2 Structuri si functii................................... 70
6.3 Matrici de structuri................................... 71
6.4 Pointeri la structuri.................................. 73
6.5 Structuri auto-referite................................ 75
6.6 Cautarea tabelara...................................... 77
6.7 Cimpuri ("fields")..................................... 78
6.8 Uniuni................................................. 79
6.9 Definire de tip ("typedef")............................ 80
Capitolul 7. Intrari si iesiri............................... 82
7.1 Accesul la biblioteca standard......................... 82
7.2 Intrari si iesiri standard - getchar si putchar........ 82
7.3 Iesire cu format - printf.............................. 83
7.4 Intrar cu format - scanf............................... 84
7.5 Conversie de format in memorie......................... 85
7.6 Acces la fisiere....................................... 86
7.7 Trararea erorilor - stderr si exit..................... 87
7.8 Linia in intrare si iesire............................. 88
7.9 Diverse alte functii................................... 89
Capitolul 8. Interfata cu sistemul UNIX......................
8.1 Descriptori de fisier..................................
8.2 Intrari/iesiri de nivel inferior - read si write.......
8.3 Open, Creat, Close, Unlink.............................
8.4 Acces direct - seek si lseek...........................
8.5 Exemplu - fopen si getc implementat....................
8.6 Exemplu - listarea directorului........................
8.7 Exemplu - alocator de memorie..........................
Appendix A. Manual de referinta al limbajului C ............. 90
1. Introducere.............................................. 90
2. Conventii lexicale....................................... 90
3. Notatii de sintaxa....................................... 91
4. Ce este intr-un nume ? .................................. 91
5. Obiecte si "Lvalori"..................................... 92
6. Conversii................................................ 92
7. Expresii................................................. 93
8. Declaratii............................................... 98
9. Instructiuni.............................................104
10. Definitii externe........................................106
11. Reguli referitoare la vizibilitate.......................107
12. Linii de control al compilatorului.......................108
13. Declaratii implicite.....................................109
14. Rezumat despre tipuri....................................109
15. Expresii constante.......................................111
16. Consideratii despre portabilitate........................111
17. Anacronisme..............................................111
18. Rezumatul sintaxei.......................................112
Index.........................................................
P R E F A T A
C este un limbaj de programare cu scop general ale carui
caracteristici sint economia de expresie, structuri moderne
de control al fluxului si de date, precum si un set bogat de
operatori. C nu este un limbaj de nivel "foarte inalt", nici
"mare", si nu este specializat vreunei arii particulare de
aplicatii. Dar absenta in restrictii si generalitatea sa il fac
mai convenabil si mai de efect pentru mai multe scopuri decit
limbaje presupuse mai puternice.
C a fost la inceput proiectat si implementat pe sistemul de
operare UNIX pe DEC PDP11 de catre Dennis Ritchie. Sistemul de
operare, compilatorul C si in mod esential, toate programele de
aplicatii ale lui UNIX (inclusiv software-ul folosit pentru a
pregati cartea aceasta) sint scrise in C. Compilatoare de C exista
deasemenea si pe mai multe alte calculatoare, intre care IBM
System/370 Honeywell 6000 si Interdata 8/32. C nu este legat
de nici un hardware sau calculator anumit si e simplu de scris
programe care se pot executa fara nici o modificare pe
diferite calculatoare care au limbajul C implementat.
Aceasta carte are drept scop sa-l ajute pe cititor sa invete sa
programeze in C. Ea contine o initiere, pentru ca noii
utilizatori sa poata incepe cit mai repede posibil, capitole
separate pentru fiecare caracteristica majora, si un manual de
referinta. Marea parte a textului nu se bazeaza atit pe expunerea
de reguli si propozitii cit pe citirea, scrierea si revizuirea de
exemple. In cea mai mare parte exemplele sint programe reale si
sint complete si nu fragmente izolate. Toate exemplele au fost
testate direct din text, care este intr-o forma citibila pe
calculator. Pe linga faptul ca am aratat cum se utilizeaza efectiv
limbajul, am incercat in plus, acolo unde era posibil, sa-l
ilustram cu algoritmi utili si cu principii de bun stil in
programare si proiectare sanatoasa.
Aceasta carte nu este un manual introductiv de programare. Ea
presupune anumite familiaritati cu conceptele de baza din
programare, ca variabile, instructiuni de asignare, bucle,
functii. Cu toate acestea, un programator novice va fi in stare sa
citeasca cartea si sa-si insuseasca limbajul, chiar daca ajutorul
unui coleg cu experienta mai mare i-ar usura munca foarte
mult. In experienta noastra, C s-a dovedit un limbaj placut,
expresiv si adaptabil pentru o mare varietate de programe. Este
usor de invatat si "se poarta bine" pe masura ce experienta in
programare cu el creste. Speram ca aceasta carte va va ajuta sa-l
folositi bine.
Criticile si sugestiile multor prieteni si colegi au imbogatit
si imbunatatit mult aceasta carte si au marit placerea noastra
de a o scrie. In particular, Mike Bianchi, Jim Blue, Stu
Feldman, Doug McIlroy, Bill Roome, Bob Rosin si Larry Rosler au
citit cu totii multiplele versiuni cu grija. Sintem asemenea
indatorati lui Al Aho, Steve Bourne, Dan Dvorak, Chuck Haley,
Debbie Halley, Marion Harris, Rick Holt, Steve Johnson, John
Mashey, Bob Mitze, Ralph Muha, Peter Nelson, Elliot Pinson, Bill
Plauger, Jerry Spivack, Ken Thompson si Peter Weinberger pentru
comentariile pline de ajutor in diferitele stadii si lui Mike Lesk
si Joe Ossanna pentru asistenta nepretuita in tiparirea lucrarii.
Brian W. Kernighan
Dennis M. Ritchie
CAPITOLUL 0. I N T R O D U C E R E
C este un limbaj de programare cu scop general. El este
puternic legat de sistemul UNIX, deoarece a fost dezvoltat pe
acest sistem si deoarece UNIX-ul si software-ul sau sint scrise
in C. Cu toate acestea, limbajul nu este legat de un anume sistem
de operare sau calculator; si, desi a fost numit "limbaj de
programare sistem", deoarece este util in scrierea sistemelor de
operare, el a fost folosit la fel de bine in scrierea de
programe importante ce trateaza probleme numerice, prelucrari de
texte sau baze de date.
C este un limbaj relativ "de nivel inferior". Aceasta
caracterizare nu este peiorativa; ea inseamna pur si simplu ca C
opereaza cu aceeasi clasa de obiecte cu care lucreaza
majoritatea calculatoarelor, si anume caractere, numere si
adrese. Acestea pot fi combinate si prelucrate cu operatori
aritmetici si logici implementati pe actualele calculatoare.
C nu poseda operatii pentru a prelucra direct obiecte compuse, cum
ar fi siruri de caractere, multimi, liste sau tablouri
considerate ca un intreg. Nu exista nici o analogie, de exemplu,
cu operatiile din PL/1 care manipuleaza un intreg tablou sau sir.
Limbajul nu defineste nici o alta facilitate de alocare de
memorie in afara de definitiile statice si de lucrul cu
stiva folosite de variabilele locale ale functiilor; nu exista
colectii reziduale sau de gramezi ca in Algol 68. In sfirsit,
limbajul C in sine nu are facilitati de intrare-iesire: nu
exista instructiuni READ sau WRITE si nici metode de acces la
fisiere, "cablate" in limbaj. Toate aceste mecanisme de
nivel inalt trebuiesc facute prin apeluri explicite de functii.
In mod similar, C ofera numai constructii directe, liniare
de control al fluxului: teste, bucle, grupari, si
subprograme, insa nu multiprogramare, operatii paralele,
sincronizari sau corutine.
Cu toate ca absenta acestor caracteristici ar parea o grava
deficienta ("Vrei sa spui ca trebuie sa apelez o functie
pentru a compara doua siruri de caractere ?"), pastrarea
limbajului la o dimensiune modesta a adus beneficii reale.
Deoarece C este relativ mic, el poate fi descris intr-un spatiu
redus si invatat repede. Un compilator pentru C poate fi
simplu si compact. Compilatoarele sint deasemenea usor de scris;
folosind tehnologia curenta, ne putem astepta la un timp de citeva
luni pentru scrierea unui compilator nou si sa avem surpriza ca
80% din codul noului compilator este comun cu cele existente.
Aceasta dovedeste marele grad de mobilitate a limbajului. Deoarece
tipurile de date si structurile de control posedate de C sint
suportate de majoritatea calculatoarelor existente, biblioteca
necesara executiei [run - time] necesara pentru a implementa
programele independente este minuscula. Pe PDP-11, de exemplu,
ea contine numai rutinele pentru inmultirea si impartirea pe
32 de biti si subrutinele ce realizeaza secventele de inceput si
de sfirsit. Desigur, fiecare implementare poseda o biblioteca
cuprinzatoare si compatibila de functii pentru a indeplini
functiile de I/O, a trata sirurile si operatiile de alocare de
memorie dar, deoarece se apeleaza numai explicit, poate fi
evitata daca e nevoie; ea poate fi scrisa portabil chiar in C.
Din nou, deoarece limbajul reflecta capacitatile
calculatoarelor curente, programele C tind sa fie suficient
de eficiente astfel ca nu exista nici o constringere pentru a
le scrie in limbajul de asamblare. Cel mai evident exemplu in
acest sens este chiar sistemul de operare UNIX, care este scris
aproape in intregime in C. Din cele 13000 de linii de cod ale
sistemului, numai aproximativ 800 de linii de la nivelul cel mai
de jos sint scrise in limbajul de asamblare. In plus, software-ul
pentru toate aplicatiile UNIX esentiale este scris in C; marea
majoritate a utilizatorilor UNIX (inclusiv unul din autorii
acestei carti) nici macar nu cunosc limbajul de asamblare al lui
PDP-11.
Cu toate ca C se potriveste cu caracteristicile multor
calculatoare, el este independent de arhitectura oricarui
calculator particular si astfel, cu putina grija, este usor a
scrie programe "portabile", adica programe care pot fi rulate
fara modificari pe varietate de calculatoare. In mediul nostru
este deja un fapt obisnuit ca programele dezvoltate pe UNIX
sa fie transportate pe sistemele Honeywell, IBM si Interdata.
In realitate, compilatoarele de C si suportul de executie
pentru aceste patru tipuri de calculatoare sint mai
compatibile decit versiunile presupuse standard ANSI pentru
FORTRAN. Sistemul de operare UNIX insusi se executa acum atit pe
PDP-11 cit si pe Interdata 8/32. In afara programelor care, in
mod necesar, sint intrucitva dependente de tipul de calculator,
ca: asamblorul, compilatorul, depanatorul - software-ul scris in
C este identic pe ambele calculatoare. Chiar in cadrul
sistemului de operare, 7000 de linii de cod, in afara suportului
pentru limbajul de asamblare si handlerelor dispozitivelor de I/O
este identic in proportie de 95%.
Pentru programatorii familiari cu alte limbaje, se poate
dovedi util sa mentionam citeva aspecte istorice, tehnice si
filosofice legate de C, pentru contrast si comparatie.
Multe din cele mai importante idei din C isi au radacina in
limbajul -de acum suficient de batrin, dar inca viabil - BCPL,
dezvoltat de Martin Richards. Influenta lui BCPL asupra lui C
apare indirect prin limbajul B, care a fost scris de Ken Thompson
in 1970 pentru primul sistem UNIX pe un PDP-7.
Cu toate impartaseste multe caracteristici esentiale cu BCPL,
limbajul C nu este in nici un sens un dialect al acestuia.
Limbajele BCPL si B sint limbaje "fara tipuri"[typeless]:
singurul tip de data este cuvintul masina, si accesul la alte
tipuri de obiecte se face cu operatori speciali sau apeluri de
functii. In C obiectele (datele) fundamentale sint
caracterele, intregii de diferite dimensiuni si numerele
flotante. In plus, exista o ierarhie de tipuri de date derivate
create cu pointeri, tablouri, structuri, uniuni si functii.
Limbajul C poseda constructiile fundamentale pentru controlul
fluxului necesare pentru programele bine structurate: grupare de
instructiuni; luare de decizii ("if"); buclare cu test de
terminare la inceput ("while", "for") sau la sfirsit ("do"),
selectare a unui caz dintr-o multime de cazuri posibile
("switch"). (Toate acestea erau valide si in BCPL, chiar daca cu
o sintaxa diferita; acest limbaj anticipa voga pentru "programare
structurata" cu mai multi ani inainte).
Limbajul C foloseste pointeri si are abilitatea de a face
aritmetica cu adrese. Argumentele functiilor sint pasate
copiind valoarea argumentului si este imposibil pentru functia
apelata sa modifice argumentul real din apelant. Cind se doreste
sa se obtina un "apel prin referinta", se trimite explicit un
pointer, iar functia poate modifica obiectul la care puncteaza
pointerul. Numele de tablouri sint trimise ca locatie a
originii tabloului, asa ca argumentele tablouri sint efectiv
apeluri prin referinta.
Orice functie poate fi apelata recursiv si variabilele
sale sint tipic "automate" sau create nou cu fiecare invocare.
Definitiile de functii nu pot fi imbricate dar variabilele pot
fi declarate in maniera de bloc structurat. Functiile unui
program C pot fi compilate separat. Variabilele pot fi interne
unei functii, externe dar cunoscute numai intr-un singur
fisier sursa, sau complet globale. Variabilele interne pot fi
automate sau statice. Variabilele automate pot fi in registre
pentru eficienta marita, dar declaratia de registru este numai
interna compilatorului si nu se refera la vreun registru specific
al calculatorului.
Limbajul C nu este un limbaj puternic tipizat in sensul lui PASCAL
sau Algol - 68. El este relativ liberal in conversia de date, cu
toate ca nu converteste automat tipurile de date cum ar fi
PL/1. Compilatoarele existente nu poseda verificare la executie
a indicilor elementelor de tablouri, tipurilor argumentelor,
etc.
Pentru acele situatii in care se cere o puternica verificare
a tipului, se foloseste o versiune separata a compilatorului.
Acest program se numeste "lint" deoarece triaza bitii dubiosi of
fluff dintr-un program. El nu genereaza cod, verifica numai
foarte strict multe aspecte ale programelor asa cum pot fi
verificate la compilare si la incarcare. El detecteaza
nepotrivirile de tip, folosirea inconsistenta a argumentelor,
variabilele nefolosite sau aparent neinitializate, dificultatile
potentiale de portabilitate si alte asemenea aspecte.
Programele care trec cu bine aceasta verificare, cu citeva
exceptii, se elibereaza de erorile de tip la fel de complet ca si,
de exemplu, programele scrise in Algol 68. Vom mentiona si alte
capacitati ale lui "lint" atunci cind ni se va ivi ocazia.
In fine, limbajul C, ca si alte limbaje, are defectele sale. Unii
din operatori au o pondere gresita; o parte sau parti ale
sintaxei ar fi putut fi mai bune; exista mai multe versiuni ale
limbajului diferind foarte putin una de alta. Cu toate acestea,
limbajul C s-a dovedit a fi un limbaj extrem de eficace si
expresiv pentru o larga varietate de aplicatii de programare.
Restul cartii este organizat dupa cum urmeaza. Capitolul 1 este
o initiere in partea centrala a limbajului C. Scopul lui este sa
faca cititorul sa inceapa sa programeze in C cit mai repede
posibil, deoarece noi credem puternic ca singurul mod de a
invata un limbaj nou este de a se scrie programe in el.
"Initierea" presupune o cunoastere a elementelor de baza ale
programarii; nu se dau explicatii despre calculatoare,
compilatoare si nici despre semnificatia unor expresii ca,
de exemplu, n = n + 1. Cu toate ca am incercat pe cit posibil sa
aratam tehnici de programare utile, cartea aceasta nu se vrea de
referinta in structuri de date si algoritmi; cind am fost fortati
sa alegem, ne-am concentrat asupra limbajului.
Capitolele 2-6 discuta diferite aspecte ale limbajului C mai
detaliat si mai formal decit o face Capitolul 1, cu toate ca
accentul cade tot pe exemple de programe utile complete si nu
pe fragmente izolate. Capitolul 2 se ocupa cu tipurile de date
fundamentale, operatorii si expresiile. Capitolul 3 trateaza
controlul fluxului: if-else, while, for, etc. Capitolul 4 acopera
functiile si structura programului -variabile externe, reguli
de domeniu, si asa mai departe. Capitolul 5 discuta
pointerii si aritmetica adreselor. Capitolul 6 contine detalii
despre structuri si uniuni.
Capitolul 7 descrie biblioteca C standard de I/O care
asigura o interfata bisnuita cu sistemul de operare. Aceasta
biblioteca de I/O este tratata pe oate calculatoarele care suporta
limbajul C, asa ca programele care o folosesc entru intrari,
iesiri si alte functii sistem pot fi mutate de pe un sistem pe
altul in principal fara modificari.
Capitolul 8 descrie interfata intre programele C si sistemul de
operare UNIX, concentrindu-se asupra operatiilor de
intrare/iesire, sistemului de fisiere si portabilitatii. Cu
toate ca acest capitol este oarecum specific pentru UNIX,
programatorii care nu folosesc acest sistem pot gasi si aici un
material util, inclusiv o privire asupra modului in care
este implementata o versiune a bibliotecii standard, precum si
sugestii pentru a obtine un cod portabil.
Anexa A contine manualul de referinta al limbajului C. Acesta
este declaratia "oficiala" a sintaxei si semanticii lui C si
(exceptind compilatoarele proprii) arbitrul final al oricarui
ambiguitati sau omisiuni din capitolele precedente.
Deoarece C este un limbaj in dezvoltare care exista pe o
varietate de calculatoare, anumite parti din aceasta carte
pot sa nu mai corespunda cu stadiul curent de dezvoltare pentru un
sistem particular. Am incercat sa evitam aceste probleme si sa
atentionam asupra potentialelor dificultati. Cind am fost in
dubiu, am ales in general descrierea situatiei PDP-11 UNIX, care
este mediul de lucru al majoritatii programatorilor in C.
Anexa A contine deasemenea diferentele de implementare pentru
C pe sistemele majore pe care el poate fi gasit.
CAPITOLUL 1. I N I T I E R E
Sa incepem cu o introducere rapida in C. Scopul nostru este
sa preezentam elementele esentiale ale limbajului in programe
reale, fara insa a ne impotmoli in detalii, reguli formale si
exceptii. In acest punct al expunerii nu incercam sa fim completi
si nici macar foarte precisi (mentionam totusi ca exemplele vor sa
fie corecte). Dorim sa va aducem cit mai repede posibil in
punctul in care veti fi capabili sa scrieti programe utile si,
pentru aceasta, ne-am concentrat asupra fundamentelor: variabile
si constante, aritmetica, controlul fluxului, functii si rudi-
mente de operatii de I/O. Am lasat deoparte intentionat din
acest capitol acele caracteristici ale limbajului C care sint
de importanta vitala in scrierea programelor mai mari. Acestea
includ pointerii, structurile, majoritatea din bogatul set de
operatori ai lui C, anumite instructiuni de control al fluxului si
o multime de detalii.
Acest mod de abordare are neajunsurile lui, desigur.
Cel mai notabil este acela ca povestea completa a caracteristici-
lor oricarui limbaj de programare nu este gasita intr-un singur
loc, iar o initiere in el, fiind scurta, poate induce in eroare.
Deoarece exemplele nu pot folosi intreaga putere a lui C, ele nu
sint atit de concise si de elegante pe cit ar putea fi. Am
incercat sa minimalizam aceste efecte, dar fiti atenti!
Un alt neajuns este acela ca in capitolele urmatoare vom
repeta in mod necesar cite ceva din acest capitol. Speram ca
aceasta repetitie va va ajuta mai mult decit va va plictisi.
In orice caz, programatorii experimentati vor fi capabili
sa extrapoleze din materialul din acest capitol propriile lor
nevoi de programare. Incepatorii vor putea scrie mici programe,
similare celor prezentate de noi. Ambele grupe pot folosi acest
capitol drept cadru pentru descrierile riguroase care incep cu
Capitolul 2.
|
|
)