//Michal Siemionczyk, sem. 6 SST

/* Niniejsze opracowanie zostalo podzielone na sekcje:

0. Wstep
1. Flagi(klasa ios_base)
	1.1 Spis flag
	1.2 Maski
	1.3 Funkcje do obslugi flag i podobne

2. Klasa Istream
3. Klasa Ostream
4. FLAGI BLEDU i F-CJE DO ICH OBSLUGI


############################ 0.   Wstep    ########################
Glowna klasa bazowa dla strumieni (czyli klasy iostream) jest ios_base. Dostarcza ona "flage stanu formatowania" oraz narzedzia do jej obslugi. 

Klasa dziedzicza po niej to basic_ios, ktora wnosi kilka ciekawych funkcji,
bedacych rozszerzeniem narzedzi do obslugi flag - ich opis znajduje sie w
punkcie 1.3.

Kolejna klasa, dziedziczaca po basic_ios, to ios. Najwieksza zaleta tej klasy
jest jej krotka nazwa, ktora mozna, zgodnie z regulami dziedziczenia, stosowac
zamiast ios_base. Dodatkowo, zawiera ona tzw. "flagi bledu" (opis w w pkt. 4)

Klasy Istream i Ostream dostarczaja mechanizmow zwiazanych z wieksza kontrola
nad odczytywaniem ze strumienia (Istream) oraz zapisywaniem do niego (Ostream)

Dodatkowo, ponizsze opracowanie omawia zagadnienie flag bledow (elementy klasy
ios),a takze metod zwiazanych z ich kontrola.

w funkcji main znajduja sie zakomentowane wywolania roznych funkcji, przedsta-
wiajacych funkcjonalnosc poruszanych zagadnien. Chcac poznac te funkcjonalnosci
nalezy odkomentowac dana funkcje, odnalezc i przeczytac jej definicje, obejrzec
wyniki programu.
*/
#include <iostream>

using namespace std;


//##################### 1.  FLAGI z OPISEM  POCZATEK ######################
/*Flagi sa polami zawierajacymi informacje tak/nie, dotyczaca formatowania. */
//###################   1.1 Spis flag ################################3

void flaga_skipws(){
	// flaga ios::skipsw domyslnie
	//wlaczona, powoduje ignorowanie bialych znakow, przyjmowanych przez 		//strumien,
	char temp[255], temp2[255];
	
	cout << "Testowanie flagi ios_base::skipsw." << endl;
	cout << "Wpisz dane (flaga wlaczona, ignoruje biale znaki)." << endl;
	cin >> temp;
	cout << temp << endl;

	cin.unsetf(ios::skipws);
	//wylaczenie flagi ios::skipsw za pomoca funkcji unsetf(fmtflags flaga)

	cout << "Wpisz dane (flaga wylaczona, toleruje biale znaki)." << endl;
	cin >> temp2; 
	// powyzsze sczytanie ze strumieniasie juz nie powiedzie - poprzednie
 	//wczytywanie bylo zakonczone znakiem konca wiersza [Enter], ktory
	// siedzial juz w buforze (nie zostal wczytany do zmiennej temp,
	// zakonczyl wczytyawnie do niej, program wypisze tylko znak konca 		//wiersza. 

	cout << temp2 << endl;
}


void flaga_justowanie(){
	/* FLagi ios::left, ios::right, oraz ios::internal oblsuguja 
	efekt justowania - czyli rownania wyswietlanego lancucha znakow
	do prawej, badz lewej czesci pola, na ktorym moze byc wys-
	wietlana. Flaga ios::internal "wyposrodkowuje" liczbe, lecz
	efekt ten uwidacznia sie dopiero przy ujemnych liczbach */	
	int dlugosc, liczba;

	cout << "Testowanie flag ios::left, ios::right, ios::internal, " <<
		"maski adjustfield, a takze funkcji width()" << endl;
	cout << "Podaj dlugosc pola, na ktorym bedzie wypisana liczba oraz " <<
		"sama, ujemna liczbe : " << endl;
	cin >> dlugosc >> liczba;
	cout.width(dlugosc);	//patrz funkcja_ios_base::width
				
	cout.setf(ios::left); // ustwienie "lewego justowania
	cout << liczba << " - ustawiona flaga ios::left" << endl;
	
	cout.width(dlugosc);
	cout.setf(ios::internal, ios::adjustfield); //ustawienie srodkowego
					//justowania za pomoca maski 
					//ios::adjustfield
	cout << liczba  << " - ustawiona flaga ios::internal" << 
		endl;
	
	cout.width(dlugosc);	
	cout.setf(ios::right, ios::adjustfield); //"prawe" justowanie
	cout << liczba <<  " - ustawiona flaga ios::right" << 
		endl;
}

