To jest stara wersja strony!
Strumienie są abstrakcyjnym pojęciem reprezentującym przestrzeń, na której wykonywawane są operacje wejścia i wejścia. Dokładniej, strumień reprezentuje źródło (bądź przeznaczenie) pewnego ciągu znaków o nieokreślonej długości.
Strumienie są zwykle powiązywane z określonym, fizycznym źródłem (bądź przeznaczeniem) ciągu znaków, jak np. plik na dysku, klawiatura czy konsola. Wynika stąd, że operacje na strumieniach są po prostu operacjami wejścia/wyjścia na wymienionych wyżej „fizycznych” urządzeń bądź programów.
Do zarządzania strumieniami w C++ wykorzystuje się standardową bibliotekę iostream
.
Klasa iostream
dziedziczy po klasach istream
(jej egzemplarzem, standardowo zdefiniowanym, jest strumień wejścia cin
) i ostream
(strumień wyjścia cout
), które z kolei dziedziczą po klasie ios
. Klasa ios
dziedziczy po klasie basic_os
, dla której klasą bazową jest natomiast ios_base
;
Poniżej został przedstawiony opis klas, po których dziedziczy klasa iostream
. Opis nie ma być kopią dokumentacji - jest stworzony, żeby po to, żeby przedstawić funkcjonalność związaną z wykorzystaniem elementów oraz funkcji składowych klas bazowych dla iostream
.
ios_base (Input Output State) jest podstawową klasą bazową dla pojęcia strumienia i operacji z nim związnych. Dostarcza pojęcie flagi stanu formatowania, a także narzędzi do jego wykorzystania.
ios_base::enum iostate / /typ wyliczeniowy odpowiadający za kategorie błędów stanu strumienia
ios_base::skipws / /flagi stanów formatowania
ios_base::left
ios_base::right
ios_base::internal
ios_base::boolalpha
ios_base::dec
ios_base::oct
ios_base::hex
ios_base::showbase
ios_base::showpoint
ios_base::uppercase
ios_base::showpos
ios_base::scientific
ios_base::fixed
ios_base::unitbuf
ios_base::adjustfield maski (pola)
ios_base::basefield
ios_base::floatfield
ios_base::ftmflags setf(fmtflags flaga)
ios_base::fmtflags setf(ftmflags flaga, fmtflags nazwa_pola)
ios_base::ftmflags unsetf(fmtflags flaga)
ios_base::ftmflags flags(fmtflags flaga)
ios_base::ftmflags flags()
ios_base::streamsize width() const;
ios_base::width(streamsize());
ios_base::precision() const;
ios_base::precision(streamsize);
ios_base::io_state rdstate()
ios_base::void clear(io_state = ios::goodbit)
ios_base::void setstate(io_state stan)
Flagi są polami zawierającymi informację tak/nie, dotyczącą formatowania.
Istnieje kilka sposób na ustawienie/zdjęć flag :
(skip white spaces) ustawienie tej flagi jest sugestią, by przyjmując znaki strumień ignorował ewentualne białe znaki (spacje, tabulatory, znaki nowej linii itp). Jeżeli ta flaga nie jest ustawiona, napotkanie białego znaku będzie równoznaczne z zasygnalizowaniem błedu strumienia. Domyślnie ta flaga jest ustawiona.
Trzy powyższe flagi obslugują justowanie. Justowanie polega na tym, że np. jeżeli liczba składająda się z 2 cyfr ma zostac wypisana na obszarze zajmującym 10 znaków, to może zostać wypisana z lewej strony tego obszaru (flaga left
), z prawej (flaga right
), bądź wyśrodkowana (flaga internal
). Naturalnym jest, że jednocześnie może być ustawiona tylko jedna flaga odpowiedzialna za justowanie. Domyslnie jest to flaga right
.
Te trzy flagi tworzą maskę (pole) adjustfield
.
Przykład (pseudokod, znak _ oznacza puste miejsce)
-42_______ //flaga left _______-42 //flaga right -_______42 //flaga internal
Włączenie tej flagi powoduje, strumień mający wypisać zawartość zmiennej bool wynoszącą 1 (true) wypisze true, zaś jeżeli zmienna ma wartość 0 (false) strumień wypisze false. Domyślnie flaga jest wyłączona - strumień wypisuje 1 bądź 0.
Podobnie jest przy wczytywaniu do obiektów typu bool - po ustawieniu tej flagi strumień będzie spodziewać się nie liczb 1 lub 0, ale słów true lub false.
Te trzy flagi decydują o tym, czy wartości liczbowe naszego programu pojawiały się będą na ekranie w postaci dziesiątkowej (dec), szesnastkowej (hex) czy ósemkowej (oct).
Podobnie przy przyjmowaniu liczb (np. z klawiatury). Jeżeli będzie to zapis „101” to strumień może to uznać za liczbę w postaci dziesiątkowej , szesnastkowej bądź ósemkowej.
W jednej chwili tylko jedna flaga może być włączona.
Domyślnie wszystkie trzy flagi są wyłączone. Wówczas stosowana jest notacja dziesiątkowa (dec).
Ustawienie tej flagi odpowiada żądaniu, by liczby całkowite wypisywane były tak, żeby łatwo moża było poznać to, w jakim systemie są one zapisane.
Domyślnie ta flaga nie jest ustawiona.
Przykład w postaci sformatowanej tabelki odpowiadającej sformatowanemu wyjściu:
hex oct dec flaga ustawiona 0xa4c 077 32 flaga nieustawiona a4c 77 32
Przy wypisywaniu liczb zmiennnoprzecinkowych ustawienie tej flagi powoduje, że wypisywane są zawsze nieznaczące zera i kropka dziesiętna. Jeżeli np. obowiązuje dokładność wypisywania do sześciu miejsc po kropce dziesiętnej, to liczby wypisywane są w sposób zgodny z przykładek. Domyślnie flaga ta nie jest ustawiona.
Przykład w postaci sformatowanej tabelki :
double m = 7.14 double n = 4 int k = 4 flaga ustawiona 7.140000 4.000000 4 flaga nieustawiona 7.14 4 4
Ustawienie tej flagi włącza wyświetlanie niektórych formatów liczb z uwzględnieniem powiększenia ilczb oznaczających np. podstawę konsersji 'x' lub wykadnik 'e' w notacji naukowej, czyli np. liczba zapisana w formacie szesnastkowym 0x1a będzie wyświetlana jako 0X1A, zaś liczba 33e-5 będzie wyświetlana jako 33E-5.
Domyślnie ta flaga nie jest ustawiona.
Ustawienie tej flagi powoduje, że przy wypisywaniu dodatnich liczb dziesiątkowych zostaną one poprzedzone znakiem + (plus), np. liczba 107.2 zostanie przedstawiona jako +107.2
Domyślnie ta flaga nie jest ustawiona.
Format wypisywanych przez strumień liczb zależy od obowiązującej w danej chwili dokładności. Domniemana wartość tej dokładności to sześć cyfr po przecinku.
Ustawienie flagi fixed sprawia, że liczby rzeczywiste będą wypisywane w postaci liczb dziesiętnych, np. double liczba = 91234567.66666666 zostanie wypisana jako 91234567.66667.
Ustawienie flagi scientific sprawia, że liczby będą wypisaywane w notacji naukowej (wykładniczej), czyli wspomniana powyzej liczba zostanie wypisana jako 9.123457e+007 (akurat obowiązuje zasada sześciu cyfr po przecinku, jako domnienanej dokładności). Strumień sam zaokrągla cechę, konkretnie jej szóste miejsce po przecinku.
Domyślnie, jeżeli nie jest ustawiona żadna z flag, wówczas sposób zastosowany przez strumień do wypisywania liczby zależeć będzie od samej liczby. Mianowicie :
- Gdy wykładnik liczby będzie mniejszy niż -4 bądź większy od obowiązującej dokładności (domyślnie jest to 6) to użyta zostanie opcja wykładnicza.
- W przeciwnym razie używana jest opcja notacji dziesiętnej
Ustawienie tej flagi jest rezygnacją z tak zwanego buforowania strumienia. Strumień niebuforowany nie jest tak efektywny, jak buforowany.
Przez domniemanie ta flaga jest ustawiona.
Zwane również polem. Ich zadanie to łatwiejsze ustawienie justowania, konwersji i notacji. Zadanie maski polega na grupowaniu kilku flag i pilnoawniu, aby na raz włączona była tylko jedna.
Modyfikacji flag tworzących grupę dokonuje się za pomocą funkcji ios_base::fmtflags setf(fmtflags flaga, fmtflags nazwa_pola)
Ta maska (pole) odpowiada za zagadnienie justowania, reprezentuje trzy wspomniane już flagi:
ios_base::left / / justowanie lewe
ios_base::right / / justowanie prawe
ios_base::internal / / justowanie wewnętrzne
Ta maska (pole) odpowiada za zagadnienia typu konwersji, reprezentuje flagi:
ios_base::dec / / konwersja decymalna
ios_base::oct / / konwersja oktalna
ios_base::hex / / konwersja heksadecymalna
Ta maska (pole) odpowiada za typ notacji, reprezentuje flagi:
ios_base::scientific / / notacja naukowa (wykładnicza)
ios_base::fixed / / notacja zwykla
Funkcja ta umożliwia ustawienie w słowie stanu tych flag, które przysłaliśmy we wzorze jako argument. Funkcja, jako rezultat, zwraca dotychczasowy stan wszystkich flag formatowania.
Typ fmtflags jest typem flag w klasie ios_base, poglądowo można śmiało przyjąć, że jest to inna nazwa na typ int, zaś poszczególne flagi są bitami wchodzącymi w skład tego typu.
//przykład cin.setf(ios::skipws); // ustawia flagę skipws odpowiadającą za ignorowanie białych znaków // przez strumień wejściowy cin. Inne flagi pozostają bez zmian. cin.setf(ios::skipws | ios::boolalpha) // ustawia jednocześnie obie flagi
Funkcją można szybko ustawić flagę należącą do grupy flag zwanej „maską” bądź „polem”. Istnieją trzy maski (opis niżej). Jedna z nich, odpowiadająca konwersji liczb to ios_base::basefield, w której skład wchodzą flagi ios_base::dec, ios_base::hex, ios_baze::oct. Flagi wchodzące w skład danej „maski” muszą być ustawione jako jedyne w grupie.
Np. mając strumień wypisujący dane w zapisie szesnastkowym, a chcąc, żeby wypisywał w zapisie dziesiątkowym, możemy zrobić np. tak
//przykład cout.setf(ios_base::dec); cout.unsetf(ios_base::hex);
bądź, z wykorzystaniem funkcji setf(flaga, nazwa_pola) :
//przykład cout.setf(ios_base::dec, ios_base::basefield); // ustawia flagę ios_base::dec, dbając o // wyłączenie pozostałych flag wchodzących // w skład pola ios_base::basefield
Dodatkowo, omawianą funkcją można skasować wszystkie flagi należące do tego pola, powracajac do sytuacji domniemanej. Robi się to podając jako pierwszy argument wartość zero.
//przykład cout.setf(0, ios::basefield); // skasowanie wszystkich flag
Funckja ta jako rezultat zwraca wartość typu fmtflags opisującą dotychczasowy stan wszystkich flag formatowania. Funkcja ta sprawia, że wybrana flaga zostaje skasowana (zdjęta), a inne zaś nietknięte.
//przykład cin.unsetf(ios::skipws); //skasowanie flagi ios::skipws
Funkcja, jako rezultat, zwraca wartość typu fmtflags, obrazującą dotychczasoy stan wszystkich flag formatowania.
Jako argument przyjmuje zestaw funkcji, który można podać za pomocą OR-owania kilku flag. Ustawia wówczas te flagi, które mają byc ustawione (obecne w zestawie), zerując zaś pozostałe zdejmuje.
Główna różnica pomiędzy funkcją flags() a funkcjami setf() oraz unsetf() jest taka, że flags() wpływa na pozostałe flagi, nie tylko na te podane jako argument zestaw (pozostałe są wyłączana)
//przykład cin.flags(ios_base::skipsw) // zdejmuje wszystkie flagi, ustawia tylko flagę // ios_base::skipsw
Zwraca wartość typu ftmflags zawierającą informację o wszystkich obecnie używanych flagach. Przydatne do sprawdzenia ustawienie jednej flagi bądź zapisu ustawień, celem późnniejszego do nich powrotu.
//przykład1 if(cout.flags() & ios_base::fixed) cout << "Flaga fixed jest ustawiona!";
//przykład2 ftmflags stare_ustawienia = cout.flas(); // zapisuje ustawienia flag strumienia cout cout.setf(ios_base::fixed); cout.setf(ios_base::skipsw); // włączenie różnych flag // ... cout.flags(stare_ustawienia) // przywrocenie poprzednich ustawien
Funkcja ta zwraca obowiązującą właśnie szerokość pola, na którym wypisywana jest ze strumienia jakaś liczba.
Funkcja określa minimalną szerokość pola, na którym ma być wypisana dana liczba.
Określenie tej liczby dotyczy tylko najbliższej operacji we/wy związanej ze strumieniem, dla którego zostaje ona podana.
//przykład int liczba = 107; cout << "Wypisz: " << liczba << "\nWypisz:"; cout.width(7); //określenie nowej szerokości pola liczby cout << liczba << ":" << endl;
Po uruchomieniu tego przykładu na ekranie pojawi się
//przykład Wypis:107: Wypis: 107:
W przypadku wczytywania danych ustawienie szerokości funkcją width() nie ma wpływu na wczytywane liczby, zaś zmieni sposób wczytywania ciągu znaków (tekstu). Dzięki temu można np. zapobiec przekroczeniu rozmiaru tablicy przeznaczonej do przyjęcia znaków, jak w poniższym przykładzie :
//przykład char napis[7]; cin.width(sizeof(napis)); // określenie szerokości (długości) pobieranego ciągu znaków cin >> napis;
Warto zauważyć, że w powyższym przykładzie zostanie wczytanych 6 znaków, a nie 7, ponieważ C-stringi (char napis[7]) muszą posiadać na końcu znak null, który jest tam automatycznie dodawany.
Funkcja ta zwraca obecną dokładność wypisywania liczb zmiennoprzecinkowych.
Domyślnie ta dokładność wynosi 6.
Uwaga. Patrz flagi ios_base::fixed oraz ios_base:scientific
Funkcja ta przyjmuje jako argument wartość streamsize (przyjmijmy, że jest to inna nazwa typu int), która oznacza nową dokładność wypisywania liczb zmiennoprzecinkowych. Zwracana wartość jest równa starszej, zastępowanej dokładności wypisywania liczb zmiennoprzecinkowych.
//przykład double x = 72.123456789; y = 10.55; z = 2; cout << "Obecna dokładność = " << (cout.precision()) << endl; cout << "Domniemany : " << "x=" << x << " y=" << y << " z=" << z << endl; //Wypisze x=72.1235 y=10.55 z=2 cout.precision(2); cout << "Po zmianie : " << "x=" << x << " y=" << y << " z=" << z << endl; //Wypisze x=72 y=11 z=2
Klasa dziedzicząca po ios_base.
basic_os::char fill(char c)
basic_os::char fill()
basic_ios:: bool good() / /opis we flagach stanów
basic_ios::bool eof()
basic_ios::bool fail()
basic_ios::bool bad()
Funkcja ta zmienia znak wypełniający miejsce pozostale przy wypisywaniu liczby na pole o większej ilości znaków, niż długość liczby, np. liczba jest dwucyfrowa, a ma byc wypisana na 7 miejscach (zostało to ustalone za pomocą, więc pozostale miejsca są domyslnie wypełniane spacjami. Nowy znak dopełniający miejsce w takich przypadkach jest właśnie argumentem tej funkcji.
Wartość zwracana jest wypełniającym znakiem, obowiązującym do momentu wywołania tej funkcji.
int liczba = 1024; cout.width(9); cout.fill('*'); cout << "Liczba:" << liczba << ":" << endl;
Wywolanie powyższego przykładu zaowocuje pojawieniem się na ekranie następującej sekwencji
Liczba:*****1024:
Funkcja ta zwraca znak używany obecnie jako wypełnienie pozostałego miejsca przy wypisywaniu liczby na pole o większej ilości znaków niż długość liczby.
Klasa dziedzicząca po basic_ios.
ios::goodbit
ios::eofbit
ios::badbit
ios::failbit
istream::int get()
istream::istream& get (char& c)
istream::istream& get(char* s, streamsize n)
istream::istream& get (char* s, streamsize n, char delim)
istream::istream& getline (char* s, streamsize n )
istream::istream& getline (char* s, streamsize n, char delim )
istream::streamsize gcount() const
istream::istream& ignore ( streamsize n = 1, int delim = EOF )
istream:: int peek()
istream::istream & read (char *gdzie, streamsize n)
istream::stremsize readsome(char* s, streamsize n)
istream::istream & putback(char c)
istream::istream & unget()
Pobiera jeden znak ze strumienia i zwraca jego wartosc rzutowana na typ integer.
<copy cpp> przyklad char c, str[256]; ifstream is; cout « „Wpisz nazwe pliku istniejacego w biezacym katalogu”; cin.get (str,256); is.open (str); otwieranie pliku
while (is.good()) petla trwajaca ile sie da { c = is.get(); pobierza znak z pliku
cout << c;
}
is.close(); zamykanie pliku </copy> == istream::istream& get (char& c) == Pobiera ze strumienia jeden znak i przechowuje go w zmiennej, do ktorej zostala podana referencja c. ==istream& get(char* s, streamsize n)== Pobiera ze strumienia n-1 znakow badz pobiera je do momentu wystapienia znaku ogranicznika (domyslnie znak konca wiersza '\n') i lokuje je do tablicy rozpoczynającej się s. w momencie natrafienia na znak ogranicznika, jest on automatycznie dodawany do tablicy s. ==istream& get (char* s, streamsize n, char delim)== Podobnie jak wyżej, z tymże przyjmuje znak ogranicznika w argumencie delim. ==istream& get(streambuf& sb) - pobiera ze strumienia znaki i lokuje je w buforze strumieniowym sb do momentu napotkania znaku ogranicznika (domyslnie znak konca wiersza '\n') badz znaku konca pliku. istream& get(streambuff& sb, char delim) - podobnia jak wyżej, z tymże przyjmuje znak ogranicznika w argumencie delim.