PODSTAWY INFORMATYKI Wykład 6.

Prezentacja na temat: "PODSTAWY INFORMATYKI Wykład 6."— Zapis prezentacji:

1 PODSTAWY INFORMATYKI Wykład 6

2 Inne funkcje operujące na plikach
fseek Zmienia bieżącą pozycje w pliku na wskazaną int fseek( FILE *stream, long offset, int origin ); Funkcja fseek przesuwa „wskaźnik” w pliku (jeśli jest związany ze strumieniem stream) do nowego położenia oddalonego o offset bajtów od origin Następna operacja na strumieniu wykonywana jest w nowej pozycji Jeśli plik jest otwarty do uaktualniania („a”), następną operacją może być zapis lub odczyt

3 fseek - c.d. fseek c.d. Parametr origin musi być jedną z następujących stałych, zdefiniowanych w stdio.h: SEEK_CUR Bieżąca pozycja „wskaźnika” SEEK_END Koniec pliku SEEK_SET Początek pliku

4 Przykład fseek /*WYNIK ./a fseek.c wprowadz szukany bajt5
#include<stdio.h> #include<stdlib.h> int main(int argc,char*argv[]){ long pol;FILE*fp; if(argc!=2){ printf("brak nazwy pliku\n");exit(1);} if((fp=fopen(argv[1],"rb"))==NULL){ printf("blad otwarcia pliku\n");exit(1);} printf("wprowadz szukany bajt\n"); scanf("%ld",&pol); if(fseek(fp,pol,SEEK_SET)){ printf("blad szukania\n");exit(1);} printf("wartoscia na pozycji %ld jest %c",pol,getc(fp)); fclose(fp);return 0;} /*WYNIK ./a fseek.c wprowadz szukany bajt5 wartoscia na pozycji 5 jest u*/

5 Inne funkcje operujące na plikach
rewind Przemieszcza „wskaźnik” pliku na początek pliku. void rewind( FILE *stream ); Funkcja rewind przemieszcza „wskaźnik” pliku związanego ze strumieniem stream na początek pliku Wywołanie rewind jest podobne do (void) fseek( stream, 0L, SEEK_SET ); Ale, w przeciwieństwie do fseek, rewind zeruje znaczniki błędów dla strumienia oraz znacznik końca pliku (end-of-file).

6 Inne funkcje operujące na plikach
tmpfile Tworzy tymczasowy plik. FILE *tmpfile( void ); Funkcja tmpfile tworzy tymczasowy plik i zwraca wskaźnik do tego strumienia (tj. struktury FILE) Jeśli plik nie może zostać utworzony, tmpfile zwraca wskaźnik NULL Plik tymczasowy jest automatycznie usuwany kiedy plik jest zamykany, kiedy program normalnie się kończy lub wywołana zostanie funkcja _rmtmp Plik tymczasowy jest otwierany w trybie w+b (binary read/write)

7 Przykład tmpfile #include <stdio.h> #include <stdlib.h>
int main(void) { FILE *tempfp; tempfp = tmpfile(); if (tempfp) printf("Temporary file created\n"); else printf("Unable to create temporary file\n"); exit(1); } return 0;

8 Nieformatowane we/wy Jak czytać i pisać ciągi dowolnych bajtów...
getc (fgetc), putc (fputc) fread, fwrite fread i fwrite używają wcześniej zdefiniowanego bufora do czytania i zapisu danych Funkcje te zwykle stosowane są do plików binarnych

9 fread Prototype: Parameters: buffer size count stream
size_t fread( void *buffer, size_t size, size_t count, FILE *stream ); Parameters: buffer Adres miejsca na przeczytane dane size Rozmiar pojedynczego elementu danych count Maksymalna liczba elementów do odczytu stream Wskaźnik na strukturę FILE

10 fwrite Prototyp podobny do fread: Parametry: buffer size count stream
size_t fwrite( void *buffer, size_t size, size_t count, FILE *stream ); Parametry: buffer Adres miejsca z danymi do zapisu size Rozmiar pojedynczego elementu danych count Maksymalna liczba elementów do odczytu stream Wskaźnik na strukturę FILE

