Lista ocen osób, które uczestniczyły w egzaminie w pierwszym terminie. Wiersze zawierają: trzy ostatnie cyfry nr indeksu, liczbę zdobytych punktów i proponowaną ocenę.

1. ***235   9.5   2
2. ***274   8   2
3. ***466   11   2
4. ***468   15   3.5
5. ***475   2   2
6. ***478   8   2
7. ***482   6   2
8. ***511   18   4
9. ***512   12 + ε   3
10. ***526   6.5   2
11. ***531   8   2
12. ***536   8   2
13. ***553   16   3.5
14. ***587   7.5   2
15. ***595   10   2
16. ***639   16   3.5
17. ***658   18   4
18. ***659   14   3
19. ***807   5   2
20. ***810   22.5   5
21. ***867   2   2
22. ***986   9   2

W razie niejasności, proszę o kontakt mailowy.

Prace będą do wglądu we czwartek (8 lutego), w godz. 12:00-12:30 (lub do ostatniej zainteresowanej osoby) w pok. 1247, bud. 12.

Lista osób, które otrzymały ocenę pozytywną z zajęć lab. ale nie zostały zwolnione z egzaminu za bardzo dobre wyniki i osiągnęły co najmniej 50% pkt. na egzaminie zerowym. Wiersze zawierają: trzy ostatnie cyfry nr indeksu, liczbę zdobytych punktów i proponowaną ocenę.

1. ***238   17.5   4
2. ***272   19   4
3. ***172   23   5
4. ***479   20.5   4.5
5. ***533   22.5   5
6. ***543   13.5   3
7. ***548   14.5   3.5
8. ***560   19.5   4.5
9. ***561   13   3
10. ***563   18.5   4
11. ***578   14.5   3.5
12. ***579   14   3
13. ***585   12 + ε   3
14. ***594   13   3
15. ***627   19.5   4.5
16. ***637   20.5   4.5
17. ***677   15   3.5
18. ***729   15   3.5

Lista osób, które otrzymały ocenę pozytywną z zajęć lab., nie zostały zwolnione z egzaminu za bardzo dobre wyniki i uczestniczyły w egzaminie zerowym, ale liczba zdobytych na egzaminie punktów nie przekroczyła progowej wartości 50% możliwych do zdobycia. Wiersze zawierają trzy ostatnie cyfry nr indeksu.

1. ***235
2. ***466
3. ***468
4. ***475
5. ***478
6. ***482
7. ***511
8. ***512
9. ***526
10. ***531
11. ***536
12. ***553
13. ***595
14. ***658
15. ***867

W razie niejasności, proszę o kontakt mailowy.

Lista zawiera trzy ostatnie cyfry numeru indeksu osób zwolnionych z egzaminu za bardzo dobre wyniki na zajęciach lab.

1. ***065
2. ***245
3. ***378
4. ***467
5. ***487
6. ***497
7. ***501
8. ***534
9. ***545
10. ***614

Osoby te z egzaminu z wykładu otrzymują ocenę taką, jaką otrzymały z zajęć lab. tj. 5 (bardzo dobry), która zostanie wpisana do protokołu USOS jako ocena zdobyta w pierwszym terminie.

W razie niejasności proszę o kontakt mailowy.

Poprawa jednej oceny z zajęć lab.

