|
|
səhifə | 39/55 | tarix | 07.05.2018 | ölçüsü | 4,6 Mb. | | #50260 |
| x=numar1;
functie1();
numar2=fileno(stdprn);
x=numar2;
functie1();
numar3=fileno(stdin);
x=numar3;
functie1();
sleep(3);
}
functie1()
{ if (x==0)
printf("codul nu manevreaza un dispozitiv de iesire ! \n");
else
printf("codul manevreaza dispozitivul de iesire:%d ! \n",x);
}
FUNCTIA lock()
-blocheaza o fila partajata in sistem SHARE
SINTAXA GENERALA este: int lock(int handle,long offset,long length);
Functia blocheaza accesul altor utilizatori din retea la o fila partajata
(SHARE.EXE trebuie sa fie activa in sistemul DOS).Functia asigura o
interfata directa cu sistemul de operare (DOS),cu actiune directa asupra
mecanismului de partajare a filelor in retea.Blocarea se poate face in
mod arbitrar,la orice locatie de memorie din fila specificata,prin inter-
mediul adresei offset (lungimea in bytes fata in inceputul filei).
In caz ca o fila este blocata la partajare,programul va repeta automat
tentativa de a citi datele,de trei ori,iar in caz ca citirea esueaza de
fiecare data,va seta variabila globala errno cu o valoare de eroare.
Functia returneaza 0 daca blocarea filei a fost reusita,sau -1 in caz
contrar si seteaza errno la valoarea EACCES (locking violation)
Puteti utiliza aceasta functie atunci cand doriti acces axclusiv la o
anumita fila,sau cand nu doriti sa fiti interupti de un alt user care
blocheaza fila in timp ce o cititi.Nu uitati sa deblocati fila dupa ce
epuizati operatiile dorite.Pentru a interveni asupra unei file blocate,
trebuie ca fila sa fie deblocata (cu unlock).
Nu blocati accesul la file,fara un motiv intemeiat.
-286- [ io.h -lseek() ]
EXEMPLU: #include
#include
#include
#include
int handle,status,x;
long lungime;
char litera;
main()
{ handle=open("mesaj.mmm",O_RDWR);
lungime=filelength(handle);
status=lock(handle,0L,lungime/2);
if (status==0)
printf("Fila partajata a fost blocata cu succes !\n");
else
printf("Fila nu a fost blocata !");
sleep(3);
}
FUNCTIA lseek()
-deplaseaza pointerul filei
SINTAXA GENERALA este: long lseek(int handle,long offset,int fromwhere);
Functia seteaza pointerul asociat filei(prin handle),la o noua adresa,
situata la offset bytes de locatia relativa specificata prin fromwhere
(locatia implicita este la inceputul filei).Valorile pentru fromwhere sunt
constante(definite in io.h) si pot fi: SEEK_CUR(pozitia curenta a pointer-
ului),SEEK_END(sfarsitul filei),SEEK_SET(inceputul filei).
Functia returneaza noua adresa (masurata in bytes fata de cea initiala),
sau -1 in caz de eroare si seteaza errno la:EBADF(bad file number),EINVAL
(invalid argument) sau ESPIPE(Illegal seek on device).
In cazul unitatilor incapabile de a deplasa pointerul in interiorul filei
(de exemplu terminale si imprimante),valoarea returnata de functie este
nedeterminata (nu poate fi utilizata pentru depanare).
EXEMPLU: #include
#include
#include
#include
long x;
int handle;
main()
{ handle=open("mesaj.mmm",O_RDWR);
x=lseek(handle,-7,SEEK_END);
printf("Pozitia pointerului este la: %ld bytes \n",x);
x=lseek(handle,15,SEEK_SET);
printf("Pozitia noua este la: %ld bytes \n",x);
sleep(3);
}
Functia se utilizeaza pentru a deschide o fila la un anumit paragraf.Este
utila mai ales atunci cand se executa operatii automate asupra filei,cand
se aplica diverse functii asupra textului deschis,cand se aplica functii
de derulare automata a textului etc.Versiunea Visual include si functia
lseeki64(),care returneaza offsetul pentru valori int de 64 biti.
-287- [ io.h -open() si _open() ]
FUNCTIA _open()
-deschide o fila pentru scriere si/sau citire
SINTAXA GENERALA este: int open(const char *filename,int oflags);
Functia deschide fila specificata prin calea de acces,cu tipul de argument
specificat prin oflags(definit in ).Valorile pentru oflags sunt:
O_RDONLY (read only),O_WRONLY (write only),O_RDWR (read/write),O_CREAT
(create and open file),O_TRUNC(open with truncation),O_EXCL (exclusive
open),O_APPEND(append to end of file),O_TEXT (CR-LF translation) si
O_BINARY (no translation).
Functia returneaza numarul (codul intern) de manipulare a filei deschise,
sau -1 in caz de esec.
EXEMPLU: #include
#include
#include
#include
int handle;
main()
{
handle=_open("mesaj.mmm",O_TEXT);
printf("codul pentru manipulare interna este:%d \n",handle);
sleep(3);
}
Functia este similara cu open(),dar nu include si modul de acces la fila,
respectiv nu necesita prezenta filei header .Se poate utiliza
pentru a crea si deschide file,daca nu aveti fila .
FUNCTIA open()
-deschide o fila pentru citire si/sau scriere
SINTAXA GENERALA este:
int open(const char *path,int access [,unsigned mode]);
Functia deschide fila specificata prin calea de acces,cu atributele spe-
cificate prin access si cu modul de acces specificat prin mode.
Atributele filei pot fi:O_RDONLY,O_WRONLY,O_RDWR,O_APPEND,O_CREAT,O_TRUNC,
O_EXCL,O_TEXT si O_BINARY definite in (vezi si _open),iar
modul de acces la fila poate fi:S_IWRITE,S_IREAD sau S_IREAD|S_WRITE si
este definit in stat.h (vezi si access() ).
Functia returneaza o valoare intreaga pozitiva (numarul de manipulare
interna handle) iar pointerul spre fila este adresat la inceputul filei.
In caz de eroare,returneaza -1 si seteaza errno la una dintre valorile:
EACCESS(permision denied),EINVACC(invalid acces code),EMFILE(too many open
files) sau ENOENT(no such file or directory)
EXEMPLU: #include
#include
#include
#include
#include
int handle;
main()
{ handle=open("mesaj.mmm",O_TEXT,S_IREAD);
printf("Fila mesaj.mmm are atasat handle= %d \n");
sleep(3); }
-288- [ io.h - read() si _read() ]
FUNCTIA read() si _read()
-citeste date dintr-o fila
SINTAXA GENERALA este: int read(int handle,void *buf,unsigned len);
int _read(int handle,void *buf,unsigned len);
Functia citeste len bytes din fila asociata la codul handle,si arhiveaza
datele in tamponul de memorie spre care pointeaza pointerul *buf.
Citirea incepe de la pozitia curenta a cursorului si pana cand au fost
citite numarul de caractere specificat prin len.Dupa incheierea citirii,
returneaza numarul de bytes cititi si arhivati si incrementeaza pointerul
filei cu numarul de biti cititi.In cazul unitatilor de memorie(disk sau
floppy disk),datele sunt citite direct de pe disc (fara tampon de memorie
intermediar).Numarul maxim de bytes ce pot fi cititi cu functia read()
este egal cu UINT_MAX-1(UINT_MAX este o constanta definita in limits.h la
valoarea 0xFFFFU).
Daca fila din care se citesc datele a fost deschisa in modul text,numarul
total de bytes cititi(valoarea returnata) nu include si caracterele
carriage-return sau Ctrl+Z.
La sfarsitul filei,functia returneaza 0 (zero) iar in caz de eroare,retur-
neaza -1 si seteaza variabila globala errno la una dintre valorile:
EACCESS (permission denied) sau EBADF (bad file number).
EXEMPLU: #include
#include
#include
#include
int numar=1,handle;
tampon[320];
main()
{ handle=open("mesaj.mmm",O_TEXT);
do
{
numar=read(handle,&tampon,400);
} while (numar==0);
printf("%s \n",tampon);
sleep(3); }
SAU: #include
#include
#include
#include
int numar,handle,x;
char tampon[80];
main()
{ handle=open("mesaj.mmm",O_TEXT);
for(x=1;x<27;x++)
{ lseek(handle,0L,SEEK_SET);
read(handle,&tampon,x);
printf("Caractere citite= %d \n",x);
printf("textul citit este: \n\n");
printf("... %s ... \n\n",tampon);
sleep(1);
}}
-289- [ io.h -setftime() si setmode() ]
FUNCTIA setftime()
-seteaza ora si data filei (reseteaza)
SINTAXA GENERALA este: int setftime(int handle,struct ftime *ftimep);
Functia se utilizeaza pentru a reseta datele din structura de tip ftime
asociata filei specificata prin codul de manipulare interna handle.Fila
trebuie sa fie deschisa pentru scriere iar modul de acces la fila trebuie
sa permita scrierea filei.Daca fila este de tip read-only,se genereaza o
eroare de acces de tip EACCESS.Pentru modificarea datei,sau a orei,se vor
utiliza variabilele ft_tsec,ft_min,ft_hour,ft_day,ft_month si ft_year,
care sunt definite in structura de tip ftime (in vezi si getftime )
Functia returneaza 0 (zero) daca a fost executata cu succes,sau -1 in caz
contrar si seteaza errno la: EACCESS (permision denied),EBADF(bad file
number) sau EINVFNC(invalid function number)
EXEMPLU: #include
#include
#include
#include
char nume[40];
int numar;
struct ftime timp;
main()
{ printf("Introduceti numele si extensia filei: \n");
scanf("%s",&nume);
numar=open(nume,O_RDWR);
timp.ft_hour=19;
timp.ft_min=30;
timp.ft_tsec=15;
timp.ft_month=7;
timp.ft_day=7;
timp.ft_year=70;
setftime(numar,&timp);
printf("Fila %s a fost resetata la ora: \n",nume);
printf("%u:%u:%u \n",timp.ft_hour,timp.ft_min,timp.ft_tsec*2);
printf("si pentru data de: \n");
printf("%u/%u/%u \n",timp.ft_month,timp.ft_day,timp.ft_year+1980);
sleep(5);
}
Introduceti orice fila accesibila din directorul TC,si apoi verificati cu
un utilitar de DOS (Norton) sau de Windows,daca datele au fost resetate
dupa dorinta.Pentru date mai vechi de anul 1980,se pot genera erori de
resetare a anului (verificati cu atentie in cazul valorilor negative).
FUNCTIA setmode()
-seteaza (reseteaza) modul de deschidere al filei
SINTAXA GENERALA este: int setmode(int handle,int amode);
Functia seteaza modul in care va fi deschisa fila (text sau binar).Pentru
amode se poate utiliza una dintre constantele O_BINARY sau O_TEXT (defi-
nite in fcntl.h).Diferenta dintre cele doua moduri consta in modul de tra-
tare a caracterelor carriage-return,line-feed si Ctrl+Z.
Functia returneaza modul de translatie anterior sau -1 in caz de eroare si
seteaza variabila errno la: EINVAL (invalid argument).
-290- [ io.h - sopen() ]
EXEMPLU: #include
#include
#include
#include
int handle,mod,mod1;
main()
{ handle=open("mesaj.mmm",O_BINARY);
mod=setmode(handle,O_TEXT);
mod1=setmode(0,O_BINARY);
printf("Fila a fost resetata in mod text !\n");
printf("Atributul mod al filei mesaj este: %d \n",mod);
printf("Atributul mod1 este: %d \n",mod1);
sleep(3);
}
FUNCTIA sopen()
-deschide o fila share (partajata)
SINTAXA GENERALA este:
int sopen(char *path,int access,int shflag[,int mode]);
Functia deschide o fila pentru acces partajat.Este similara cu open dar
accepta si argumentul shflag care este o constanta definita in
si poate lua una dintre urmatoarele valori: SH_COMPAT (seteaza compati-
bilitatea pentru acces partajat),SH_DENYRW (nu permite accesul la scriere
sau citire),SH_DENYWR (nu permite accesul la scriere),SH_DENYRD(nu permite
accesul la citire),SH_DENYNONE(permite accesul atat la citire cat si la
scriere),sau SH_DENYNO(permite accesul la citire si scriere).
Pentru acces si mode,se pot utiliza aceleasi constante ca si pentru open()
adica: O_RDONLY,O_WRONLY,O_RDWR,O_NDELAY,O_APPEND,O_CREAT,O_TRUNC,O_EXCL
O_BINARY,O_TEXT,O_NOINHERIT (definite in fcntl.h) si S_IWRITE,S_IREAD,sau
S_WRITE|S_IREAD (definite in stat.h)
Parametrii pot fi combinati in oricare dintre combinatiile logice posibile
Modul de acces la fila trebuie precizat doar atunci cand se creaza o fila
noua cu O_CREAT.Cand O_TEXT sau O_BINARY nu se specifica distinct,fila va
fi deschisa cu valoarea setata pentru _fmode (implicit O_TEXT).
Functia returneaza o valoare nonnegativa si un pointer spre inceputul fi-
lei,sau -1 si un cod de eroare(EACCESS,EINVACC,EMFILE,ENOENT) in errno.
EXEMPLU: #include
#include
#include
#include
#include
#include
int handle;
main()
{ handle=sopen("mesaj.mmm",O_RDWR,SH_DENYNONE,S_IWRITE);
printf("Fila a fost deschisa pentru acces partajat ! \n");
printf("fila poate fi citita sau suprascrisa !\n");
printf("fila are codul handle=%d \n",handle);
sleep(3);
}
Functia este destinata pentru operatii cu file si fisiere,in retea.
-291- [ io.h - tell() si unlink() ]
FUNCTIA tell()
-returneaza pozitia actuala a pointerului filei (cursorul)
SINTAXA GENERALA este: long tell(int handle);
Functia returneaza pozitia curenta a pointerului spre fila al carei cod
de manipulare interna este cel specificat prin handle.Pozitia este expri-
mata prin numarul de bytes fata de inceputul filei(practic citeste pozi-
tia cursorului in cadrul filei).
Functia returneaza un numar de tip long(pozitia exprimata in bytes) sau
-1 in caz de eroare si seteaza errno la EBADF(bad file number).
EXEMPLU: #include
#include
#include
#include
int handle,x;
char text[80];
long pozitie;
main()
{ handle=open("mesaj.mmm",O_TEXT);
for (x=1;x<11;x++)
{ read(handle,&text,20);
printf("%s \n",text);
pozitie=tell(handle);
printf("Pozitia cursorului este la: %ld bytes \n",pozitie);
sleep(1);
};
sleep(3);
}
FUNCTIA unlink()
-sterge o fila
SINTAXA GENERALA este: int unlink(const char *filename);
Functia sterge o fila.Se poate specifica orice unitate de memorie,nume de
fila sau cale de acces(path).Nu se accepta caracterele cu sens general gen
* si ? (wildcards).Nu pot fi sterse filele cu atributul read-only.Pentru a
sterge filele de tip read-only,acestea trebuie modificate initial cu chmod
sau respectiv cu _rtl_chmod(),pantru a permite accesul la scriere.Pentru
a putea fi stearsa cu unlink(),fila trebuie inchisa inainte de a o sterge.
Functia returneaza 0 in caz de succes sau -1 in caz contrar si seteaza va
riabila errno la EACCESS sau ENOENT (path or file name not found).
EXEMPLU: #include
#include
main()
{ chmod("mesaj1.mmm",S_IWRITE);
chmod("mesaj2.mmm",S_IWRITE);
unlink("mesaj1.mmm");
unlink("mesaj2.mmm");
}
Veriunea C++ include si functia remove(),care apeleaza functia unlink()
pentru a sterge o fila.Atentie sa nu stergeti din greseala file de tip
sistem,sau file care contin date valoroase.Stergerea este ireversibila
(datele nu mai pot fi recuperate dupa apelarea functiei).
-292- [io.h -unlock(),write() si _write()]
FUNCTIA unlock()
-deblocheaza o fila share blocata cu lock()
SINTAXA GENERALA este: int unlock(int handle,long offset,long length);
Functia elibereaza o fila share care a fost blocata cu lock().Dupa apela-
rea functiei unlock(),fila va putea fi partajata in retea.Fila apeleaza
direct sistemul de operare (modul de partajare la citirea filelor).Pentru
a evita erorile de executie,toate filele care au fost blocate cu lock(),
trebuie deblocate cu unlock() inainte de a fi inchise.Daca redactati un
program sau o aplicatie,aveti grije sa deblocati si sa inchideti automat
toate filele inainte de a termina programul (sistemul de operare Windows
inchide automat toate filele spre deosebire DOS si C).
Functia returneaza 0 sau -1 in caz de eroare.
EXEMPLU: #include
#include
#include
#include
int handle,x;
long w=1;
main()
{ handle=open("mesaj.mmm",O_TEXT);
lock(handle,0L,w);
x=unlock(handle,0L,w);
if(x==0)
printf("Fila a fost deblocata \n");
else
printf("Fila nu a fost deblocata \n");
sleep(3);
}
FUNCTIA write() si _write()
-scrie intr-o fila
SINTAXA GENERALA este: int write(int handle,void *buf,unsigned len);
int _write(int handle,void *buf,unsigned len);
Functia scrie datele din tamponul de memorie pointat prin pointerul *buf
in fila specificata prin handle,pe o lungime de len bytes.Handle este
codul intern de manipulare al filei sau al unitatii de memorie,cel retur-
nat de functia creat(),open(),dup(),dup2() etc.
Numarul maxim de caractere ce por fi scrise este dat de UINT_MAX-1(definit
in limits.h).In mod text caracterele carriage return sunt inlocuite prin
line feed+carriage return (linie noua de la capat de rand).Scrierea in
fila incepe de la pozitia curenta a cursorului.In cazul in care numarul
de caractere transcrise este mai mic decat cel specificat prin len,apare
o situate ce poate genera un mesaj de eroare in cazul depanatoarelor auto-
mate care vor interpreta situatia ca si cand nu mai este spatiu suficient
in unitatea de memorie.In cazul unitatilor de memorie,scriere se face
direct pe unitate.Daca fila in care se scrie a fost deschisa cu O_APPEND,
atunci cursorul va fi deplasat la sfarsitul filei (pozitia EOF),inainte de
a incepe scrierea datelor (datele vor fi adaugate fara suprascriere).
Functia returneaza numarul de bytes scrisi(fara a include si caracterele
carriage return),iar in caz de eroare returneaza -1 si seteaza variabila
errno la EACCESS(permission denied) sau EBADF(bad file number).
-293- [ io.h - generalitati,constante ]
EXEMPLU: #include
#include
#include
#include
int handle;
char *text1="Mesaj arhivat in fila specificata !";
char *text2="Exemplu de editare in fila !";
Dostları ilə paylaş: |
|
|