void flaga_boolalpha(){
	/* Wlaczenie tej flagi powoduje, strumien majacy wypisac zawartosc 		zmiennej bool wynoszaca 1 (true) wypisze true, zas jezeli zmienna ma 		wartosc 0 (false) strumien wypisze false. Domyslnie flaga jest 		wylaczona - strumien wypisuje 1 badz 0.
	Podobnie jest przy wczytywaniu do obiektow typu bool - po ustawieniu 		tej flagi strumien bedzie spodziewac sie nie liczb 1 lub 0, ale slow 		true lub false. */
	bool a = (5==5)?true:false; //wpisanie do zmiennej a wartosci 'prawda'
	cout << "Flaga boolalpha jest wylaczona." << endl << "Wartosc " <<
		"'prawda' w zmiennej oznczana jest jako : " << a << endl;
	cout.setf(ios::boolalpha);	//ustawianie flagi
	cout << "Flaga boolalpha jest wlaczona." << endl << "Wartosc " <<
		"'prawda' w zmiennej oznczana jest jako : " << a << endl;
	

}

void flaga_postac_liczbowa(){
	//ios::dec, ios::hex, ios::oct
	/*Te trzy flagi decyduja o tym, czy wartosci liczbowe naszego programu
	 pojawialy sie beda na ekranie w postaci dziesiatkowej (dec),
	 szesnastkowej (hex) czy osemkowej (oct)
	Podobnie przy przyjmowaniu liczb (np. z klawiatury). Jezeli bedzie to
	 zapis „101” to strumien moze to uznac za liczbe w postaci
	 dziesiatkowej , szesnastkowej badz osemkowej.
	W jednej chwili tylko jedna flaga moze byc wlaczona.
	Domyslnie wszystkie trzy flagi sa wylaczone. Wowczas stosowana jest
	 notacja dziesiatkowa (dec). */
	int a = 113;
	cout.setf(ios::dec, ios::basefield);
	cout << "Flaga ios::dec wlaczona, 113 to: " << a << endl;
	cout.setf(ios::hex, ios::basefield); //uzycie maski basefield do zmiany
				//postaci liczb. Patrz
				// funkcja_ios_base::setf_maska() oraz
				// maski()
	cout << "Flaga ios::hex wlaczona, 113 to: " << a << endl;
	
	cout.setf(ios::oct, ios::basefield);
	cout << "Flaga ios::oct wlaczona, 113 to " << a << endl;
}

void flaga_showbase(){
	/*Ustawienie tej flagi odpowiada zadaniu, by liczby calkowite
	 wypisywane byly tak, zeby latwo moza bylo poznac to, w jakim systemie
	 sa one zapisane. Domyslnie ta flaga nie jest ustawiona. */
	cout << "Flaga ios::showbase WYLACZONA." << endl;
	flaga_postac_liczbowa(); //ios::showbase wylaczona
	cout.setf(ios::showbase);//wlaczenie flagi ios::showbase
	cout << "Flaga ios::showbase WLACZONA." << endl;
	flaga_postac_liczbowa(); // ios::showbase wlaczona;
	
}

void flaga_showpoint(){
	/*Przy wypisywaniu liczb zmiennnoprzecinkowych ustawienie tej flagi
	 powoduje, ze wypisywane sa zawsze nieznaczace zera i kropka
	 dziesietna. Jezeli np. obowiazuje dokladnosc wypisywania do szesciu
	 miejsc po kropce dziesietnej, to liczby wypisywane sa w sposob zgodny
	 z przykladek. Domyslnie flaga ta nie jest ustawiona. */
	double a = 72.1000;
	cout << a << endl;	//ios_showpoint wyl, obetnie zera
	cout.setf(ios::showpoint);
	cout << a << endl;	//ios_showpoint wl, pokaze zera
	
}