1. Dn. 17 stycznia (środa) w pracowni komputerowej 119, bud. 21, w godz. 11:30 – 14:45 odbędą się zajęcia lab., na których będzie można uzyskać ocenę, która zastąpi jedną z ocen uzyskanych na zajęciach lab. w semestrze.
2. Zajęcia lab. w dn. 17 stycznia nie są obowiązkowe. Są to zajęcia tylko dla osób, które chcą skasować jedną ze swoich ocen i zastąpić ja nową oceną zdobytą na tych zajęciach. Np. jeżeli ktoś ma trzy zera z zajęć, co oznacza, że otrzyma ocenę negatywną z lab., może przyjść, aby zdobyć lepszą ocenę, która zastąpi jedno z tych zer.
3. Przed rozpoczęciem zajęć wszystkim uczestnikom kasowana jest jedna, wskazana przez nich ocena z zajęć lab. w semestrze. Jeżeli jest to ocena inna niż zero punktów, wskazane punkty są tracone bezpowrotnie.
4. Na zajęciach będzie do zrobienia jedno zadanie, za które można zdobyć do 10 pkt. Zadanie obejmuje materiał całego semestru. Warunki realizacji są takie same jak na zajęciach w semestrze, tj. praca samodzielna bez korzystania z zasobów internetu (za wyjątkiem strony https://cplusplus.com/ oraz platformy learningowej UKSW).
5. Zajęcia w tej sali są wspólne dla zainteresowanych z wszystkich trzech grup.

W razie niejasności proszę o pytania mailem.Warunki zwolnienia z egzaminu za bardzo dobre wyniki z lab. zostaną ustalone dopiero po zakończeniu semestru, kiedy będą znane wszystkie wyniki z lab.

Egzamin zerowy

1. Dn. 25 stycznia (czwartek) w sali wykładowej 205, bud. 21, w godz. 16:45 – 18:15 planowany jest egzamin zerowy z ZTP.
2. Egzamin jest pisemny. Proszę zabrać ze sobą kartki papieru i długopisy oraz legitymacje studenckie. Proszę być na miejscu kilka minut wcześniej, ponieważ sala zostanie otwarta już w trakcie przerwy, tak aby punktualnie o godz. 16:45 można było rozpocząć egzamin.
3. Szczegółowe zasady udziału są opisane na stronie www: Zasady zaliczenia wykładu, ale uwaga: (1) egzamin nie ma części praktycznej, to znaczy, nie będzie kartki z kodem programu, dla którego należy podać komunikaty wypisywane w oknie konsoli, (2) wszystkie osoby, które mają szansę na ocenę pozytywną z lab. na koniec semestru są oczekiwane na egzaminie.
4. Ocenie podlegają prace egzaminacyjne tylko tych osób, które na koniec semestru, tj. 26 stycznia (piątek) będą miały z zajęć lab. dostateczną liczbę punktów oraz spełnią warunki gwarantujące ocenę pozytywną.
5. Oceny pozytywne uzyskane z tego egzaminu są wpisywane do protokołu jako zdobyte w pierwszym terminie.
6. Oceny negatywne nie są nigdzie wpisywane i są zapominane.
7. Jeżeli będą takie osoby, które zostaną zwolnione z egzaminu za bardzo dobre wyniki lab., to proponowana im ocena zastąpi ocenę z egzaminu zerowego. Jednak decyzja o zastosowaniu w tym roku zwolnień z egzaminu za bardzo dobre wyniki jeszcze nie została podjęta.
8. Brak zainteresowania (niedostateczna liczba studentów na sali) spowoduje odwołanie egzaminu zerowego.

Zwracam uwagę na zasadę: Na egzaminie nie wolno sięgać do telefonów komórkowych. Telefony w czasie egzaminu muszą być wyciszone i schowane np. w torbie czy plecaku. Niestosowanie się do tej zasady skutkuje natychmiastowym zakończeniem egzaminu przez studenta i opuszczeniem sali.

Założenia

Przyjmijmy, że mamy zbiór punktów w przestrzeni n-wymiarowej, przy czym współrzędne pojedynczego punktu są reprezentowane w postaci wektora liczb rzeczywistych o długości n. Mówimy, że punkt A dominuje nad punktem B, jeżeli dla każdej współrzędnej A(i) odpowiadająca jej współrzędna B(i) jest mniejsza lub równa, oraz istnieje co najmniej jedna taka współrzędna j dla której A(j)>B(j). Można też wtedy powiedzieć, że B jest zdominowane przez A. Jeżeli natomiast dla pary punktów taki warunek nie jest spełniony, tj. ani A nie dominuje nad B, ani B nad A, wtedy uważamy punkty A i B za nieporównywalne względem siebie.

W zbiorze punktów punkt niezdominowany to taki, który może tylko dominować lub być nieporównywalnym z wszystkimi pozostałymi punktami.

Zadanie #1

Wygeneruj zbiór 100 losowych punktów w przestrzeni n-wymiarowej, po czym znajdź w nim zbiór punktów niezdominowanych. Algorytm znajdowania punktów niezdominowanych polega na porównaniu każdego punktu ze wszystkimi pozostałymi (nie dokonujemy porównania punktu z samym sobą). Jeżeli dla aktualnie sprawdzanego punktu z żadnego porównania nie wyniknie, że jest zdominowany, to znaczy, że jest niezdominowany. Kopię znalezionego punktu niezdominowanego należy zapisać w kontenerze pomocniczym. Na koniec sprawdzania kontener pomocniczy zawiera wyłącznie punkty niezdominowane.
Algorytm można zrealizować z pomocą dwóch kontenerów zawierających zestawy tych samych 100 punktów oraz kontenera pomocniczego, który początkowo jest pusty. Punkty z pierwszego kontenera są punktami sprawdzanymi, a punkty z drugiego – punktami z którymi dokonywane jest sprawdzenie. Do kontenera pomocniczego trafiają kopie tych punktów z kontenera pierwszego, które okazały się niezdominowane. Realizacja czynności odbywa się za pomocą dwóch pętli for – zewnętrznej (punkty z pierwszego kontenera) i wewnętrznej (punkty z drugiego kontenera).
Po zaimplementowaniu algorytmu spróbuj zaimplementować go ponownie, ale tym razem bez używania pętli for, while, repeat, natomiast stosując algorytmy STL oraz własne lub biblioteczne obiekty funkcyjne. Sprawdź, czy uzyskałeś ten sam wynik.

Zadanie #2

Wygeneruj zbiór 100 punktów losowo rozłożonych na okręgu (w przestrzeni 2-wymiarowej) o promieniu 1 (zobacz Zadania przed lab. 6: zadanie #2), po czym znajdź w nim zbiór punktów niezdominowanych. W kontenerze uporządkuj rosnąco niezdominowane punkty pod względem ich pierwszej współrzędnej. Wykorzystując algorytm adjacent_difference (slajdy 121 i 122, wykład 9) policz odległości euklidesowe miedzy sąsiednimi punktami (tj. między punktami 1 i 2, 2 i 3, 3 i 4, itd.). Uwaga: w obiekcie funkcyjnym służącym do obliczenia odległości euklidesowej miedzy dwoma punktami skorzystaj z algorytmu inner_product, tak jak to jest pokazane na slajdzie 121 wykładu 9. Policzone odległości zapisz do pomocniczego kontenera, a na koniec policz średnią odległość między punktami oraz wariancję tej odległości.
Przy pisaniu kodu programu unikaj pętli for, while, repeat, a zamiast nich stosuj algorytmy STL oraz własne lub biblioteczne obiekty funkcyjne.

Wskazówka: kod zawierający przykładowy fragment rozwiązania zadania 2 – wykorzystanie algorytmu inner_product do policzenia odległości euklidesowych miedzy sąsiednimi punktami: ZTP_Zad2przedLab7.cpp

Hint:

Zadanie dotyczące znajdowania zbioru punktów niezdominowanych może pojawić się na lab.7. Na zajęciach można będzie wykorzystać fragmenty własnego kodu opracowanego w domu.

Za zgodą Dziekana WMP.SNŚ w najbliższy czwartek, 14 grudnia, wykład ZTP od godz. 16:45 do 18:15 odbędzie się w trybie zdalnym na platformie MS Teams. Aby uczestniczyć w wykładzie należy dołączyć do zespołu WM-I-S1-E3-ZTP_2023/24_Z_WYK_GR1 korzystając z kodu: yv04q5s

Zadania, które dotyczą zakresu materiału, jaki będzie poruszany na lab. 6. Rozwiązanie nie jest wymagane. Zadania stanowią wyłącznie pomoc w przygotowaniu się do zajęć.

Zadanie #1:

Przyjmij, że A, B, C i D reprezentują punkty w przestrzeni n-wymiarowej. Punkty te są reprezentowane w programie przez wektory współrzędnych. Wektor A zawiera dla każdej współrzędnej uzyskaną niezależnie wartość losową z generatora liczb o rozkładzie jednostajnym z przedziału [-10,10]. Wektor B zawiera wartości stałe [1,..,1].

Pobierz od użytkownika liczbę wymiarów przestrzeni n, utwórz odpowiednich rozmiarów wektory, przy czym zainicjuj też odpowiednio A i B, a następnie napisz kod wykonujący kolejno następujące obliczenia:

1. D = A*B
2. C = 3*B + D
3. D = 3*(A+C)-(A*B)

gdzie operator '*’ oznacza mnożenie, przy czym kiedy argumentami są skalar i wektor, następuje przemnożenie wszystkich współrzędnych wektora przez skalar, natomiast w przypadku, kiedy argumentami są dwa wektory, jest to iloczyn Hadamarda (zobacz: https://pl.wikipedia.org/wiki/Mnożenie_macierzy). Sprawdź na danych testowych, czy obliczenia wykonują się poprawnie.

Uwaga – ograniczenie: do zaimplementowania w/w operacji nie wykorzystuj żadnych pętli (for, while, repeat), a wyłącznie algorytmy STL i obiekty funkcyjne (własne lub biblioteczne). Jeżeli to potrzebne, rozłóż operacje na pojedyncze kroki, których wynik zapamiętuj w wektorach pomocniczych.

Zadanie #2:

W celu wygenerowania punktu na powierzchni hipersfery (zobacz: https://pl.wikipedia.org/wiki/Hipersfera) z centrum w środku układu współrzędnych należy wykonać następujące kroki:

1. wygenerować wektor Z, którego każda współrzędna jest uzyskaną niezależnie wartością losową z generatora liczb o rozkładzie normalnym. Liczba współrzędnych wektora odpowiada liczbie wymiarów przestrzeni, w której definiowana jest hipersfera,
2. policzyć ||Z||, tj. długość wektora Z, a następnie podzielić każdą ze współrzędnych wektora Z przez tę długość.

Nowy wektor Z reprezentuje punkt na powierzchni hipersfery o promieniu 1 z centrum w środku układu współrzędnych.

Wygeneruj wiele takich punktów dla przestrzeni 2-wymiarowej i przedstaw je w postaci graficznej. Sprawdź, czy układają się w kształt okręgu.

Uwaga – ograniczenie: do zaimplementowania w/w operacji nie wykorzystuj żadnych pętli (for, while, repeat), a wyłącznie algorytmy STL i obiekty funkcyjne (własne lub biblioteczne). Jeżeli to potrzebne, rozłóż operacje na pojedyncze kroki, których wynik zapamiętuj w wektorach pomocniczych.

Zadania, które dotyczą zakresu materiału, jaki będzie poruszany na lab. 5. Rozwiązanie tych zadań nie jest wymagane. Stanowią wyłącznie pomoc w przygotowaniu się do zajęć.

Zadanie 1:

Napisz funkcję, która wczytuje macierz z pliku tekstowego zapisaną tak, że w kolejnych wierszach pliku są wartości komórek kolejnych wierszy macierzy rozdzielone spacjami, a następnie dokonuje jej transpozycji. Przyjmij, że wymiary wczytywanej macierzy są nieznane, ale że dane w pliku są na pewno poprawne (tj. wiersze przechowują tylko liczby, liczby liczb w wierszach są takie same, itp.). Do wczytania macierzy użyj kontenera typu <deque<deque<double>>. Funkcja zwraca transponowaną macierz w postaci wskaźnika do dynamicznie alokowanego kontenera typu vector<vector<double>>. Wypisz w oknie konsoli zawartość wynikowego kontenera i sprawdź, czy transpozycja została przeprowadzona poprawnie.

Zadanie 2:

Wczytaj słowa z kolejnych wierszy z pliku tekstowego do listy list, tj. kontenera typu list<list<string>>, tak aby kontener zawierał listę wierszy, gdzie każdy wiersz jest reprezentowany przez listę słów z tego wiersza. Posortuj rosnąco słowa z każdego wiersza wg zasady sortowania takiej jak w słowniku języka polskiego, a następnie scal posortowane listy słów do jednej listy wynikowej reprezentowanej przez inny kontener typu list<string>. Wypisz w oknie konsoli zawartość wynikowego kontenera w postaci kolumny i upewnij się, że sortowanie i scalanie się powiodło. Testy przeprowadź na pliku mistrz.txt

Zadanie, które dotyczy zakresu materiału, jaki będzie poruszany na lab. 4. Rozwiązanie tego zadania nie jest wymagane. Stanowi wyłącznie pomoc w przygotowaniu się do zajęć.

Zamieszczony poniżej kod programu reprezentuje przykład programowania z wykorzystaniem cech charakterystycznych. W programie wykorzystywane są dwie klasy reprezentujące dwa pojęcia:

1. temperatura_wody – liczba rzeczywista reprezentująca temperaturę wody
2. kostka_do_gry – liczba całkowita reprezentująca wartość, jaka może wypaść w wyniku rzutu kostką do gry.

Dla tych klas zdefiniowano ich cechy charakterystyczne. Są nimi:

1. _jest_liczba – cecha mówiąca, czy danych obiekt reprezentuje liczbę,
2. _jest_liczba_calkowita – cecha mówiąca, czy liczba którą reprezentuje danych obiekt, jest liczbą całkowitą,
3. _nalezy_do_przedzialu – cecha mówiąca, czy liczba którą reprezentuje danych obiekt, należy do przedziału,
4. _dolna_granica_przedzialu – wartość dolnej granicy przedziału, do którego mogą należeć liczby reprezentowane przez danych obiekt,
5. _gorna_granica_przedzialu – wartość górnej granicy przedziału, do którego mogą należeć liczby reprezentowane przez danych obiekt,

Cechy charakterystyczne zostały zaimplementowane w programie. W tym celu najpierw zostały zaimplementowane dwie klasy: Bazowe_Cechy oraz Cechy: public Bazowe_Cechy tworzące pojęcie zbioru cech.

Następnie dla każdej z dwóch klas: temperatura_wody i kostka_do_gry zostały skonkretyzowane w odpowiedni sposób przypisane im klasy cech:

1. Cechy<temperatura_wody>: public Bazowe_Cechy
2. Cechy<kostka_do_gry>: public Bazowe_Cechy

Działanie programu polega na gromadzeniu danych liczbowych różnych typów w kontenerach, przy czym kontenery do walidacji wprowadzanych danych używają cech charakterystycznych. W tym celu zdefiniowana została klasa reprezentująca kontener SzablonStosu przystosowany do przechowywania dowolnych wartości, w tym obiektów typu temperatura_wody i kostka_do_gry. Metoda push tego kontenera przed umieszczeniem danej dokonuje jej walidacji posługując się informacjami z klasy Bazowe_Cechy.

Wykorzystanie kontenera zostało zademonstrowane w funkcji main. W kodzie main tworzone są trzy kontenery K1, K2 i K3, a następnie są wypełniane wartościami. Uwaga: kontener K1 jest zapełniany wartościami tak długo, póki wystarczy zasobów komputera (w trakcie wykonania programu warto uruchomić menedżer zadań i w sekcji wydajności obserwować, jak ubywa wolnej pamięci w miarę pracy programu).

Zadania do zrobienia przed ćwiczeniami

1. Przenieś kod do środowiska VS C++, skompiluj i uruchom.
2. Przeanalizuj kod, upewnij się, że rozumiesz rolę wszystkich pól i metod w klasach i potrafisz to wyjaśnić na zajęciach.
3. Upewnij się, że potrafisz wyjaśnić, dlaczego tyle właśnie elementów zostaje umieszczonych w każdym z trzech kontenerów (a nie więcej).
4. dodaj do kodu jeszcze jedną klasę reprezentującą pojęcie liczbowe „numer kołnierzyka koszuli” i skonkretyzuj w odpowiedni sposób odpowiadającą jej klasę cech. Następnie, jeżeli to konieczne, rozszerz kod metody push tak aby poprawnie walidował obiekty nowego typu. W funkcji main dodaj kontener K4 w którym zgromadzisz kilka obiektów nowego typu.
5. Przygotuj się do rozwijania tego kodu dla potrzeb nowych rodzajów wartości, jakie można przechowywać w tym kontenerze.

Pliki do pobrania

Plik programu: ZPO-traits.cpp
Plik z danymi wejściowymi: qv-lab4 (po założeniu nowego projektu VC++ należy go umieścić w tym samym folderze, co plik z kodem programu).

 
/* ==========================
   (c) WMP.SNS UKSW, 2015
========================== */

#include<iostream>
#include<fstream>
#include<string>
#include<limits>
#include<exception>

using namespace std;

class _Bazowe_Cechy {
public:
	// pola statyczne stałe - dla stałych wartości całkowitych
	static const bool _jest_liczba = false;
	static const bool _nalezy_do_przedzialu = false;
	static const bool _jest_liczba_calkowita = false;
};

template<typename T>
class _Cechy : public _Bazowe_Cechy {
public:
	// metody statyczne - dla wartości innych typów niż liczby całkowite
	static const T _dolna_granica() { return T(); };
	static const T _gorna_granica() { return T(); };
};

template<typename T>
class Cechy : public _Cechy<T> {
};

class przyspieszenie {
	double a;
public:
	przyspieszenie(double acc = 0) : a(acc) {};
	double operator()() const { return a; };
	przyspieszenie& operator=(double acc) { a = acc; return *this; };
	bool operator<(const przyspieszenie& p) const { return (a < p.a); };
	friend ostream& operator<<(ostream& os, const przyspieszenie&);
};
ostream& operator<<(ostream& os, const przyspieszenie& p) { return os << p.a; };

template<>
class Cechy<przyspieszenie> : public _Cechy<przyspieszenie> {
public:
	static const bool _jest_liczba = true;
};

class temperatura_wody {
	double t;
public:
	temperatura_wody(double temp = 50) : t(temp) {};
	double operator()() const { return t; };
	temperatura_wody& operator=(double temp) { t = temp; return *this; };
	bool operator<(const temperatura_wody& tw) const { return (t < tw.t); };
	friend ostream& operator<<(ostream& os, const temperatura_wody&);
};
ostream& operator<<(ostream& os, const temperatura_wody& tw) { return os << tw.t; };

template<>
class Cechy<temperatura_wody> : public _Cechy<temperatura_wody> {
public:
	static const bool _jest_liczba = true;
	static const bool _nalezy_do_przedzialu = true;
	static const temperatura_wody _dolna_granica() { return temperatura_wody(0); };
	static const temperatura_wody _gorna_granica() { return temperatura_wody(100); };
};

class kostka_do_gry {
	int n;
public:
	kostka_do_gry(int num = 1) : n(num) {};
	int operator()() const { return n; };
	kostka_do_gry& operator=(int num) { n = num; return *this; };
	bool operator<(const kostka_do_gry& k) const { return (n < k.n); };
	friend ostream& operator<<(ostream& os, const kostka_do_gry&);
};
ostream& operator<<(ostream& os, const kostka_do_gry& k) { return os << k.n; };

template<>
class Cechy<kostka_do_gry> : public _Cechy<kostka_do_gry> {
public:
	static const bool _jest_liczba = true;
	static const bool _nalezy_do_przedzialu = true;
	static const bool _jest_liczba_calkowita = true;
	static const kostka_do_gry _dolna_granica() { return kostka_do_gry(1); };
	static const kostka_do_gry _gorna_granica() { return kostka_do_gry(6); };
};

class Przepelnienie : public exception {
	char opis[100];
public:
	Przepelnienie(const char* o) { strcpy_s(opis, o); }
	const char* what() const throw() { return opis; };
};
class BrakDanych : public exception {
	char opis[100];
public:
	BrakDanych(const char* o) { strcpy_s(opis, o); }
	const char* what() const throw() { return opis; };
};

template<typename T, int rozmiar, typename CechyT = Cechy<T>>
class SzablonStosu{
	T stos[rozmiar];
	int top;
public:
	int zajetosc() { return top; };
	SzablonStosu() : top(0) {}
	void push(const T& i) {
		if (top == rozmiar)
			throw Przepelnienie(typeid(i).name());
		stos[top++] = i;
	}
	void push(int i) {
		if (top == rozmiar)
			throw Przepelnienie(typeid(i).name());

		// walidacja wartości przekazanej do zapisu
		if (CechyT::_jest_liczba && CechyT::_jest_liczba_calkowita) {
			if (CechyT::_nalezy_do_przedzialu) {
				if (!(T(i) < CechyT::_dolna_granica()) && !(CechyT::_gorna_granica() < T(i)))
					stos[top++] = i;
			}
			else
				stos[top++] = i;
		}
	}
	void push(double i) {
		if (top == rozmiar)
			throw Przepelnienie(typeid(i).name());

		// walidacja wartości przekazanej do zapisu
		if (CechyT::_jest_liczba && !CechyT::_jest_liczba_calkowita) {
			if (CechyT::_nalezy_do_przedzialu) {
				if (!(T(i) < CechyT::_dolna_granica()) && !(CechyT::_gorna_granica() < T(i)))
					stos[top++] = i;
			}
			else
				stos[top++] = i;
		}
	}
	T pop() {
		if (top == 0)
			throw BrakDanych(typeid(stos[0]).name());

		return stos[--top];
	}
	template<typename U1, int r, typename U2>
	friend ostream& operator<<(ostream& os, const SzablonStosu<U1, r, U2>&);
};
template<typename U1, int r, typename U2>
ostream& operator<<(ostream& os, const SzablonStosu<U1, r, U2>& S)
{
	for (int i = 0; i < S.top; i++) cout << S.stos[i] << endl;
	return os;
};

int main() {
	SzablonStosu<string, 5> K1;
	SzablonStosu<przyspieszenie, 10> K2;
	SzablonStosu<temperatura_wody, 10> K3;
	SzablonStosu<kostka_do_gry, 10> K4;

	// zapełnianie stosów K1, K2, K3 i K4:
	ifstream fi("qv-lab4.txt");
	string s;
	try{
		K1.push("Henryk");
		K1.push("Sienkiewicz");
		while (fi) {
			fi >> s;
			K1.push(s);
			fi.seekg(ios::beg);
			fi.clear();
			cout << '*';
		};
	}
	catch (Przepelnienie& e){
		cout << "K1 gotowy: " << e.what() << endl;
	};
	cout << "Danych na stosie K1: " << K1.zajetosc() << endl << endl;

	K2.push(przyspieszenie());
	K2.push(przyspieszenie(5.0));
	K2.push(10);	// uwaga: nie akceptujemy przyspieszenia jako liczby całkowitej
	K2.push(10.0);
	cout << K2;
	cout << "Danych na stosie K2: " << K2.zajetosc() << endl << endl;

	K3.push(temperatura_wody());
	K3.push(temperatura_wody(36.6));
	K3.push(71.2);
	K3.push(112.1); // uwaga: nie akceptujemy wartości spoza przedziału
	cout << K3;
	cout << "Danych na stosie K3: " << K3.zajetosc() << endl << endl;

	K4.push(kostka_do_gry(3));
	K4.push(kostka_do_gry());
	K4.push(6);
	K4.push(10); // uwaga: nie akceptujemy wartości spoza przedziału
	cout << K4;
	cout << "Danych na stosie K4: " << K4.zajetosc() << endl << endl;

	// opróżnianie stosów
	try{
		while (true)
			K1.pop();
	}
	catch (BrakDanych& e) {
		cout << "K1 pusty: " << e.what() << endl;
	}
	try{
		while (true)
			K2.pop();
	}
	catch (BrakDanych& e) {
		cout << "K2 pusty: " << e.what() << endl;
	}
	try{
		while (true)
			K3.pop();
	}
	catch (BrakDanych& e) {
		cout << "K3 pusty: " << e.what() << endl;
	}
	try {
		while (true)
			K4.pop();
	}
	catch (BrakDanych& e) {
		cout << "K4 pusty: " << e.what() << endl;
	}

	system("pause");
	return 0;
}