|
|
səhifə | 41/55 | tarix | 07.05.2018 | ölçüsü | 4,6 Mb. | | #50260 |
| getch();
}
FUNCTIA strcspn() si _fstrcspn()
-compara doua siruri si selecteaza segmentul neidentic
SINTAXA GENERALA este:
size_t strcspn(const char *s1,const char *s2); [C] sau:
size_t far * far _fstrcspn(const char far *s1,const char far *s2); [C++]
Functia compara cele doua siruri si identifica segmentul initial din pri-
mul sir in care datele nu sunt identice cu cele din cel de al doilea sir.
Functia compara cele doua siruri pana la aparitia primului caracter comun
si returneaza numarul de caractere citite pana la identificarea primului
caracter comun.Nici unul dintre siruri nu este modificat in timpul compa-
ratiei,iar caracterul NULL terminal nu este adunat la rezultatul raportat.
Functia returneaza numarul de caractere neidentice (segmentul initial).
EXEMPLU: #include
#include
char *text1="1234567890";
char *text2="TAROM707";
char rezultat=" ";
int w;
main()
{ w=strcspn(text2,text1);
memccpy(rezultat,text2,'!',w);
printf("Primul caracter comun este in pozitia: %d \n",w+1);
printf("textul neidentic este: %s \n\n",rezultat);
printf(" ...apasati orice tasta...\n");
getch();
}
Functia se poate utiliza cu succes pentru a gasi un cuvant intr-un text
oarecare,sau pentru a compara doua baze de date de tip caracter,pentru
a identifica doua siruri identice,sau pentru a extrage elementele dis-
tincte din doua siruri de caractere etc.Se pot realiza algoritmi impreuna
cu alte functii (strcmp(),strcmpi(),memccpy(),memset() etc.).
-302- [ string.h-strdup() si _strerror() ]
FUNCTIA strdup() si _fstrdup()
-copiaza un sir la o adresa nou creata
SINTAXA GENERALA este: char *strdup(const char *s); sau:
char far * far _fstrdup(const char far *s); [C++]
Functia realizeaza un duplicat al sirului s (pointat de *s) la o noua
adresa,pentru care obtine spatiu apeland functia malloc().Spatiul alocat
va fi egal cu lungimea sirului+1 (strlen(s)+1) bytes.Dupa ce spatiul
alocat nu mai este necesar,utilizatorul va trebui sa elibereze acest
spatiu (cu free()),deoarece nu se elibereaza automat.
Functia returneaza un pointer spre adresa de locatie a sirului duplicat,
sau returneaza NULL daca spatiul necesar nu a putut fi alocat.
EXEMPLU: #include
#include
char *text="NUMELE SI PRENUMELE:";
char *duplicat1,*duplicat2;
main()
{ printf("Sursa= %s \n",text);
printf("textul duplicat este: \n\n");
duplicat1=strdup(text);
duplicat2=strdup(text);
printf("1-%s \n2-%s \n",duplicat1,duplicat2);
printf(" ...apasati o tasta... \n");
getch();
free(duplicat1);
free(duplicat2);
}
FUNCTIA _strerror()
-construieste un mesaj de eroare personalizat
SINTAXA GENERALA este: char *_strerror(const char *s);
Functia permite construirea unui mesaj de eroare personalizat(adica puteti
adauga un text oarecare inaintea mesajului de eroare returnat automat).
Functia returneaza un pointer spre sirul care contine mesajul de eroare.
Daca sirul pointat este NULL,functia va returna cel mai recent mesaj de
eroare arhivat in memorie.Daca sirul *s nu este NULL,functia va returna
continutul sirului(mesajul personalizat),apoi doua puncte,un spatiu gol si
ultimul mesaj de eroare generat automat.Sirul *s trebuie sa contina maxim
194 de caractere (sirul total sa nu depaseasca 250 de caractere).
Functia returneaza un pointer spre sirul astfel construit.Sirul final este
construit intr-un tampon static de memorie,care este suprascris la fiecare
apelare a functiei _strerror().
EXEMPLU: #include
#include
char *mesaj,*text="Ultimul cod de eroare este";
int x,y;
main()
{ fopen("bgidemo.exe","a");
mesaj=_strerror(text);
printf("%s \n",mesaj);
printf(" ...apasati orice tasta... \n");
getch(); }
-303- [string.h-strerror,stricmp,strlen ]
FUNCTIA strerror()
-returneaza un pointer spre un mesaj de eroare
SINTAXA GENERALA este: char *strerror(int errnum);
Functia returneaza un pointer spre mesajul de eroare specificat prin codul
numeric errnum(un numar de tip int).Numarul de cod al mesajului de eroare
este acelasi cu cel utilizat de variabila globala errno pentru arhivarea
automata a erorilor generate de compilare(Exemple: 2=ENOENT-no such file
or directory etc. -codurile pot fi diferite de la o versiune la alta !)
Functia returneaza un pointer spre sirul care contine mesajul de eroare.
Sirul este construit intr-un tampon de memorie static si este suprascris
la fiecare apelare a functiei strerror().
EXEMPLU: #include
#include
#include
char *mesaj;
int x;
main()
{ for (x=1;x<23;x++)
{ mesaj=strerror(x);
printf("Cod eroare=%d Mesaj=%s \n",x,mesaj);
sleep(2);
}
sleep(5);
}
FUNCTIA stricmp(),_fstricmp()
-compara doua siruri (nu tine cont de majuscule si minuscule)
SINTAXA GENERALA este: int stricmp(const char *s1,const char *s2); sau:
int far _fstricmp(const char far *s1,const char far *s2); [C++]
Functia compara cele doua siruri,incepand cu primul caracter din fiecare
sir,fara sa tina cont de majuscule sau minuscule.Este identica cu strcmpi.
Functia returneaza o valoare negativa daca s1 este mai mic decat s2,zero
daca sirurile sunt identice sau o valoare pozitiva daca s1 este mai mare
decat s2.
EXEMPLU: #include
#include
char *text1="123xxABC";
char *text2="123XXabc";
main()
{ printf("strcmp returneaza: %d\n",strcmp(text1,text2));
printf("iar stricmp returneaza: %d\n",stricmp(text1,text2));
printf(" ...apasati orice tasta... \n");
getch(); }
FUNCTIA strlen() si _fstrlen()
-calculeaza lungimea unui sir
SINTAXA GENERALA este: size_t strlen(const char *s); sau:
size_t far _fstrlen(const char far *s); [C++]
Functia calculeaza si returneaza lungimea sirului spre care pointeaza *s,
fara a include si caracterul NULL terminal.
Functia returneaza lungimea sirului (un numar unsigned int)
-304- [string.h-strlwr() si strncat() ]
EXEMPLU: #include
#include
char *text[80];
size_t x;
main()
{ printf("Introduceti un sir de caractere: \n");
scanf("%s",&text);
x=strlen(text);
printf("Sirul introdus contine: %u caractere \n",x);
printf(" ...apasati orice tasta... \n");
getch();
}
FUNCTIA strlwr() si _fstrlwr()
-converteste toate majusculele din sir in minuscule
SINTAXA GENERALA este: char *strlwr(char *s); sau
char far * far _fstrlwr(char char far *s); [C++]
Functia converteste toate caracterele scrise cu majuscule in caractere
scrise cu litera mica,corespunzatoare celor din categoria LC_CTYPE(adica
in caracterele curente utilizate pentru editare).Conversia se aplica doar
pentru literele de la A la Z (nu si pentru caracterele speciale).
Functia returneaza un pointer spre sirul astfel modificat.
EXEMPLU: #include
#include
char *text="NAPOLEON BONAPARTE";
main()
{ printf("textul initial este: %s \n",text);
printf("Textul modificat este: %s \n",strlwr(text));
printf("...apasati orice tasta... \n");
getch();
}
FUNCTIA strncat() si _fstrncat()
-adauga un fragment de sir la alt sir
SINTAXA GENERALA este:
char *strncat(char *dest,const char *src,size_t maxlen); sau
char far *far _fstrncat(char far *dest,const char far *src,size_t maxlen);
Functia copiaza numarul de caractere specificat prin maxlen,din sirul src
(sirul sursa pointat de *src) la sfarsitul sirului de destinatie (dest).
Sirul rezultat va avea lungimea totala egala cu suma celor doua fragmente
componente (strlen(dest)+maxlen).
Functia returneaza sirul rezultat (dest).
EXEMPLU: #include
#include
char *text;
main()
{ text=strncat("Text initial","3.141592",7);
printf("textul rezultat este: %s \n",text);
printf(" ...apasati orice tasta...\n");
getch();
}
-305- [string.h -strncmp() ]
EXEMPLUL 2: #include
#include
#include
char *sursa="Text demonstrativ ";
char destinatie[40];
int x;
main()
{ for (x=1;x<20;x++)
{ strncat(destinatie,sursa,x);
printf("S-au atasat: %d caractere \n\n",x);
printf("Sirul rezultat este: %s \n",destinatie);
sleep(1);
strcpy(destinatie," ");
}
sleep(3);
}
FUNCTIA strncmp() si _fstrncmp()
-compara cate un fragment din doua siruri diferite (primul fragment)
SINTAXA GENERALA este:
int strncmp(const char *s1,const char *s2,sixe_t maxlen);
int far _fstrcmp(const char far *s1,const char far *s2,size_t maxlen);
Functia este identica cu strcmp() dar compara doar primele maxlen caracte-
re din cele doua siruri.Comparatia este de tip unsigned (valoarea ASCII)
si incepe cu primul caracter din primul sir pana la cel specificat prin
maxlen (un numar unsigned int de caractere),sau pana cand intervine primul
caracter diferit.
Functia returneaza rezultatul comparatiei astfel: ==0 daca cele doua frag-
mente sunt perfect identice,<0 daca primul sir este mai mic(caracterul ce
difera este mai mic) sau >0 daca primul sir este mai mare(primul caracter
diferit are valoare ASCII mai mare in primul sir).
EXEMPLU: #include
#include
char *text1="123abcd";
char *text2="123abcW";
int x,numar;
{ for (x=1;x<8;x++)
{ numar=strncmp(text1,text2,x);
if (numar==0)
printf("primele: %d caractere sunt identice \n",x);
else
printf("dupa: %d caractere sirurile sunt diferite \n",x-1);
};
printf(" ...apasati orice tasta...\n");
getch();
}
Comparatia celor doua fragmente este stricta si tine cont si de majuscule
si minuscule(compara valoarea ASCII a caracterului).Functiile similare
strncmpi() si strnicmp() sunt identice dar nu fac diferenta intre majus-
cule si minuscule ( a si A sunt considerate identice si returneaza zero).
Ambele apeleaza strncmp() + o rutina de conversie a majusculelor.
-306- [ strncmpi(),strncpy() si strnicmp()]
FUNCTIA strncmpi()
-compara cate un fragment din doua siruri (nu tine cont de majuscule)
SINTAXA GENERALA este:
int strncmpi(const char *s1,const char *s2,size_t n);
Functia este similara cu strncmp() dar nu tine cont de majuscule (X=x).
EXEMPLU: vezi strncmp()
FUNCTIA strncpy() si _fstrncpy()
-copiaza un numar de bytes dintr-un sir in altul
SINTAXA GENERALA este:
char *strncpy(char *dest,const char *src,sixe_t maxlen);
char far *far _fstrncpy(char far *dest,const char far *src,size_t maxlen);
Functia copiaza numarul de bytes precizati prin maxlen,din sirul sursa
(src) in sirul de destinatie (dest).Pentru specificarea sirurilor se vor
utiliza pointeri.Copierea se va face prin trunchierea sau extinderea si-
rului de destinatie,dupa cum este cazul.In caz ca sirul sursa este mai
lung decat cel de destinatie,sirul rezultat nu va mai contine caracterul
NULL terminal (nu este adaugat automat).
Functia returneaza sirul rezultat (pointerul spre sirul rezultat).
EXEMPLU: #include
#include
#include
char *sursa="Mesaj urgent !!!";
char *destinatie="...................textul initial ";
int x;
main()
{ for (x=1;x<17;x++)
{
printf("Dupa copierea celor: %d caractere \n",x);
strncpy(destinatie,sursa,x);
printf("Sirul rezultat este: %s \n\n",destinatie);
sleep(1);
};
printf("...apasati orice tasta... \n");
getch();
}
FUNCTIA strnicmp() si _fstrnicmp()
-compara doua fragmente din siruri diferite (nu tine cont de majuscule)
SINTAXA GENERALA este:
int strnicmp(const char *s1,const char *s2,size_t maxlen);
int far _fstrnicmp(const char far *s1,const char far *s2,size_t maxlen);
Functia este identica cu strncmpi() si similara cu strncmp() dar cu deo-
sebirea ca nu tine cont de majuscule.
Atat strncmpi() cat si strnicmp() sunt implementate cu macro-uri si pentru
executie apeleaza la functia strncmp() si respectiv la o rutina de con-
versie a majusculelor in minuscule,astfel incat comparatia sa se poata
face numeric,de tip unsigned int,utilizand codul numeric ASCII al carac-
terelor.
EXEMPLU: vezi functia strncmp() si strcmpi() sau stricmp()
Incercati sa editati un exemplu cat mai elocvent.
-307- [string.h-strnset() si strnpbrk() ]
FUNCTIA strnset() si _fstrnset()
-seteaza un numar de caractere dintr-un sir
SINTAXA GENERALA este: char *strnset(char *s,int ch,size_t n); sau
char far * far _fstrnset(char far *s,int ch,size_t n); [C++]
Functia copiaza caracterul specificat prin 'ch' in primii n bytes din
sirul de destinatie (specificat prin pointerul *s).Daca numarul specificat
prin n este mai mare decat lungimea totala a sirului,atunci numarul n va
fi inlocuit prin strlen(s),adica prin numarul de caractere al sirului de
destinatie.Setarea caracterelor se face pana cand se ajunge la caracterul
n,sau pana cand se ajunge la caracterul NULL terminal (sirul initial nu
poate fi extins ci doar resetat).
Functia returneaza sirul rezultat (pointerul spre sir).
EXEMPLU: #include
#include
#include
char *text="123456789abcd";
int x;
main()
{ for (x=0;x<15;x++)
{ strnset(text,'*',x);
printf("x=%d \n",x);
printf("Textul rezultat este: %s \n",text);
sleep(1);
};
sleep(3);
}
FUNCTIA strpbrk() si _fstrpbrk()
-cauta intr-un sir,prima aparitie a oricarui caracter dintr-un alt sir.
SINTAXA GENERALA este: char *strpbrk(const char *s1,const char *s2); sau
const char far * far _fstrpbrk(const char far *s1,const char far *s2);
Functia scaneaza (verifica) sirul s1,pana la prima aparitie a oricarui
caracter dintre cele continute in sirul s2.Cautarea nu tine cont de ma-
juscule (a si A sunt considerate identice).
Functia returneaza un pointer de tip caracter spre primul caracter din
sirul s1 care este continut si in sirul s2.Daca nici unul dintre caracte-
rele din sirul s2 nu se regaseste si in sirul s1,functia returneaza NULL.
EXEMPLU: #include
#include
char *text="Numele si Prenumele = RUSU VICTOR STEFAN";
char *parola="Stefan";
char *rezultat;
main()
{ rezultat=strpbrk(text,parola);
if (rezultat)
printf("Primul caracter identificat este: %c \n",*rezultat);
else
printf("Sirurile sunt complet diferite ! \n");
printf(" ...apasati orice tasta...\n");
getch();
}
-308- [strrchr(),strrev() si strset() ]
FUNCTIA strrchr() si _fstrrchr()
-cauta intr-un sir ultima aparitia a unui caracter indicat
SINTAXA GENERALA este: char *strrchr(const char *s,int c); [C] sau
const char _fstrrchr(const char far *s,int c); [C++]
char *strrchr(char *s,int c); [C++]
char *_fstrrchr(char far *s,int c); [C++]
Functia cauta in sirul s ultima aparitie a caracterului c.Cautarea
include si caracterul NULL terminal.
Functia returneaza un pointer spre ultima aparitie din sirul s a carac-
terului c.Daca nu gaseste caracterul c in sirul s,functia returneaza NULL
EXEMPLU: #include
#include
char *text="Continutul bazei de date";
char x,*z;
main()
{ printf("Introduceti un caracter oarecare: \n);
scanf("%c",&x);
z=strrchr(text,x);
if (z)
printf("Caracterul %c este inclus in baza de date \n",x);
else
printf("Caracterul %c nu este in baza de date \n",x);
printf(" ...apasati orice tasta... \n");
getch();
}
FUNCTIA strrev() si _fstrrev()
-inverseaza ordinea caracterelor dintr-un sir
SINTAXA GENERALA este: char *strrev(char *s); sau
char far * far _fstrrev(char far *s); [C++]
Functia inverseaza ordinea pentru toate caracterele din sir,cu exceptia
caracterului NULL terminal (exemplu: string\0 devine gnirts\0 )
Functia returneaza un pointer spre sirul rezultat.
EXEMPLU: #include
#include
char *text="Abecedar de programare in limbaj C";
main()
{ printf("textul initial este: \n");
printf("%s \n",text);
printf("Textul inversat este: \n %s \n",strrev(text));
printf("...apasati orice tasta...\n");
getch();
}
FUNCTIA strset() si _fstrset()
-seteaza toate caracterele din sir la caracterul indicat
SINTAXA GENERALA este: char *strset(char *s,int ch);
char far far *_fstrset(char far *s,int ch); [C++]
Functia inlocuieste toate caracterele din sirul s cu caracterul specificat
prin ch.Functia se executa pana cand intalneste caracterul NULL terminal.
Functia returneaza sirul rezultat (pointerul spre sir).
-309- [ string.h-strspn() si strstr() ]
EXEMPLU: #include
#include
char *text1="Cont 001=123456";
char *text2="Cont 002=765432";
char *text3="Cont 003=567890";
main()
{ printf("%s %s %s \n",text1,text2,text3);
strset(text1,'*');
strset(text2,'?');
strset(text3,'!');
printf("Dupa resetare,datele arata astfel: \n");
printf("%s %s %s \n",text1,text2,text3);
printf(" ...apasati orice tasta...\n");
getch();
}
FUNCTIA strspn() si _fstrspn()
-cauta intr-un sir,un subset de date(fragmentul initial)
SINTAXA GENERALA este: size_t strspn(const char *s1,const char *s2);
si size_t far _fstrspn(const char far *s1,const char far *s2); [C++]
Functia identifica in primul segment initial din sirul s1 datele care sunt
perfect identice cu cele din sirul s2 (scaneaza sirul s1 pentru a identi-
fica fragmentul s2).
Functia returneaza lungimea segmentului din sirul s1 care este perfect
identica cu datele din sirul s2 (caracter cu caracter,incepand cu primul).
Valoarea returnata este un numar de tip unsigned int.
EXEMPLU: #include
#include
char *parola="Administrator";
char *text="Admitere";
int nr;
main()
{ nr=strspn(parola,text);
printf("Al doilea sir,este diferit dupa: %d bytes \n",nr);
printf(" ...apasati orice tasta...\n");
getch();
}
FUNCTIA strstr() si _fstrstr()
-cauta intr-un sir,un subset de date(indiferent de pozitia in sir)
SINTAXA GENERALA este: char *strstr(const char *s1,const char *s2);
si char far * far _fstrstr(const char far *s1,const char far *s2); [C++]
Functia cauta in sirul s1,un fragment, specificat prin sirul s2.Functia
este similara cu strspn() dar identifica subsetul de date in orice pozitie
din sir(nu doar in fragmentul initial).
Functia returneaza un pointer de tip caracter spre elementul din sirul
s1 de la care incepe corespondenta cu fragmentul continut in sirul s2.
Functia returneaza NULL in cazul in care fragmentul de date specificat
prin s2 nu se regaseste in sirul s1.
Functia se utilizeaza mai ales pentru a cauta un anumit cuvant,sau un
anumit simbol,intr-un text sau intr-un sir de caractere.
-310- [ string.h-strtok() ]
EXEMPLU: #include
#include
char *text1="Banca Nationala";
char *text2="ion";
char *text3="anca";
char *rezultat;
main()
{ rezultat=strstr(text1,text2);
printf("%s apare in %s astfel: \n %s \n",text2,text1,rezultat);
rezultat=strstr(text1,text3);
printf("%s apare in %s astfel: \n %s \n",text3,text1,rezultat);
printf(" ...apasati orice tasta... \n");
getch(); }
FUNCTIA strtok() si _fstrtok()
-cauta intr-un sir,elementele delimitate printr-un separator specificat
SINTAXA GENERALA este: char *strtok(char *s1,const char *s2); sau
char far * far _fstrtok(char far *s1,const char far *s2); [C++]
Functia cauta in sirul s1,elementele distincte(token) separate intre ele
prin delimitatorul specificat prin s2(de tip caracter constant).Prin token
se intelege in termeni generali,cel mai mic element distinct din program
(poate fi un caracter,o cifra,un cuvant,o comanda,o functie,un sir etc.).
Primul apel la functia strtok() returneaza un pointer spre primul caracter
(byte) din primul token identificat in sirul s1 si apoi adauga un caracter
NULL imediat dupa tokenul identificat(NULL terminator de sir).Orice apel
ulterior la functia strtok() avand ca prim argument NULL,va identifica
urmatorul token(element) din sir,pana la epuizarea sirului.Este esential
ca toate elementele sirului sa fie separate prin acelasi delimitator,care
trebuie specificat ca argument secund la functiei (EXEMPLE: el1,el2,el3
sau element1*element2*element3*element4 etc.).
Functia poate fi apelata succesiv si pentru delimitatori diferiti,astfel
incat sirul de date sa poata fi separat in elemente diferite(tokeni)
( Exemplu: *el,element1,*el2,element2,*el3,element3,* etc.).
Apelurile la functia strtok() nu pot fi intricate in interiorul unei alte
functii strtok()(strtok(strtok()),deoarece se formeaza o bucla infinita.
Functia returneaza un pointer spre token,sau NULL la capatul sirului.
EXEMPLU: #include
#include
char *text1="lapte,oua,carne,branza,paine,ciocolata";
char *text2=",";
char *rezultat;
int x;
main()
{ printf("sirul initial este: %s \n",text1);
rezultat=strtok(text1,text2);
printf("Primul token(element) este: %s \n",rezultat);
for(x=1;x<6;x++)
{ rezultat=strtok(NULL,text2);
printf("Urmatorul token(element) este: %s \n",rezultat); }
printf(" ...apasati orice tasta... \n");
getch(); }
-311- [ string.h- strupr() ]
FUNCTIA strupr() si _fstrupr()
-converteste minusculele in majuscule
SINTAXA GENERALA este: char *strupr(char *s);
char far * far _fstrupr(char far *s);
Functia converteste literele mici in litere majuscule,corespunzator cu
fonturile curente din categoria LC_CTYPE.Functia afecteaza doar literele
de la a la z (convertite in A la Z),restul caracterelor sunt neafectate.
Functia returneaza sirul rezultat (pointerul spre sir).
EXEMPLU: #include
#include
char *text="cluj-napoca";
main()
{ printf("textul initial este: %s \n",text);
printf("scris cu majuscule devine: %s \n",strupr(text));
printf(" ...apasati orice tasta...\n");
getch();
}
CONSTANTE,TIPURI DE DATE SI VARIABILE GLOBALE
Singura constanta utilizata in fila antet este size_t
size_t -este o constanta de tip unsigned int si este definita in stddef.h
ca operator pentru sizeof().
OBSERVATII GENERALE:-functiile continute in fila permit ana-
liza automata si diverse operatii efectuate asupra datelor de tip caracter
arhivate sub forma de siruri.Sirurile de caractere pot contine si cifre,
dar acestea nu trebuiesc confundate cu valorile numerice ale acestor cifre
care trebuiesc utilizate ca valori de tip int,float etc. O eroare foarte
frecventa este cea de apela functii ce opereaza cu valori numerice,pentru
cifre arhivate sub forma de caractere.Spre deosebire de alte medii de
programare,limbajul C utilizeaza un format de date diferit pentru valorile
numerice,fata de cele de tip caracter.Se pot realiza totusi o serie de
operatii matematice asupra datelor de tip caracter,dar numai prin formarea
de bucle si de algoritmi repetitivi,in care datele sunt prelucrate prin
formatul char dar in operatii automate succesive.Acest gen de artificii
de programare nu trebuie confundat cu operatiile matematice efectuate
asupra valorilor numerice.Aceasta limitare din limbajul C prezinta o
serie de inconveniente,dar si o serie de avantaje majore (datele arhivate
sub forma de caracter nu pot fi bulversate prin operatii matematice mai
mult sau mai putin bine definite).
Functiile implementate sunt relativ rudimentare,dar prin combinarea
lor se pot obtine rutine de prelucrare automata a textelor,rutine de
corectare automata a erorilor,rutine de scanare pentru identificarea sau
excluderea unor elemente din text,rutine de verificare a variabilelor de
tip caracter,rutine de copiere sau resetare a unor baze de date,etc.
Principalul avantaj fata de alte medii de programare,il reprezinta volu-
mul foarte redus de memorie utilizat pentru procesarea si arhivarea date-
lor.In plus,functiile din se pot combina cu cele grafice din
pentru a realiza forme mai atractive de prezentare a datelor.
Cu putina rabdare,se pot obtine rezultate entuziasmante.
-312- [ dos.h -absread() ]
BIBLIOTECA C-fila antet
-contine declaratii pentru functii,constante si variabile globale necesare
pentru apelurile la functiile DOS 8086 (functii bazate pe arhitectura de
procesor de tip Z80 si urmatoarele:8086,8286,8386,8486,8586 etc.)
Aceste functii apeleaza direct sistemul de operare si nu se recomanda
apelarea lor de catre incepatori,deoarece se pot obtine rezultate greu de
anticipat.Este bine sa nu utilizati aceste functii decat dupa ce a-ti
inteles modul de lucru si formatul datelor din sistemul DOS.
FUNCTIA absread()
-citeste sectoare de pe disc
SINTAXA GENERALA este:
int absread(int drive,int nsects,int 1-sect,void *buffer);
Functia citeste numarul de sectoare specificat prin nsect,de pe unitatea
de disc specificata prin drive,incepand cu sectorul specificat prin 1-sect
si salveaza datele in tamponul de memorie specificat prin *buffer.Pentru
unitatea de disc se utilizeaza conventia curenta: 0=A,1=B,2=C etc. iar
pentru 1-sect se utilizeaza sectoarele logice,incepand cu primul (primul
sector este sectorul 0=sectorul de boot).
Functia returneaza 0 in caz de succes sau -1 in caz de eroare si seteaza
variabila errrno la un mesaj de eroare.
EXEMPLU: #include
#include
#include
void *tampon;
int x;
main()
{ x=absread(0,1,1,tampon);
printf("Datele citite sunt: %u \n",tampon);
sleep(5);
}
Pentru exemplul de mai sus,utilizati o discheta(neprotejata).Functia va
returna primul paragraf (16 bytes) din primul sector al dischetei(discheta
trebuie sa fie formatata DOS).Pentru majoritatea hard-discurilor actuale,
functia nu este aplicabila,deoarece formatul memoriei este pe 32 de bytes,
sau mai mare iar functia este destinata pentru formatul DOS/16 bytes.
In general,pentru a opera cu datele,orice sistem de operare utilizeaza un
anumit format.Sistemul DOS,arhiveaza datele in stiva,care este impartita
in sectoare si clustere,numerotate astfel incat sa faciliteze accesul la
orice adresa de memorie.Stiva poate contine linii (paragrafe) formate din
16 bytes,32 bytes,64 bytes etc.(caz in care se spune ca sistemul lucreaza
"pe 16 biti","pe 32 de biti" etc.).Alte sisteme de operare utilizeaza si
alte forme de gestionare a memoriei (matrici,tablouri bi si tridimensio-
nale,file si tampoane de memorie,fluxuri de date gen stream-uri etc.).
De obicei,sistemele de arhivare a datelor sunt compatibile cu mai multe
sisteme de operare,astfel incat aceleasi date pot fi citite in formate
diferite (de exemplu o fila de text,poate fi citita ca un flux de date
sub forma de fila virtuala,poate fi citita intr-o fereastra sub forma de
date volatile,poate fi citita sub forma de arhiva DOS ca text,hex,in
sectoare,sau poate fi citita in format binar,etc.).Atunci cand doua sis-
teme de operare nu sunt compatibile,este necesara o interfata de conversie
-313- [dos.h-abswrite() si allocmem() ]
a datelor la un format accesibil(De exemplu,stiva de 16 bytes se poate
transforma usor in stiva de 32 bytes,dar va ocupa un spatiu dublu de
memorie).
Functia absread() este utila mai ales pentru a citii sectoarele de disc
care contin "BAD"-uri (date neinterpretabile de catre sistem).ATENTIE
insa,datele raportate BAD de catre un sistem de operare,pot fi perfect
valabile in alt sistem de operare (Exemplu: DOS 16 nu poate opera cu date
DOS 32).
FUNCTIA abswrite()
-scrie date in sectoarele de disc
SINTAXA GENERALA este:
int abswrite(int drive,int nsects,int 1-sect,void *buffer);
Functia scrie datele din tamponul de meorie specificat prin buffer,pe
unitatea de disc specificata prin drive,pe nsect sectoare,incepand cu
sectorul specificat prin 1-sect.Pentru unitatea de disc se utilizeaza
conventia 0=A,1=B,2=C etc. iar sectoarele sunt cele logice(nu cele fizice)
si se numeroteaza incepand cu primul(sectorul 0).
Functia returneaza zero in caz de succes sau -1 in caz de eroare.
EXEMPLU: #include
#include
char *tampon="0000000000000000";
char *sector;
main()
{ abswrite(0,1,1,tampon);
absread(0,1,1,sector);
printf("Datele scrise in sectorul 1 sunt: %s \n",sector);
perror("Eroare=");
sleep(3);
}
Functia se poate utiliza pentru a arhiva date,direct pe sectoarele DOS,
dar mai ales pentru a corecta automat sectoarele raportate cu "BAD-uri".
Nu utilizati functia,daca nu intelegeti exact ce rezultat urmeaza sa
obtineti.Prin suprascrierea sectorului zero (sectorul de boot),unitatea
de disc nu va mai fi bootabila,adica nu va mai putea fi accesata.Sectorul
de boot al dischetei,contine datele necesare pentru identificarea unitatii
si prin modificarea lor se vor pierde toate datele arhivate.
FUNCTIA allocmem()
-apeleaza functia DOS 0x48 pentru a aloca un bloc de memorie
SINTAXA GENERALA este:
int allocmem(unsigned size,unsigned *segp);
Functia aloca memorie libera prin apelul la functia de sistem 0x48 si apoi
returneaza adresa de memorie a blocului alocat.Dimensiunea blocului de
memorie alocata se specifica prin size (in paragrafe,adica in linii de
cate 16 bytes) iar *segp este pointerul spre adresa la care va fi alocat
blocul de memorie.Daca blocul de memorie solicitat nu poate fi alocat (nu
exista destula memorie libera),atunci pointerul segp nu va mai fi generat.
Toate blocurile de memorie alocata vor contine paragrafe aliniate.
Functia returneaza -1 in caz de succes,sau returneaza cel mai mare bloc
de memorie libera alocabila,in caz de eroare.
-314- [ dos.h - bdos() ]
EXEMPLU: #include
#include
unsigned int tampon,numar;
int adresa;
main()
{ numar=16;
adresa=allocmem(numar,&tampon);
if (adresa<0)
printf("S-au alocat 256 bytes(n*16) la adresa: %x \n",tampon);
else
printf("nr.maxim de paragrafe alocabile este: %d \n",adresa);
perror("");
sleep(3);
freemem(tampon);
}
Memoria alocata,nu este eliberata automat decat la inchiderea programului.
Este bine sa eliberati blocurile de memorie,atunci cand nu mai sunt nece-
sare.
FUNCTIA bdos()
-permite apeluri la functiile de sistem DOS
SINTAXA GENERALA este:
int bdos(int dosfun,unsigned dosdx,unsigned dosal);
Functia permite apelarea directa a functiilor sistemului de operare DOS,si
implicit,accesul la registrii de memorie ai procesorului 8086.Pentru
detalii referitoare la functiile sistemului de operare si respectiv la
adresa de stiva a fiecarei functii,consultati manualul sistemului DOS.
Functia se utilizeaza doar pentru acele functii ale sistemului DOS,la care
apelul se face cu argument numeric (de tip int).Pentru functiile la care
este necesar un pointer pentru specificarea argumentului functiei(pointer
spre un sir de caractere de tip comanda,etc.),se va utiliza functia
bdosptr().In definitie,dosfun este functia DOS apelata,dosdx este valoarea
registrului DX,iar dosal este valoarea registrului AL.
Functia returneaza valoarea registrului AX,rezultata prin apelarea siste-
mului de operare prin functia specificata prin dosfun.
EXEMPLU: #include
#include
int control;
main()
{ control=bdos(0x10,0,0);
perror("Eroare=");
printf("Valoarea registrului AX este: %d \n",control);
sleep(5);
}
Dupa cum se vede in exemplu,functia permite preluarea valorilor din re-
gistrii de memorie ai procesorului.Acest gen de operatii este foarte util
pentru depanarea aplicatiilor cu calcule matematice complexe,sau pentru
programatorii care scriu aplicatii pentru procesor,compilatoare,sau
utilizeaza si limbajele de asamblare pentru a definii noi functii in C.
Pentru intelegerea simplista a functiilor din fila ,este utila si
o prezentare sumara a registrilor de memorie ai procesorului 8086.
-315- [ dos.h-registrii 8086 ]
Procesorul 8086 contine si un bloc de memorie interna,care este organizata
sub forma de stiva si este impartita in registrii.Procesorul 8086 poate
opera cu adrese in format de 16 biti (2 bytes).Procesoarele ulterioare
80286,80366,80486,80586 etc.) pot opera cu date in format de 32,64 sau
chiar 128 de biti (au registrii de memorie de 32,64,128 biti etc.).
Pentru operarea datelor se accepta urmatoarele tipuri de date:
OPERATOR BITI BYTES
byte 8 1
word 16 2
dword 32 4
fword 48 6
pword 48 6
qword 64 8
tbyte 80 10
tword 80 10
dqword 128 16
REGISTRII PROCESORULUI (memoria interna) SUNT:
Tip * Biti * Nume
------------------------------------------------------------------------
GENERAL * 8 * al cl dl bl ah ch dh bh
* 16 * ax cx dx bx sp bp si di
* 32 * eax ecx edx ebx esp ebp esi edi
------------------------------------------------------------------------
SEGMENT * 16 * es cs ss ds fs gs
------------------------------------------------------------------------
CONTROL * 32 * cr0 cr2 cr3 cr4
------------------------------------------------------------------------
DEBUG * 32 * dr0 dr1 dr2 dr3 dr6 dr7
------------------------------------------------------------------------
FPU * 80 * st0 st1 st2 st3 st4 st5 st6 st7
------------------------------------------------------------------------
MMX * 64 * mm0 mm1 mm2 mm3 mm4 mm5 mm6 mm7
------------------------------------------------------------------------
SSE * 128 * xmm0 xmm1 xmm2 xmm3 xmm4 xmm5 xmm6 xmm7
------------------------------------------------------------------------
Functiile DOS apelate din utilizeaza doar registrii de tip general
si cei de tip segment,la care se asociaza si registrii de control de
stare a procesorului (flags).Ceilalti registrii(FPU-unitate in virgula
mobila,DEBUG-depanare,MMX si SSE-extensii de memorie) sunt utilizati doar
de catre procesoarele mai recente.
Procesoarele cu arhitectura pe 64 de biti(AMD 64,EM64T etc.) au un bloc
de memorie mai complex cu registri suplimenteri,pentru diverse functii si
aplicatii suplimentare.Dintre acestia sunt:
8 biti : spl,bpl,sil,dil,r8b,r9b,r10b,r11b,r12b,r13b,r14b,r15b
16 biti : r8w,r9w,r10w,r11w,r12w,r13w,r14w,415w
32 biti : r8d,r9d,r10d,r11d,r12d,r13d,r14d,r15d
64 biti : rax,rcx,rdx,rbx,rsp,rbp,rsi,rdi,r8,r9,r10,r11,r12,r13,r14,r15
128 biti : xmm8,xmm9,xmm10,xmm11,xmm12,xmm13,xmm14,xmm15
Puteti intalnii acesti registrii in mesajele de eroare returnate de sis-
temul Windows atunci cand apar erori de gestiune a memoriei interne.
-316- [ dos.h -registrii 8086 ]
Deasemenea,puteti apela registrii suplimentari pentru a verifica arhi-
tectura procesorului instalat.
In general,registrii de procesor pot fi utilizati pentru a memora
temporar datele cu care se lucreaza curent,valori numerice aflate in
etapa de procesare sau preprocesare,contorul buclelor de repetitie aflate
in executie sau date despre starea actuala a procesorului(registrii de
stare).Memoria de procesor este foarte utila deoarece este apelata mult
mai rapid decat memoria fizica,nu se degradeaza prin scriere si citire
repetata,nu poate fi apelata decat prin functii restrictive etc.
Registrele comune de procesor arata cam in felul urmator:
15 7 0
Acumulator AH (AX) AL -deplasari si I/O
Date DH (DX) DL -inmultire,impartire,I/O
Contor CH (CX) CL -bucle,repetitii,rotatii
Baza BH (BX) BL -pointer la adresa de baza
Pointer de baza BP -pointer la date(stiva)
Index sursa SI -sir sursa si pointer index
Index destinatie DI -pointer index sir destinatie
Pointer stiva SP -pointer la varful stivei
Registre segment
Segment cod CS
Segment date DS
Segment stiva SS
Segment suplimentar ES
Indicatoare Flags
Pointer instructiune IP
Registrele AX,DX,CX,BX,BP,SI si DI sunt registre generale pe 16 biti si
sunt utilizate ca memorie temporara (volatila),in timpul prelucrarii
datelor.Astfel,daca un proces de prelucrare a datelor a fost intrerupt
in timpul executiei,se va putea determina moentul la care a intervenit
intreruperea,sau datele stocate in memorie in acel moment.AX,DX,CX si
BX pot fi accesate ca registre de 2x8 biti prin AH,DH,CH si BH pentru
cei 8 biti cei mai semnificativi(7-15) si respectiv prin AL,DL,CL si
BL pentru cei 8 biti mai putin semnificativi (0-7) unde L si H sunt
prescurtari pentru low si high level of discrimination.In cazul regis-
trelor de 32 de biti,se adauga la denumire si un E (de la extended),
astfel incat AX devine EAX,DX devine EDX etc.
Pe langa utilizarile generale,registrii au si utilizari speciale:
AX -registrul acumulator se utilizeaza la impartiri pentru a stoca o
0>
Dostları ilə paylaş: |
|
|