void flaga_uppercase(){
	/*Ustawienie tej flagi wlacza wyswietlanie niektorych formatow liczb z
	 uwzglednieniem powiekszenia ilczb oznaczajacych np. podstawe
	 konsersji 'x' lub wykadnik 'e' w notacji naukowej, czyli np. liczba
	 zapisana w formacie szesnastkowym 0x1a bedzie wyswietlana jako 0X1A,
	 zas liczba 33e-5 bedzie wyswietlana jako 33E-5.	
	Domyslnie ta flaga nie jest ustawiona. */
	double a = 33e-6;
	int b = 342;
	cout.setf(ios::hex, ios::basefield); cout.setf(ios::showbase);
				//po to, by wyswietlac int w formacie szes-
				//nastkowym
	cout << a << " " << b << endl;	//wyswietli z malymi formantami

	cout.setf(ios::uppercase); //wlaczenie flagi ios::uppercase;
	cout << a << " " << b << endl;	//wyswietli z duzymi formantami


}

void flaga_showpos(){
	/*Ustawienie tej flagi powoduje, ze przy wypisywaniu dodatnich liczb
	 dziesiatkowych zostana one poprzedzone znakiem + (plus), np. liczba
	 107.2 zostanie przedstawiona jako +107.2
	Domyslnie ta flaga nie jest ustawiona. */
	double a = 107.533;
	cout << a << endl;	//zwyczajnie, bez znaku +
	cout.setf(ios::showpos);//wlaczenie flagi
	cout << a << endl;	//ze znakiem +
}

void flaga_notacja(){
	/* Ustawienie flagi fixed sprawia, ze liczby rzeczywiste beda
	 wypisywane w postaci liczb dziesietnych, np. double liczba =
	 91234567.66666666 zostanie wypisana jako 91234567.66667.Ustawienie
	 flagi scientific sprawia, ze liczby beda wypisaywane w notacji
	 naukowej (wykladniczej), czyli wspomniana powyzej liczba zostanie
	 wypisana jako 9.123457e+007 (akurat obowiazuje zasada szesciu cyfr po
	 przecinku, jako domnienanej dokladnosci). Strumien sam zaokragla
	 ceche, konkretnie jej szoste miejsce po przecinku. 
	Domyslnie, jezeli nie jest ustawiona zadna z flag, wowczas sposob
	 zastosowany przez strumien do wypisywania liczby zalezec bedzie od
	 samej liczby. Mianowicie :
		- Gdy wykladnik liczby bedzie mniejszy niz -4 badz wiekszy od
	 obowiazujacej dokladnosci (domyslnie jest to 6) to uzyta zostanie
	 opcja wykladnicza.
		- W przeciwnym razie uzywana jest opcja notacji dziesietnej */

	ios::fmtflags pierwotne = cout.flags(); //zapis ustawien, patrz 
						//funkcja_ios_base::flags_bez
	double a = 91234567.66666666; //domyslnie bedzie tu uzyta notacja
	cout << a << endl;		// wykladnicza
	cout.setf(ios::fixed, ios::floatfield);	//ustawienie flagi
	cout << a << endl << endl;	//opcja "niedomyslna", dziesietna

	cout.flags(pierwotne); // "skasowanie flag" nalezacych do
					// maski floatfield, przywrocenie
					// sytuacji domyslnej
	double b = 923.23; //domyslnie bedzie tu uzyta notacja dziesietna
	cout << b << endl;
	cout.setf(ios::scientific, ios::floatfield);	//ustawienie flagi
	cout << b << endl;
}

//#########################    1.1 Spis Flag koniec #################3