11 fread c.d. Czyta do count elementów o rozmiarze size bajtów każdy z wejściowego strumienia stream i zapisuje je w buforze o adresie buffer Zwraca liczbę pełnych elementów odczytanych z pliku „Wskaźnik” na pozycję w pliku (jeśli jest) jest zwiększany o liczbę przeczytanych bajtów Jeśli plik jest otwarty w trybie tekstowym, pary cr-lf są zastępowane pojedynczym znakiem lf (linefeed) Wartość częściowo odczytanych elementów jest nieokreślona

12 fwrite c.d. Zapisuje do count elementów o rozmiarze size bajtów każdy, z bufora buffer to strumienia stream Zwraca liczbę pełnych zapisanych elementów „Wskaźnik” zwiększany jest o liczbę zapisanych bajtów Jeśli plik jest otwarty w trybie tekstowym, cr jest zastępowany przez cr-lf

13 Przykład fread, fwrite #include <string.h>
#include <stdio.h> int main(void){ FILE *stream; char msg[] = "This is a test"; char buf[20]; if ((stream = fopen("DUMMY.FIL", "w+")) == NULL) { fprintf(stderr, "Cannot open output file.\n"); return 1; } /* zapis danych do pliku */ fwrite(msg, strlen(msg)+1, 1, stream); /* przewinięcie na początek */ fseek(stream, SEEK_SET, 0); /* pdczyt danych */ fread(buf, strlen(msg)+1, 1, stream); printf("%s\n", buf); fclose(stream); return 0;

14 Wyniki programu Wyświetla: This is a test - DUMMY.FIL
This is a test - w konsoli

15 fread, fwrite - kopiowanie
#include <stdio.h> #define BUFLEN 1024 int main(){ FILE *f1, *f2; char buf[BUFLEN]; size_t len; f1 = fopen("data.bin","rb"); f2 = fopen("output.bin","wb"); if (!(f1 && f2)) return -1; while ((len = fread(buf, 1, BUFLEN, f1))>0) /* główna pętla */ fwrite(buf, 1, len, f2); fclose(f1); fclose(f2); return 0; }

16 Inne funkcje operujące na plikach
ungetc Zwraca znak z powrotem do strumienia wejściowego (!) int ungetc(int c, FILE *stream); Zwraca znak c do strumienia stream, który musi być otwarty do czytania. Ten znak zostanie zwrócony przez najbliższe wywołanie getc lub fread dla tego strumienia. Tylko jeden znak może zostać zwrócony do strumienia bez czytania. Drugie wywołanie ungetc bez getc spowoduje, że poprzedni znak zostanie zapomniany. Funkcje fflush, fseek, fsetpos, rewind kasują zwrócony znak.

