Pobieranie prezentacji. Proszę czekać

Pobieranie prezentacji. Proszę czekać

Programowanie C++116 Strumienie wejścia/wyjścia ios istreamostream ifstream iostream ofstream istrstream istringstrem ostrstream ostringstream fstream.

Podobne prezentacje


Prezentacja na temat: "Programowanie C++116 Strumienie wejścia/wyjścia ios istreamostream ifstream iostream ofstream istrstream istringstrem ostrstream ostringstream fstream."— Zapis prezentacji:

1 Programowanie C++116 Strumienie wejścia/wyjścia ios istreamostream ifstream iostream ofstream istrstream istringstrem ostrstream ostringstream fstream strstream streambuf filebufstdiobuf strstrambuf stringmbuf

2 Programowanie C++117 Klasa ios class ios { public: typedef unsigned long fmtflags; // 32-bitowy łańcuch bitowy typedef unsigned char iostate;// 8-bitowy łańcuch bitowy protected: streambuf* _strbuf;// wskaźnik do bufora ostream* _tie;// wskaźnik do ostream dołączonego do istream int _width;// szerokość pola wyjściowego int _prec;// dokładność dla float char _fill;// znak wypełnienia pustych pól fmtflags _flags;// flagi formatowania iostate _state;// aktualny stan io ios(streambuf* _strbuf = 0, ostream* _tie = 0); X ~ios();... }; _width _prec _fill _flags _state _strbuf _tie 15 9 #

3 Programowanie C++118 Flagi formatowania class ios { public: enum { skipws= 01,// pomiń białe znaki (domyślne) left= 02,// wyrównanie lewostronne right= 04,// wyrównanie prawostronne (domyślne) internal= 010,// wyrównanie lewo i prawostronne dec= 020,// konwersja dziesiątkowa oct = 040,// konwersja ósemkowa hex= 0100,// konwersja szesnastkowa showbase= 0200,// pokaż podstawę konwersji showpoint= 0400,// pokaż kropkę dziesiętną uppercase = 01000,// duże litery w zapisie liczb showpos = 02000,// użyj + z liczbami dodatnimi scientific = 04000,// użyj notacji naukowej dla float i double fixed= ,// użyj notacji z kropką dziesiętną unitbuf= ,// buforowanie... stdio= }; //...współpraca z stdio... };

4 Programowanie C++119 Selektory klasy ios class ios { public: streambuf* rdbuf () const { return _strbuf ; } ostream* tie () const { return _tie; } int width () const { return _width; } int precision () const { return _prec; } char fill () const { return _fill; } long flags () const { return _flags; } int rdstate () const { return _state; }... }; main () { cout<<"cout.width = "<< cout.width( ) <

5 Programowanie C++120 Selektory klasy ios class ios { public: streambuf* rdbuf () const { return _strbuf ; } ostream* tie () const { return _tie; } int width () const { return _width; } int precision () const { return _prec; } char fill () const { return _fill; } long flags () const { return _flags; } int rdstate () const { return _state; }... }; main () { cout<<"cout.width = "<< cout.width( ) <

6 Programowanie C++121 Modyfikatory klasy ios class ios { public: int width (int w) { int t = _width; _width = w; return t; } int precision (int p) {int t = _precision; _precision = t; return t; } char fill (char c) { char t = _fill; _fill = c; return t; } long flags (long f) { long t = _flags; _flags = f; return t; }... }; ############################Hello World Hello World pi = pi = pi = main () { cout.fill('#'); cout.width(40); cout<<"Hello World"<

7 Programowanie C++122 Zmiana flag formatowania main () { int n = 234; long oldf = cout.flags(ios::hex | ios::uppercase); cout<

8 Programowanie C++123 main () { char buffer[80]; cin.unsetf(ios::skipws); //czyści domyślneustawienie flagi cin>>buffer; cout<<"["<

9 Programowanie C++124 Zmienne stanu klasy ios class ios { public: enum { goodbit= 0,// wszystko ok eofbit= 01,// koniec pliku failbit= 02,// ostatnia operacja zakończona niepomyślnie badbit= 04 };// niewłaściwa operacja... }; Dostępne selektory: good(), eof(), fail(), bad(), rdstate() main () { cout<<" cin.rdstate = "<>n; cout<<" cin.rdstate = "<

10 Programowanie C++125 Operatory dla stanu ios class ios { public: operator void* () const;// operator konwersji int operator! () const; void clear (int );// modyfikator - ustawia nowe słowo stanu strumienia... }; main () { int n, sum=0; cin>>n; while (cin) {// pętla będzie wykonywana tak długo dopóki _state ==0 sum+=n; cin>>n; } cout<<" suma częściowa wynosi "<>n) sum+=n; cout<<" suma całkowita wynosi "<

11 Programowanie C++126 Klasa istream class istream : virtual public ios { //...} zdefiniowanie ios jako wirtualnej klasy bazowej ułatwia wielokrotne dziedziczenie, które posiada klasa iostream Strumień cin oraz operator >> klasy istream obsługują formatowane operacje wejścia. Nieformatowane funkcje wejścia: int get ( ); istream& get ( char& c ); istream& get ( char* buffer, int n, char delim = \n ); istream& getline ( char* buffer, int n, char delim = \n); istream& ignore ( int n = 1, int delim = EOF); int peek ( ); istream& putback (char c); istream& read ( char* buffer, int n); istream& read ( unsigned char* buffer, int n); int gcount ( );

12 Programowanie C++127 Nieformatowane wejście main () { char c; while((c = cin.get() ) != EOF) cout<

13 Programowanie C++128 Nieformatowane wejście c.d. main () { char buffer[80]; cin.getline(buffer,8); cout<>month; cin.ignore();// zjada '/' cin.ignore(80,'/');//zjada "dd/", lub "d/" lub "/" cin>>year; cout<<"Miesiąc = "<

14 Programowanie C++129 Nieformatowane wejście c.d. main () { char buffer[80],c ; cout<

15 Programowanie C++130 Klasa ostream class ostream : virtual public ios { //...} Strumienie: cout // standardowe urządzenie wyjścia cerr // standardowe urządzenie wyjścia dla komunikatów błędów (niebuforowany) clog // jak wyżej, strumień buforowany wraz z operatorem << obsługują formatowane wyjście. Nieformatowane funkcje wyjścia: int put ( char c ); ostream& put ( char c ); ostream& write ( const char* buffer, int n); ostream& write ( const unsigned char* buffer, int n );

16 Programowanie C++131 Nieformatowane wyjście main () { char c ; while(cin.get (c) ) cout.put(c); cout<

17 Programowanie C++132 Manipulatory Manipulatory – specjalne funkcje, które wstawiane do strumieni wyglądają jak obiekty i dokonują zmiany sposobu formatowania Operator wstawiania do strumienia: ostream& operator <<(ostream& (*p)(ostream&)) { return (*p)(*this); } Manipulator endl:ostream& endl(ostream& ostr) { ostr.put(\n); ostr.flush(); }

18 Programowanie C++133 Manipulatory strumieni Najbardziej popularne manipulatory strumieni:

19 Programowanie C++134 Definiowanie manipulatorów Manipulatory strumieni definiowane są zgodnie z następującymi prototypami: - manipulatory bezparametrowe ios& f( ios& ostr); ostream& f( ostream& ostr ); istream& f ( istream& istr); - manipulatory z parametrem ios& f( ios& ostr, int n ); ostream& f( ostream& ostr, int n ); istream& f ( istream& istr, int n ); ostream& beep(ostream& ostr) { return ostr<<\a; } main ( ) { cout<

20 Programowanie C++135 Zastosowanie manipulatorów ostream & tem(ostream& str){ str<

21 Programowanie C++136 Operacje wejścia/wyjścia na plikach Trzy rodzaje strumieni zdefiniowane dla operacji na plikach: ofstream - zapis do plików, ifstream- odczyt z plików, fstream- odczyt i zapis do tego samego pliku Otwarcia plików wejściowych i wyjściowych można dokonać za pomocą konstruktorów lub funkcji open (mają takie same parametry): void open ( char* name, int mode = ***, int prot = filebuf::openprot ); ifstream infile (" testfile.txt"); // deklaracja zmiennej i otwarcie pliku ifstream* infile; //deklaracja wskażnika infile = new ifstream("testfile.txt"); // utworzenie strumienia i otwarcie pliku ifstream infile; // deklaracja zmiennej infile.open("testfile.txt"); // otwarcie pliku ifstream infile; // deklaracja zmiennej infile.open("testfile.txt"); if (infile.fail()) { // otwarcie pliku nie powiodło się; //wyświetl komunikat błędu i wróć do programu } if (!infile) {// otwarcie pliku nie powiodło się;}

22 Programowanie C Zdefiniowanie strumienia ( obiekt klasy ifstream, ofstrem lub iofstream ) -Określenie i otwarcie konkretnego pliku -Wykonanie operacji we/wy -Likwidacja strumienia Operacje wejścia/wyjścia na plikach #include main(){ ostream plik_wyj; plik_wyj.open("pliczek.txt"); plik_wyj<<"Jakis tekst"; plik_wyj.close( ); }

23 Programowanie C++138 Otwarcie plików Otwarcia plików wejściowych i wyjściowych można dokonać za pomocą konstruktorów lub funkcji open (mają takie same parametry): void open ( char* name, int mode = ***, int prot = filebuf::openprot ); Tryby otwarcia plików:

24 Programowanie C++139 Pliki binarne #include #include point.h" main() { clrscr(); char* nazwa="pliktest.000"; fstream plik(nazwa, ios::out|ios::binary); Point xx; if (plik) { plik.write((char *)&xx, sizeof(xx)); xx.Set(2,2); plik.write((char *)&xx, sizeof(xx)); } plik.close(); plik.open(nazwa, ios::in|ios::out|ios::nocreate); if (plik) while(!plik.eof()) {plik.read((char*)&xx,sizeof(xx)); cout<

25 Programowanie C++140 Wskaźnik pozycji w pliku Każdy plik posiada swój wskaźnik (albo do czytania, albo do pisania, albo dwa niezależne wskaźniki jeden do czytania a drugi do pisania). Wskaźniki te są typu streampos streampos tellg( );// funkcja klasy istream pokazuje jakie jest położenie wskaźnika do czytania streampos tellp( ); // funkcja klasy ostream pokazuje położenie wskaźnika pisania enum seek_dir // typ wyliczeniowy zdefiniowany w klasie ios określający punkt odniesienia { beg, // początek cur, // aktualna pozycja end }; // koniec istream& seekg (streampos, seek_dir = ios::beg); ostream& seekp(streampos, seek_dir = ios::beg); Plik w C++ może być otwarty jednocześnie do zapisu i oczytu. Korzystamy wówczas z klasy fstream: fstream strum(plik.txt, ios::in | ios::out)

26 Programowanie C++141 Modyfikacja pliku tekstowego #include main( int arg, char** argv) { fstream iofile(argv[1], ios::in|ios::out); if (!iofile) { cerr<<"Error: nie można otworzyc pliku"<

27 Programowanie C++142 Szablony funkcji Szablon - abstrakcyjny przepis na tworzenie konkretnego kodu. T jest parametrem szablonu Szablon musi być zdefiniowany w zakresie globalnym. void swap( int& n, int& m) { int temp = n; n = m; m = temp; } void swap(Date& d1, Date& d2) { Date temp = d1; d1 = d2; d2 = temp; } template void swap(T& x, T& y) { T temp = x; x = y; y = temp; } main ( ) { int m = 22, n = 33; cout<<" m = "<

28 Programowanie C++143 Szablony klas Szablony klas działają jak szablony funkcji generując klasy. template class X {...}; Funkcje składowe szablonu klasy są szablonami funkcji o takim samym nagłówku jak szablon klasy. template class X{}; main( ) { X x1;//O.K. const int n = 44; X x2;//O.K. int m = 66; X x3;//ERROR } template class X { T square (T t) { return t*t; } }; template T square (T t) { return t*t; }

29 Programowanie C++144 Szablon klasy stos template class Stack { private: int size; int top; T* data; public: Stack( int s = 100): size(s); top = -1; { data = new T[size]; } ~Stack( ) {delete [ ] data}; void push (const T& x) {data[++top] = x; } T pop() { return data[top--];} int isEmpty( ) const {return top = = -1;} int isFull( ) const { return top = = size - 1; } }; main ( ) { Stack stosint(5); Stack stosdata(10); Data x, y(2000,1,17); stosint.push(13); stosint.push(2); stosdata.push(x); stosdata.push(y); cout<

30 Programowanie C++145 Pojemniki Pojemnik to obiekt, który zawiera inne obiekty (np.tablica, stos). Klasa pojemnikowa (klasa - pojemnik) to klasa, której obiekty są pojemnikami. Pojemnik zwany jest homogenicznym jeśli wszystkie jego obiekty są tego samego typu lub heterogenicznym w przeciwnym przypadku. template class Vector{ protected: T* data; unsigned size; void copy(const Vector &); public: Vector (unsigned n = 10) : size(n), data( new T[size]) { } Vector ( const Vector & other) : size(other.size), data( new T[size]) { copy(other); } ~Vector {delete [ ] data;} Vector & operator = (const Vector &); T& operator [ ] (unsigned i) const {return data[ i ];} usigned Size( ) const {return size;} };

31 Programowanie C++146 Definicja funkcji składowych template Vector & Vector ::operator = (const Vector & other) { size = other.size; data = new T[size]; copy( other); return this*; } template void Vector ::copy( const Vector & other) { unsigned min_size = (size < other.size ? size : other.size); for (int i =0; i

32 Programowanie C++147 Dziedziczenie szablonów Dziedziczenie szablonów klas działa tak samo jak dziedziczenie zwykłych klas. template class Array : public Vector { protected: int i0; public: Array(int i, int j): i0(i), Vector (j-i+1) { } Array(const Array & other): i0(other.i0), Vector (other) { } T& operator [ ] (int i) const { return Vector ::operator [ ] (i-i0); } int firstSubscript( ) const { return i0;} int lastSubscript ( ) const { return i0+size - j; } }; #include #include "Array.h" main ( ) { Array x(1,3); x[1] = 2.22; x[2] = 3.33; x[3] = 4.44; cout<"x.Size( ) = "<

33 Programowanie C++148 Szablony jako parametry szablonów Ponieważ szablony klas pracują jak zwykłe klasy to można je przekazywać jako parametry innych szablonów. Stack > a; template class Matrix{ protected: Vector *> row; public: Matrix( unsigned r =1, unsigned c=1) : row { for (int i=0; i (c); } ~Matrix () { for (int i = 0; i size( ); } }; main ( ) { Matrix a(2,3); a[0][0] = 0.0; a[0][1] = 0.1; a[0][2] = 0.2; a[1][0] = 1.0; a[1][1] = 1.1; a[1][2] = 1.2; cout<<"Macierz ma "<

34 Programowanie C++149 Szablon klasy dla list jednokierunkowych Listy - struktury pozwalające na dynamiczną alokację pamięci, tworzone jako połączony ciąg węzłów, z których każdy zawiera dane składowe oraz wskaźnik do następnego węzła. template class ListNode { friend class List ; protected: T data; ListNode* next; public: ListNode(T& t, ListNode * p): data(t), next(p) { } }; template class List { protected: ListNode * first; ListNode * newNode( T& t, ListNode * p) { ListNode * q = new ListNode (t,p); return q; } int t data 12 next p ListNode

35 Programowanie C++150 Funkcje składowe szablonu listy Konstruktor domyślny ustawia wskaźnik first na 0 Destruktor będzie likwidował całą listę:... public : List ( ) : first(0) { } ~List ( ); void insert (T t); int remove (T& t); int isEmpty ( ) { return first == 0;} void print ( ); }; template List ::~List ( ) { ListNode * temp; for (ListNode * p = first; p; ) { temp = p; p = p->next; delete temp; } Funkcja insert tworzy nowy węzeł i wstawia go na początek listy: template void List ::insert (T t) { ListNode * p = newNode(t,first); first = p; }

36 Programowanie C++151 template int List ::remove ( T& t) { if (isEmpty()) return 0; t = first->data; ListNode * p = first; first = first->next; delete p; return 1; } template void List ::print ( ) { for (ListNode * p = first; p; p = p ->next) cout data ; cout<<* \n; } #include #include "List.h" main( ) { List liczby; liczby.insert(0); liczby.insert(1); liczby.insert(2); liczby.insert(3); liczby.print( ); int x; liczby.remove(x); cout<<"Usunięto "< 2 -> 1 -> 0 -> * Usunięto 2 2 -> 1 -> 0 -> * data 2 next data 1 next data 0 next

37 Programowanie C++152 Iteratory Iterator - obiekt mający zdolność poruszania się po elementach pojemników; działający jak wskaźnik pokazujący w danym momencie jeden element należący do pojemnika. Podstawowe operacje iteratora: inicjalizacja iteratora na początkowej pozycji pojemnika, pobranie wartości danych znajdujących się we wskazywanej pozycji, zmiana wartości danych na określonej pozycji, określenie czy we wskazywanej przez iterator pozycji znajduje się jakaś wartość, przesunięcie do następnej pozycji pojemnika. // Iterator.h template class Iterator { public: virtual int reset( ) = 0; virtual T operator ( )( ) = 0; virtual void operator = (T t) = 0; virtual int operator ! ( ) = 0; virtual int operator ++( ) =0; };

38 Programowanie C++153 Szablon iteratora dla szablonu klasy List // plik ListIter.h #include List.h #include Iterator.h template class ListIter: public Iterator { protected: ListNode * current; ListNode * previous; List & list; public: ListIter(List & l):list(l) {reset( );} virtual void reset( ) {previous = NULL; current = list.first;} virtual T operator ( ) ( ) {return current->data;} virtual void operator = (T t) {current->data=t;} virtual int operator ! ( ) ; virtual int operator ++( ) ; void insert (T t); void preInsert(T t); void remove( ); }; template int ListIter ::operator ! ( ) { if (current==NULL) if (previous==NULL) current=list.first; else current=previous->next; return (current!=NULL); } if (!it)... template int ListIter ::operator ++ ( ) { if (current==NULL) if (previous==NULL) current=list.first; else current=previous->next; else { previous=current; current=current->next; } return (current!=NULL); } for (it.reset(); !it; it++)...

39 Programowanie C++154 #include "List.h" #include "ListIter.h" #include "Date.h" main( ) { List Daty; ListIter it(Daty); Date today; it.insert(today); today.Forth(); it++; it.insert(today); today.Back(); it++; it.insert(today); Daty.print(); Date my(1994,4,19); it.reset(); it++; it=my; it++; it.remove(); for (it.reset(); !it; it++) {Date temp=it(); temp.Forth(); it = temp; } Daty.print(); } template void ListIter ::insert(T t) { ListNode * p=list.newNode(t,0); if (list.isEmpty( ) ) list.first=p; else { p->next= current->next; current->next=p; } } template void ListIter :remove( ) { if (current==list.first) list.first = current->next; else previous->next= current->next; delete current; current = 0; } > > >* > >*

40 Programowanie C++155 Przyjaciel Listy Lista może posiadać więcej niż jeden iterator: Iteratory są od siebie niezależne. // List.h template class List { friend class ListIter ; //.... }; template class ListNode { friend class List ; friend class ListIter ; //.... }; List list; ListIter it1(list), it2(list),it3(list); it1.insert(11.01); it1++; it1.insert(22.02); it1++; it1.insert(33.03); for (it2.reset(); !it2; it2++) it2=10*it2; it3=it1;


Pobierz ppt "Programowanie C++116 Strumienie wejścia/wyjścia ios istreamostream ifstream iostream ofstream istrstream istringstrem ostrstream ostringstream fstream."

Podobne prezentacje


Reklamy Google