//########################  1.2   MASKI ######################33
	/* Zwane rowniez polem. Ich zadanie to latwiejsze ustawienie
	 justowania, konwersji i notacji. Maska grupuje kilka flag
	 i pilnuje, aby na raz wlaczona byla tylko jedna.	
	Modyfikacji flag tworzacych grupe dokonuje sie za pomoca funkcji
	 ios_base::fmtflags setf(fmtflags flaga, fmtflags nazwa_pola) (patrz
	 funkcja_ios_base::setf_zwykla(); 
	Istnieja trzy maski : 
	- ios::adjustfield ("opiekuje" sie flagami ios::left, ios::right, 
			ios::internal, domyslna to ios::right) ,
	- ios::basefield (flagi ios::dec, ios::hex, ios::oct, domyslna to
	 ios::dec),
	-  ios::floatfield (flagi ios::fixed, ios::scientific, 
	domyslnie uzywana flaga zalezy od sytuacji - patrz flaga_notacja()) 
*/
void maski(){
	/*	Przyklad pokazuje jak zrobic to samo przy pomocy maski
		 ios::basefield i bez niej*/

	int a = 1234;
	cout.setf(ios::showbase); //ustawienie tej flagi dla celow pogladowych,
				  //patrz flaga_showbase();
	
	//############## uzycie maski do zmiany notacji START #########	
	cout << a << endl; //ustawiona jest flaga ios::dec, notacja dziesietna
	
	cout.setf(ios::hex, ios::basefield); //uzycie maski do zmiany flagi
	cout << a << endl; //ustawionaj jest ios::hex, notacja szesnastkowa

	cout.setf(ios::oct, ios::basefield); //uzycie maski do zmiany flagi
	cout << a << endl; //ustawiona jest ios::oct, notacja osemkowa;
	
	cout.setf(ios::dec, ios::basefield);	//przywrocenie stanu domyslnego
	//############# uzycie maski do zmiany notacji STOP ############

	cout << endl;
	//########### "zwykla" zmiana notacji START ##########
	cout << a << endl;
	cout.setf(ios::hex);	//ustawienie flagi ios::hex
	cout.unsetf(ios::dec);	//zdjecie aktywnej flagi ios::dec, nie moga byc
				//dwie na raz!
	cout << a << endl;	//ustawiona ios::hex, notacja szesnastk
	cout.setf(ios::oct); //ustwienie flagi ios::oct
	cout.unsetf(ios::hex);	//zdjecie flagi ios::hex
	cout << a << endl;
	cout.setf(ios::dec);	//przywrocenie stanu domyslanego czesc1
	cout.unsetf(ios::oct);	//przywrocenie stanu domyslnego czesc2
}

//############### 1.2 Maski     STOP   #####################33


//###############  1.3 Funkcje do obslugi flag i podobne START ############
void funkcja_ios_base_setf_zwykla(){
	/* ios_base::fmtflags setf(fmtflags ktore_flagi)
	Ustawia dana flage, podana w argumencie */
	int a = 107;
	cout << a << endl;
	cout.setf(ios::showpos);	//ustawienie flagi ios::showpos
	cout << a << endl;
}


void funkcja_ios_base_setf_maska(){
	/*ios_base::fmtflags setf(ftmflags flaga, fmtflags nazwa_pola)
	Funkcja mozna szybko ustawic flage nalezaca do grupy flag zwanej
	 „maska” badz „polem”.Flagi wchodzace w sklad danej „maski” musza byc
	 ustawione jako jedyne w grupie.*/
	int a = 107;
	cout << a << endl;
	cout.setf(ios::hex, ios::basefield); //ustawienie flagi ios::hex,
					//nalezacej do maski ios::basefield
	cout << a << endl;
	
}


void funkcja_ios_base_unsetf(){
	/*ios_base::fmtflags unsetf(fmtflags flagi) 
	Funkcja ta jako rezultat zwraca wartosc typu fmtflags opisujaca
	 dotychczasowy stan wszystkich flag formatowania. Funkcja ta sprawia,
	 ze wybrana flaga zostaje skasowana (zdjeta), a inne zas nietkniete. 
	*/
	int a = 1123;

	cout << a << endl;	//wyswietli w notacji dziesietnej

	cout.setf(ios::hex);	// ustawienie flagi ios::hex
	cout.unsetf(ios::dec);	//wylaczenie domyslnej flagi ios::dec
	cout << a << endl;	//wyswietli w notacji szesnastkowej

	cout.unsetf(ios::hex);	//wylaczenie flagi ios::hex, automatycznie
				//ustawiana jest domyslna flaga ios::dec
	cout << a << endl;	//wyswietlki znowu w notacji dziesietnej
}


void funkcja_ios_base_flags_argument(){
	/*ios_base::fmtflags flags(fmtflags zestaw)
	Funkcja, jako rezultat, zwraca wartosc typu fmtflags, obrazujaca
	 dotychczasoy stan wszystkich flag formatowania.
	Jako argument przyjmuje zestaw funkcji, ktory mozna podac za pomoca OR
	-owania kilku flag. Ustawia wowczas te flagi, ktore maja byc ustawione
	 (obecne w zestawie), zerujac zas pozostale zdejmuje.
	*/
	int a = 1023;
	cout << a << endl;
	cout.flags(ios::hex | ios::showbase | ios::uppercase); //wlaczenie 
				//3 flag na raz oraz automatyczne zadbanie
				//o to, by pozostale flagi zostaly przywrocone
				//do domyslnej wartosci
	cout << a << endl; 
}