17 ungetc - przykład #include <stdio.h> int main( void ){ int i=0;
char ch; puts(”Wpisz liczbę całkowitą i literę:"); /* czytamy znaki aż do nie-cyfry lub EOF */ while((ch = getchar()) != EOF && isdigit(ch)) i = 10 * i + ch - 48; /*zamieniamy ASCII na wartość cyfry*/ /*jeśli przeczytano nie-cyfrę, zwracamy ją do stdin*/ if (ch != EOF) ungetc(ch, stdin); printf("i = %d, nast. znak w buforze = %c\n", i, getchar()); return 0; }

18 Wynik programu Wpisz liczbę całkowitą i literę: 4r
= 4, nast. znak w buforze = r

19 Czy to wszystko o plikach? NIE
Funkcje clearerr fclose fcloseall fdopen feof ferror fflush fgetc fgetchar fgetpos fgets fileno flushall fopen fprintf fputc fputchar fputs fread freopen fscanf fseek fsetpos ftell fwrite getc getchar gets getw perror printf putc putchar puts putw remove rename rewind rmtmp scanf setbuf setvbuf sprintf sscanf strerror tempnam tmpfile tmpnam ungetc unlink vfprintf vfscanf vprintf vscanf vsprintf vsscanf

20 Dynamiczny przydział pamięci
Do tej pory, pamięć przydzielana była zawsze podczas definiowania zmiennych Co zrobić, jeśli ilość pamięci jest nieznana podczas kompilacji programu? Przydzielać (alokować) pamięć podczas wykonywania programu!

21 C: malloc i free Przydzielanie pamięci: void *malloc(size_t size);
Zwalnianie pamięci: void free(void *block);

22 C: malloc i free #include <malloc.h> #include <stdio.h>
#include <string.h> main() { char *name[4]; char buf[20]; int i; for (i=0;i<4;i++) { printf(”Podaj tekst: "); fgets(buf,20,stdin); name[i] = (char*) malloc(strlen(buf)+1); if (name[i] != NULL) strcpy(name[i],buf); else fprintf(stderr,”Brak pamięci\n"); } /* ... Inne operacje na tablicy name ... */ return 0; }

23 Wynik programu Program przerywa działanie gdy podamy ponad 20 liter:
Podaj tekst: ruyiw Podaj tekst: jdfksl Podaj tekst: jslfks Podaj tekst: fkslfksjk

24 Wskaźniki na struktury
typedef struct { int k; double x; } my_str; my_str *p; p = (my_str*)malloc(sizeof(my_str)); if (p==NULL) fprintf(stderr,”Brak pamięci..\n"); else { (*p).k = 9; /* *p.k jest błędne */ p->k = 10; /* działa jak (*p).k */ free(p); }

25 Wróćmy do tablic wskaźników
char *name[] = { "Illegal month", "Jan", "Feb", "Mar" }; Illegal month\0 Jan\0 Feb\0 Mar\0 name

26 Jak wypełnić tę tablicę ...
char *name[4]; name[0] = (char*) malloc(strlen("Illegal month")+1); if (name[0]==NULL) fprintf(stderr,”Brak pamięci\n"); else strcpy(name[0],"Invalid month"); name[1] = (char*) malloc(strlen("Jan")+1); if (name[1]==NULL) fprintf(stderr,"Brak pamięci \n"); strcpy(name[1],"Jan"); ...

27 Ważne: zwalnianie pamięci
...ciąg dalszy: for (i=0;i<4;i++) free(name[i]); Nie należy „zwalniać” NULL!!! free(NULL); /* Błąd! */

28 A co z tablicą name o rozmiarze 4?
Ta tablica też może być alokowana dynamicznie: char **name; name = (char**) malloc(4*sizeof(char*)); Możemy w ten sposób tworzyć struktury danych zachowujące się pod pewnymi względami jak tablice dwuwymiarowe. Rozmiar takiej tablicy jest ustalany podczas wykonywania programu (ang. run time), a nie kompilacji.

29 Co się stanie jeśli... Nie sprawdzimy, czy w wyniku próby alokowania pamięci uzyskaliśmy wskaźnik różny od NULL? Nie ma gwaracji, że uda się alokować pamięć Próba odwołania do pamięci przez wskaźnik równy NULL zwykle prowadzi do załamania programu albo (w mniej odpornych systemach operacyjnych całego) Nie zwolnimy alokowanej pamięci przed zakończeniem wykonywania programu? System operacyjny „czyści” bałagan po zakończeniu aplikacji, ale... lepiej jawnie zwolnić pamięć

30 Funkcje działające na łańcuchach
Plik nagłówkowy: <string.h> Wszystkie funkcje przyjmują, że łańcuchy kończą się znakiem ’\0’ Większość funkcji nie alokuje pamięci dla łańcuchów Ich użytkownik jest odpowiedzialny za dostarczenie miejsca w pamięci na wynik

31 Funkcje działające na łańcuchach: strcpy
char *strcpy(char *dest, const char *src); Kopiuje łańcuch src do dest #include <stdio.h> #include <string.h> int main(void){ char string[10]; char *str1 = "abcdefghi"; strcpy(string, str1); printf("%s\n", string); return 0; } WYNIK abcdefghi

32 Funkcje działające na łańcuchach: strncpy
char *strncpy(char *dest, const char *src, size_t maxlen); Kopiuje najwyżej maxlen znaków z src do dest. Docelowy łańcuch, dest, może być pozbawiony końcowego zera, jeśli długość src wynosi maxlen lub więcej.

33 Funkcje działające na łańcuchach: strncpy
#include <stdio.h> #include <string.h> int main(void) { char string[3+1]; char *str1 = "abcdefghi"; strncpy(string, str1, 3); string[3] = '\0'; /* inaczej zabrakłoby ’\0’ */ printf("%s\n", string); return 0; } /* Wynik: abc */

34 Funkcje działające na łańcuchach: strcmp
int strcmp(const char *s1, const char*s2); strcmp dokonuje porównania łańcuchów s1 i s2 traktując je jak ciąg wartości unsigned char Wartość zwracana: < jeśli s1 < s2 == 0 jeśli s1 == s2 > jeśli s1 > s2

35 Funkcje działające na łańcuchach: strcmp
#include <string.h> #include <stdio.h> int main(void) { char *buf1 = "alice", *buf2 = ”andrew"; int p; p = strcmp(buf2, buf1); if (p > 0) printf("buffer 2 is greater than buffer 1\n"); else printf("buffer 2 is not greater than buffer 1\n"); return 0; } /* Wynik: buffer 2 is greater than buffer 1 */

36 Przykład hasła z strcmp
#include<stdio.h> #include<stdlib.h> #include<string.h> int main(void) {char haslo[80]; int i; for(i=0;i<3;i++){ printf("haslo:\n"); gets(haslo); if(!strcmp("Programowanie Komputerow",haslo)) {break;} } if(i==3){printf("dostep zabriniony\n");} else printf("logowanie powiodlo sie\n"); return 0; /* WYNIK haslo:studia haslo:rok3 haslo:2005 dostep zabriniony haslo:op haslo:Programowanie Komputerow logowanie powiodlo się */

37 Funkcje działające na łańcuchach: strlen
size_t strlen(const char *s); Zwraca liczbę znaków w łańcuchu s, nie licząc kończącego ten łańcuch zera #include <stdio.h> #include <string.h> int main(void){ char *string = ”The ANSI C compiler"; printf("%d\n", strlen(string)); return 0; } /* Wynik: 19 */

38 Funkcje działające na łańcuchach: strcat
char *strcat(char *dest, const char *src); strcat dołącza kopię src do końca łańcucha dest. Długość wynikowego łańcucha jest równa strlen(dest) + strlen(src) strcat zwraca wskaźnik na połączone łańcuchy.

39 Funkcje działające na łańcuchach: strcat
#include <string.h> #include <stdio.h> int main(void) { char destination[25]; char *blank = " ", *c = "C ", *a = ”ANSI"; strcpy(destination, a); strcat(destination, blank); strcat(destination, c); printf("%s\n", destination); return 0; } /* WYNIK: ANSI C */

40 Funkcje działające na łańcuchach: strchr
char *strchr(const char *s, int c); Szuka w łańcuchu pierwszego wystąpienia podanego znaku Kończące zero uznawane jest za część łańcucha Jeśli c nie występuje w s, funkcja zwraca NULL

41 Funkcje działające na łańcuchach: strchr
#include <string.h> #include <stdio.h> int main(void) { char string[15]; char *ptr, c = 'r'; strcpy(string, "This is a string"); ptr = strchr(string, c); if (ptr) printf("The character %c is at position: %d\n", c, ptr-string); else printf("The character was not found\n"); return 0; } /* Wynik: The character r is at position: 12 */

42 Funkcje działające na łańcuchach: strrchr
char *strrchr(const char *s, int c); strrchr szuka ostatniego wystąpienia znaku c w łańcuchu s

43 Funkcje działające na łańcuchach: strpbrk
char *strpbrk(const char *s1, const char *s2); strpbrk szuka w łańcuchu s1 pierwszego wystąpienia jakiegokolwiek znaku występującego w łańcuchu s2 Jeśli znajdzie, strpbrk zwraca wskaźnik na pierwsze wystąpienie takiego znaku Jeśli nie znajdzie, zwrócona zostanie wartość NULL

44 Funkcje działające na łańcuchach: strpbrk
#include <stdio.h> #include <string.h> int main(void){ char *string1 = "value=123"; char *string2 = ",:=;"; char *ptr; ptr = strpbrk(string1, string2); if (ptr) printf("strpbrk found first character: %c\n", *ptr); else printf("strpbrk didn't find character in set\n"); return 0; } /* strpbrk found first character: = */

45 Funkcje działające na łańcuchach: strstr
char *strstr(const char *s1, const char *s2); strstr szuka w łańcuchu s1 pierwszego wystąpienia łańcucha s2 Jeśli znajdzie, strstr zwraca wskaźnik na ten element s1, od którego zaczyna się s2 (wskaźnik na wystąpienie s2 w s1) Jeśli nie znajdzie, strstr zwraca NULL

46 Funkcje działające na łańcuchach: strstr
#include <stdio.h> #include <string.h> int main(void) { char *str1 = ”Computer Programming", *str2 = ”ram", *ptr; ptr = strstr(str1, str2); printf("The substring is: %s\n", ptr); return 0; } /* The substring is: ramming */

47 Funkcje działające na łańcuchach: strtok
char *strtok(char *s1, const char *s2); strtok traktuje s1 jako sekwencję tokenów, rozdzielonych ciągami separatorów zdefiniowanych przez s2 Pierwsze wywołanie strtok zwraca wskaźnik do pierwszego znaku pierwszego tokenu w s1 oraz zapisuje znak 0 do s1 bezpośrednio za tym tokenem Kolejne wywołania tej funkcji z pierwszym argumentem równym NULL zwracają wskaźniki do kolejnych tokenów w s1, aż do ich wyczerpania

48 Funkcje działające na łańcuchach: strtok
#include <string.h> #include <stdio.h> int main(void) { char input[16] = "abc,d"; char *p; /* strtok umieszcza znak 0 za ewentualnie znalezionym tokenem*/ p = strtok(input, ","); if (p) printf("%s\n", p); /* Drugie wywołanie z pierwszym argumentem równym NULL zwraca wskaźnik to kolejnego tokenu */ p = strtok(NULL, ","); if (p) printf("%s\n", p); return 0; } /*WYNIK: abc d */

49 Funkcje operujące na pamięci: memcpy
void *memcpy (void *dest, const void *src, size_t n); Kopiuje blok n bajtów z src do dest Jeśli obszary src i dest nakładają się, wynik jest niezdefiniowany

50 Funkcje operujące na pamięci: memcpy
#include <stdio.h> #include <string.h> int main(void) { char src[] = "******************************"; char dest[] = "abcdefghijlkmnopqrstuvwxyz "; char *ptr; printf("destination before memcpy: %s\n", dest); ptr = (char *) memcpy(dest, src, strlen(src)); if (ptr) printf("destination after memcpy: %s\n", dest); else printf("memcpy failed\n"); return 0; } destination before memcpy: abcdefghijlkmnopqrstuvwxyz destination after memcpy: ******************************456709

51 Funkcje operujące na pamięci: memmove
void *memmove(void *dest, const void *src, size_t n); Kopiuje blok n bajtów z src do dest Nawet jeśli bloki pamięci nakładają się, wynik kopiowania jest poprawny

52 Funkcje operujące na pamięci: memmove
#include <string.h> #include <stdio.h> int main(void) { char dest[] = "abcdefghijklmnopqrstuvwxyz "; char *src = "******************************"; printf("destination prior to memmove: %s\n", dest); memmove(dest, src, 26); printf("destination after memmove: %s\n", dest); return 0; } destination prior to memmove: abcdefghijklmnopqrstuvwxyz destination after memmove: **************************

53 Funkcje operujące na pamięci: memset
void *memset (void *s, int c, size_t n); memset ustawia pierwszych n bajtów tablicy s na znak c Zwraca s