Pobieranie prezentacji. Proszę czekać

Pobieranie prezentacji. Proszę czekać

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

Podobne prezentacje


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

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

2 Programowanie C++142 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++143 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++144 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++145 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"<

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

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

8 Programowanie C++148 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 = "<

9 Programowanie C++149 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 "<

10 Programowanie C++150 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 ( );

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

12 Programowanie C++152 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 = "<

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

14 Programowanie C++154 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 );

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

16 Programowanie C++156 Manipulatory strumieni Najbardziej popularne manipulatory strumieni:

17 Programowanie C++157 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<

18 Programowanie C++158 Operacje wejścia/wyjścia na plikach 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:

19 Programowanie C++159 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)

20 Programowanie C++160 Funkcje wirtualne main () { DatePolish today; DatePolish::SetFormat(DatePolish::TEXT); cout<<„\n Funkcja Write : „; today.Write(); cout<<„\n Funkcja Display ; „; today.Display; Date tomrrow(2000,1,11); tomorow.Display(); cout<<„\n Funkcja Display ; „; tomorow.Display(); ; } Funkcje wirtualne gwarantują tzw. dynamiczne wiązanie czyli wywołanie funkcji jest odłożone do czasu realizacji programu i jest zależne od obiektu, na rzecz którego dana funkcja jest wywoływana. Funkcja Write : 10 Styczeń 2000 Funkcja Display : Funkcja Display: class Date {... virtual Write (ostream& output = cout) const... }; Funkcja Write : 10 Styczeń 2000 Funkcja Display : 10 Styczeń 2000 Funkcja Display :

21 Programowanie C++161 Polimorfizm Polimorfizm - pozwala by obiekty różnych typów powodowały różne działanie w wywołaniu tej samej funkcji. Jest to możliwe dzięki temu, że wskaźnik do obiektu klasy bazowej może również pokazywać na obiekty klas pochodnych. Aby uzyskać wiązanie dynamiczne parametry muszą być przekazywane przez wskaźnik bądź referencję Słowo virtual pojawia się tylko w deklaracji funkcji w klasie podstawowej, nie musi pojawić w klasie pochodnej Jeśli klasa bazowa deklaruje funkcję wirtualną to musi zawierać jej definicję nawet jeśli ciało funkcji jest puste Klasa pochodna nie musi definiować ponownie funkcji wirtualnej, wówczas domyślnie wywoływana jest funkcja z klasy bazowej Klasa pochodna we własnej definicji nie może zmieniać typu zwracanego przez funkcję wirtualną

22 Programowanie C++162 Wirtualne destruktory Destruktory definiujemy jako funkcje wirtualne! class X { private: int* p; public: X() {p = new int[2]; cout<<” X(). ”;} ~X() { delete [] p; cout<<”~X (). \n”;} }; class Y: public X{ private: int* q; public: Y() {q = new int[100]; cout<<”Y() : Y::q = ”<

23 Programowanie C++163 Czyste funkcje wirtualne i klasy abstrakcyjne Media Audio BookPeriodical CDMagazineNewspaperJournalTapeRecord Czysta funkcja wirtualna - funkcja nie mająca w swojej klasie implementacji. virtual void f( ) = 0; Abstrakcyjna klasa bazowa - klasa posiadająca jedną lub więcej czystych funkcji wirtualnych. class Media{ protected: String title; public: virtual void print( ) = 0; virtual char* id( ) = 0; }; class Book: public Media{ private: String author, publisher,isbn; public: void print ( ) { cout<

24 Programowanie C++164 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 = "<

25 Programowanie C++165 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; }

26 Programowanie C++166 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<

27 Programowanie C++167 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;} };

28 Programowanie C++168 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

29 Programowanie C++169 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( ) = "<

30 Programowanie C++170 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 "<

31 Programowanie C++171 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

32 Programowanie C++172 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; }

33 Programowanie C++173 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

34 Programowanie C++174 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; };

35 Programowanie C++175 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++)...

36 Programowanie C++176 #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; } > > >* > >*

37 Programowanie C++177 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++141 Strumienie wejścia/wyjścia ios istreamostream ifstream iostream ofstream istrstream istringstrem ostrstream ostringstream fstream."

Podobne prezentacje


Reklamy Google