void funkcja_ios_base_flags_bez(){
	/* ios_base::fmtflags flags()
	Zwraca wartosc typu ftmflags zawierajaca informacje o wszystkich
	 obecnie uzywanych flagach. Przydatne do sprawdzenia ustawienie jednej
	 flagi badz zapisu ustawien, celem poznniejszego do nich powrotu. 
	*/
	ios_base::fmtflags stare_ustawienia = cout.flags(); //zapisanie
					//starych ustawien
	
	cout.setf(ios::fixed, ios::floatfield);	//zmiana ustawien
	if(cout.flags() & ios_base::fixed)	//sprawdzenie ustawien
		cout << "Flaga fixed jest ustawiona!" << endl;
	
	cout.flags(stare_ustawienia);	//przywrocenie starych ustawien
	
	if(cout.flags() & ios_base::fixed)	//sprawdzenie ustawien
		cout << "Flaga fixed jest ustawiona!" << endl;	//tym razem
				//powyzszy napis sie nie wyswietli

	
}


void funkcja_ios_base_width_bez(){
	/* ios_base::streamsize width() const
	Funkcja ta zwraca obowiazujaca wlasnie szerokosc pola, na ktorym
	 wypisywana jest ze strumienia jakas liczba. 
	*/
	cout << "Obecnie ustawiona szerokosc pola liczby : " <<cout.width()<<
		endl;
}

void funkcja_ios_base_width(){
	/*ios_base::width(streamsize s)
	Funkcja okresla minimalna szerokosc pola, na ktorym ma byc wypisana
	 dana liczba. Okreslenie tej liczby dotyczy tylko najblizszej operacji
	 we/wy zwiazanej ze strumieniem, dla ktorego zostaje ona podana. 
	*/
	cout << "|";
	cout.width(10); //ustawienie szerokosci pola liczby na 10
	cout << 123 << "| - ta liczba jest na polu o szerokosci 10." <<
		endl;
	cout.width(0);
	cout << "|" << 123 << "| - ta liczba jest na polu o szerokosci 0." <<
		endl;
}

void funkcja_ios_base_precision_bez(){
	/*ios_base::streamsize precision() const
	Funkcja ta zwraca obecna dokladnosc wypisywania liczb
	 zmiennoprzecinkowych. Domyslnie ta dokladnosc wynosi 6.
	*/
	cout << cout.precision() << endl;	//wyswietla precyzje
}


void funkcja_ios_base_precision()
{
	/*ios_base::streamsize precision(int szerokosc) const
	Funkcja ustawia dokladnosc wypisywania liczb zmiennoprzecinkowych
	*/
	double a = 123.56789012345;
	cout << a << endl; //domyslnie dokladnosc wynosi 6
	cout.precision(10);//zmiana dokladnosci na 10
	cout << a << endl;//dokladnosc wynosi 10
}


void funkcja_basic_os_fill_bez(){
	/* basic_os:char fill()
	Funkcja ta zwraca znak uzywany obecnie jako wypelnienie pozostalego
	 miejsca przy wypisywaniu liczby na pole o wiekszej ilosci znakow niz
	 dlugosc liczby. 
	*/
	cout << "Mam" << cout.fill() << "na" << cout.fill() << "imie..." <<
		endl; //domyslnym znakiem jest spacja
}

void funkcja_basic_os_fill(){
	/*basic_os::char fill(char c)
	Funkcja ta zmienia znak wypelniajacy miejsce pozostale przy
	 wypisywaniu liczby na pole o wiekszej ilosci znakow.
	*/
	int a = 1024;	//liczba jest wypisywana na 4 znakach
	cout.width(12); //szerokosc pola jest wieksza o 8 znakow;
	cout << a << endl; //domyslny znak wypelniajacy to spacja ' ';
	cout.fill('*'); //zmiana znaku wypelniajacego na '*'
	cout.width(12);
	cout << a << endl;
		
}
//######################  1.3 Funkcje do obslugi flag i podobne KONIEC ##########

//######################  1. Flagi    KONIEC ################################



//################     2. Klasa ISTREAM START    ###########################

void funkcje_istream_get(){
	/*
	istream::int get() - pobiera znak z wejscia strumienia, rzutujac go na 
				integer
	istream::istream& get (char& c) - pobiera znak, zapisujac go w
				 zmiennej c,
	istream::istream& get(char* s, streamsize n) - pobiera (n-1) znakow
				ze strumienia, zapisujac je w tablicy s
	istream::istream& get (char* s, streamsize n, char delim) - pobiera
				(n-1) znakow ze strumienia, zapisujac je w s
				 do momentu napotkania znaku oznaczonego
				delim
	*/
 	char tekst[255];
	cin.get(tekst, 10);	//pobierzemy tylko 9 znakow ze strumienia
	cout << tekst << endl;
}



void funkcje_istream_getline(){
	/*
	istream& getline (char* s, streamsize n ) - pobiera (n-1) znakow,
		 zapisuje je do tablicy s; wczytywanie przerywa wystapienie
			znaku konca linii '\n';
	istream& getline (char* s, streamsize n, char delim ) - to samo, co
			wyzej, z tymze mozna podaj znak, ktory ma przerywac
			wczytywanie
	*/
	char tab[255];
	cin.getline(tab, 10, '*'); //wczytywanie przerywa wystapienie znaku '*'
	cout << tab << endl;
}

void funkcja_istream_gcount(){
	/* istream::streamsize gcount() const
		
	*/
	char tab[10];
	cout << "Podaj tekst o dlugosc do 10 znakow :" << endl;
	cin.getline(tab, 10);
	cout << tab << endl <<"A operowales przed chwila na ilosci znakow " <<
			" wynoszacej :  " << cin.gcount() << endl;

}

void funkcja_istream_ignore(){
	/* istream::istream& ignore ( streamsize n = 1, int delim = EOF )
	Pobiera ze strumienia wejsciowego ilosc znakow podana przez argument n
	 i pomija je. Pobieranie zatrzymuje sie w momencie napotkania na znak
	 ogranicznika delim. 
	*/
	char first, last;
	cout << "Podaj imie i nazwisko: ";
	first=cin.get();
	cin.ignore(256,' ');
	last=cin.get();
	cout << "Twoje inicjaly to  " << first << last << endl;
}


void funkcja_istream_peek(){
	/*istream:: int peek()
	Odczytuje i zwraca kolejny znak ze strumienia, bez usuwania go stamtad.
	*/
	char c;
	int n;
	char str[256];
	cout << "Wpisz liczbe lub slowo: ";
	c=cin.peek(); 
	if ( (c >= '0') && (c <= '9') ){
	  cin >> n;
	  cout << "Wpisales liczbe  " << n << endl;
	}else{
	  cin >> str;
	  cout << " Wpisales slowo " << str << endl;
	}
}

void funkcja_istream_read(){
	/*istream::istream & read (char *gdzie, streamsize n)
	 Wczytuje ona ze strumienia n znakow i umieszcza je do tablicy, ktorej
	 pierwszy element znajduje sie pod adresem gdzie. Znaki
	 alfanumeryczne, nowej linii, czy konca pliku - beda one umieszczane
	 we wskazanym miejscu pamieci. 
	*/
	char napis[10];
	for(int i = 0; i <10; i++) napis[i] = 0;	//"czyszczenie" tablicy
	cout << "Zawartosc tablicy przed : " << napis << endl;
	cout << "Wczytam tylko 4 bajty, napisz cos : ";
	cin.read(napis, 4);
	cout << "Wczytane bajty : " << napis << endl;		
}


void funkcja_istream_putback(){
	/*istream::istream & putback(char c)
	Pozwala na wlozenie z powrotem do strumienia znaku, ktory zostal z
	 niego wyjety. Wartym odnotowania jest fakt, ze standard nie definiuje
	 tego, co by sie stalo gdybysmy sprobowali wrzucic do strumienia inny
	 znak, niz zostal przed chwila z niego wyczytany. 
	*/
	char c,z;
	cin >> c;	//sczytanie znaku
	cout << "Przeczytany c=" << c << endl;
	cin.putback(c);	//odlozenie z powrotem
	cin >> z;
	cout << "Przeczytany z=" << z << endl;
}

//############################   2. Klasa ISTREAM KONIEC #################

//############################   3. Klasa OSTREAM START ##############3

void funkcja_ostream_put(){
	/*ostream::ostream & put(char c)
	Sluzy do wstawienia do strumienia pojedynczego znaku c.
	Zwraca jako wynik referencje do strumienia wyjsciowego, co pozwala na
	 kaskadowe laczenie uzycia tej funkcji, jak w przykladzie.
	Czasami wstawienie znakow do strumienia moze sie nie powiesc, np.
	 podczas wstawiania znakow do strumienia plynacego do pliku dyskowego
	 - np. dysk ulegl zapelnieniu. Wowczas funkcja zwraca, zamiast
	 refencji - zero.
	*/
	char napis[] = "kocham zpr";
	int i = 0;
	do{
		cout.put(napis[i]).put('-');	
	}while(napis[++i]);
	cout << endl;
}

void funkcja_ostream_write(){
	/*ostream::ostream & write(const char* s, streamsize n)
	Funkcja sluzy do wstawienia do strumienia zadanej liczby bajtow.
	Pierwszy argument jest wskaznikiem do tablicy char, z ktorej maja byc
	 pobrane bajty w celu wstawienia ich do strumienia. Drugi argument
	 definiuje liczbe bajtow (poczawszy od miejsca wskazywanego
	 wskaznikiem), ktore maja byc wstawione do strumienia.
	*/
	char napis[] = "Rembrandt";
	int i = 0; 
	cout.write(napis+3, 4);	//wypisze na ekranie "bran";
	cout << endl;
}

//####################     3. KLASA   OSTREAM    KONIEC ###################





//############### 4. FLAGI BLEDU i F-CJE DO ICH OBSLUGI START #########

void funkcje_flagi_bledu(){

/*	W kazdym obiekcie klasy IOSTREAM jest znajduje sie slowo odpowiadajace
	 za stan bledu strumienia. Jezeli nastepuje jakis blad pracy
	 strumienia - w tym slowie ustawiany jest bit odpowiadajacy za dana
	 kategorie bledu. Te kategorie bledow okreslone sa typem calkowitym
	 zdefiniowanym w klasie ios_base :ios_base::enum iostate

	ios_base::enum iostate
	{ 
		goodbit = 0,	//gdy pozostale flagi bledu sa wyzerowane
		eofbit = 1,	//gdy napotkany koniec pliku (EOF)
		failbit = 2,	//blad strumienia, nalezy zdjac flage i mozna
				//pracowac dalej
		badbit = 4	//awaria strumienia, nie mozna pracowac dalej
	};

	Funkcje do obslugi flag bledu to :
	basic_ios:: bool good();
	basic_ios::bool eof();
	basic_ios::bool fail();
	basic_ios::bool bad();
	Wszystkie powyzsze funkcje sprawdzaja, czy wlaczona jest odpowiednia
	flaga bledu.

	////przyklad uzycie f-cji basic_ios::good()
	char znak;
	do{
		cin >> znak;
		cout << znak;	
	}while(cin.good());	
	////////////////////////////////////////////

	////przykd uzycia f-cji basic_ios::eof()
	char dane[1000];
	ifstream s("wtorek.tmp", ios::in | ios::binary); //zakladamy istnienie
					// pliku wtorek.tmp w katalogu, 
		                   //w ktorym znajduje sie plik wykonywalny
	s.read(dane, sizeof(dane));
	if(s.eof())
	  cout << "Napotakny EOF przed wczytaniem wszystkich danych" << endl;
	else
	  cout << "Wszystkie dane wczytane O.K"
	////////////////////////////////////////
	
	

/*	###############  RECZNE USTAWIANIE i KASOWANIE FLAG BLEDU  ########
		
	Robimy to wtedy, gdy sami chcemy zdecydowac o tym, co jest popawna, a
	 co niepoprawna operacja we/wy. Przydaje sie to w przypadku operacji
	 we/wy z obiektami typu zdefiniowanego przez uzytkownika.


	w klasie IOS_BASE znajduja sie nastepujace funkcje przydatne przy
	 omawianym zagadnieniu :

	ios_base::io_state rdstate();
	ios_base::void clear(io_state = ios::goodbit);
	ios_base::void setstate(io_state stan); 	


	ios_base::io_state rdstate()
		Zwraca jako rezultat slowo typu io_state obrazujace stan flag
	 bledu danego strumienia. 
	/////////////       przyklad             /////////////////
	if(cin.rdstate() & ios:failbit)
		cout << "Flaga failbit jest ustawiona" << endl;
	/////////////////////////////////////
	

	
	ios_base::void clear(io_state = ios::goodbit)
		Dzialanie tej funkcji jest takie, ze argument bedacy slowem
	 stanu bledow strumienia (io_state) zastepuje calkowicie dotychczasowe
	 slowo stanu bledow strumienia, wszystkie flagi na raz. Wartosc
	 domniemana oznacza, ze w nowym slowie zadna flaga bledu nie jest
	 ustawiona. 
	/////////////////      przyklad1         //////////////////
	cin.clear(0);		//kasuje wszystkie flagi bledu
	cin.clear();		//kasuje wszystkie flagi bledu
	cin.clear(ios::eofbit);	//ustawia w strumieniu cin flage eofbit,
				 kasujac inne
	cin.clear(ios::eofbit | ios::failbit);// ustawia w strumieniu flagi
						 eofbit i failbit
	////////////////////////////////////////////////////////
	////////////////      przyklad2       /////////////////
	io_state slowo_stanu;
	slowo_stanu = wejscie.rdstate(); //odczytanie dotychczasowego stanu 
	slowo_stanu |= ios::eofbit; 	//"dopalenie" flagi ios::eofbit
	wejscie.clear(slowo_stanu);	//"podrzucenie" noweo slowa stanu
	//////////////////////////////////////////////////////


	ios_base::void setstate(io_state stan)
		Funkcja ta ulatwia „dopalenie” jednej flagi do biezacego slowa
	stanu. Jej definicja to: 
	void setstate(io_state f)
	{
		clear(rdstate() | f);
	}

	
*/

/////////////// przyklad uzycia f-cji basic_ios::fail() /////////////
	cout << "Funkcja oczekuje na podanie liczby. Podaj cos innego, " <<
		"uaktywnisz flage bledu basic_ios::failbit" << endl;	

	int liczba;
	cin >> liczba;
	if(cin.fail())
		cout << "Zle podana liczba !!" << endl;	
	
}
//################## 4. FLAGI BLEDU I FUNKCJE DO ICH OBSLUGI KONIEC ##########3





int main()
{
//#################     1. FLagi ######################3
	//flaga_skipws();	//flaga ios::skipsw
	//flaga_justowanie();	//flagi ios::left, ios::right, ios::internal
	//flaga_boolalpha();	//flaga ios::bootalpha
	//flaga_postac_liczbowa(); //flagi ios::dec, ios::hex, ios::oct
	//flaga_showbase();		//flaga ios::showbase
	//flaga_showpoint();		//flaga ios::showpoint
	//flaga_uppercase();		//flaga ios::uppercase
	//flaga_showpos();		//flaga ios::showpos
	//flaga_notacja();		//flagi ios::cientific, ios::floatfield
	//maski();		//maski ios::adjustfield, ios::basefield, 
				//ios::floatfield



	//funkcja_ios_base_setf_zwykla();//ios_base::fmtflags setf(fmtflags ktore_flagi)
	//funkcja_ios_base_setf_maska();  //ios_base::fmtflags setf(ftmflags flaga, fmtflags nazwa_pola)
	//funkcja_ios_base_unsetf();  //ios_base::fmtflags unsetf(fmtflags flagi)
	//funkcja_ios_base_flags_argument();  //ios_base::fmtflags flags(fmtflags zestaw)
	//funkcja_ios_base_flags_bez();  //ios_base::fmtflags flags()
	//funkcja_ios_base_width_bez();  //ios_base::streamsize width() const
	//funkcja_ios_base_width();  //ios_base::width(streamsize s)
	//funkcja_ios_base_precision();  //ios_base::streamsize precision(int szerokosc) const


	//funkcja_basic_os_fill_bez();  //basic_os:char fill()
	//funkcja_basic_os_fill();  //basic_os::char fill(char c)
//###################       Klasa ISTREAM ##########################
	//funkcje_istream_get();  //istream::rozne wersje f-cji get
	//funkcje_istream_getline();  //istream:: 2 wersje f-cji getline
	//funkcja_istream_gcount();  //istream::streamsize gcount() const
	//funkcja_istream_ignore();  //istream::istream& ignore ( streamsize n = 1, int delim = EOF )
	//funkcja_istream_peek();  //istream:: int peek()
	//funkcja_istream_read();  //istream::istream & read (char *gdzie, streamsize n)
	//funkcja_istream_putback();  //istream::istream & putback(char c)

//##############         Klasa OSTREAM #############################
	//funkcja_ostream_put();  //ostream::ostream & put(char c
	//funkcja_ostream_write();  //ostream::ostream & write(const char* s, streamsize n)

//###########3         Funkcje obslugi flag bledu ################
	//funkcje_flagi_bledu(); //rozne f-cje, patrz definicja
	return 0;

}