Projekt ZOO

#include "stdafx.h" //Przy projektowaniu w Microsoft Visual C++

#include <stdio.h>

#include <stdlib.h>

#include <iostream>

#include <fstream>

#include "PlikNaglowkowy.h"

using namespace std;

class BazaDanych{

public:

virtual void save() = 0;

virtual void load() = 0;

};

class Zwierze{

public:

char* nazwa;

int wysokosc;

double waga;

char* ubarwienie;

Zwierze(char*nazwa, int wysokosc, double waga, char*ubarwienie){

this->nazwa = new char[strlen(nazwa) + 1];

strcpy(this->nazwa, nazwa);

this->wysokosc = wysokosc;

this->waga = waga;

this->ubarwienie = new char[strlen(ubarwienie) + 1];

strcpy(this->ubarwienie, ubarwienie);

}

virtual void show() = 0;

virtual void zamienNaNapis(ostream& out) = 0;

virtual void setNazwa() = 0;

virtual void setWysokosc() = 0;

virtual void setWaga() = 0;

virtual void setUbarwienie() = 0;

virtual void setInne() = 0;

~Zwierze(){

delete[] nazwa;

delete[] ubarwienie;

}

};

/*Importowanie bibliotek niezbędnych dla programu. Pierwsza z nich jest potrzebna tylko jeśli program jest pisany w Visual Studio C++. Biblioteka fstream służy do obsługi strumieni wejściowych i wyjściowych na plikach.

Klasa BazaDanych jest abstrakcyjną klasą do zarządzania bazą danych. Umieszczone są w niej metody wirtualne load() i save(), służące do zapisywania i wczytywania zawartości bazy do programu.

Klasa Zwierze jest także abstrakcyjna. Z niej dziedziczą klasy różnych gatunków zwierząt, które wszystkie łączy to, że (poza tym, że są zwierzętami), mają pewne cechy wspólne. Są to między innymi: nazwa (imię), wysokość, waga oraz ubarwienie.

Konstruktor zwierzęcia składa się z tych właśnie wspólnych cech, którymi możemy opisać każde zwierzę. Ponieważ nazwa jest typu wskaźnikowego, nie można kopiować jej do innej zmiennej w zwykły sposób przypiasania tak jak zmienne typu całkowitego (integer), lecz nalerzy użyć bardziej złożonej procedury. W dynamiczny sposób wydzielana jest pamięc dla nazwy rezerwując dla niej tyle miejsca ile zajmuje nazwa z konstruktora. Za pomocą strlen sprawdzana jest długość nazwy. Dodany jest jeden znak dodatkowy na wartość null, która powinna być na końcu każdego char*. Za pomocą dwuargumentowej funkcji strcpy kopiowana jest zawartość drugiego elementu do pierwszego. Wten sam sposób odbywa się to z kopiowaniem ubarwienia.

Klasa ta zawiera także 7 metod wirtualnych, które są zdefiniowane w każdej z klas dziedziczących.

Nazwa oraz ubarwienie są typu wskaźnikowego i wygenerowana dla nich pamięć jest stale zajmowana, dlatego konieczny jest tzw. destruktor, który usuwa te zmienne za pomocą słowa kluczowego delete. Destruktor wykorzystywany jest w klasie ListaZwierzat w metodzie remove(), która służy do usuwania zwierząt z Zoo.*/

class Node{

public:

Node* next;

Zwierze* zwierz;

Node(Zwierze* zwierz){

this->zwierz = zwierz;

next = NULL;

}

void show(){

zwierz->show();

}

void setNazwa(){

zwierz->setNazwa();

}

void setWysokosc(){

zwierz->setWysokosc();

}

void setWaga(){

zwierz->setWaga();

}

void setUbarwienie(){

zwierz->setUbarwienie();

}

void setInne(){

zwierz->setInne();

}

};

class Delfin : public Zwierze{

public:

int IQ;

Delfin(char*nazwa, int wysokosc, double waga, char*ubarwienie,

int IQ):Zwierze(nazwa, wysokosc, waga, ubarwienie){

this->IQ = IQ;

}

void show(){

cout << endl

<< "***INFORMACJE O DELFINIE***" << endl << endl

<< " Nazwa: " << this->Zwierze::nazwa << endl

<< " --> wysokosc: "

<< this->Zwierze::wysokosc << "cm" << endl

<< " --> waga: "

<< this->Zwierze::waga << "kg" << endl

<< " --> ubarwienie: "

<< this->Zwierze::ubarwienie << endl

<< " --> iloraz inteligencji: IQ "

<< IQ << endl << endl;

}

void zamienNaNapis(ostream& out){

out << endl << 1 << ";"

<< nazwa << ";"

<< wysokosc << ";"

<< waga << ";"

<< ubarwienie << ";"

<< IQ;

}

/*Klasa Node (kolejka) jest czymś w rodzaju kolekcji, która współdziała z klasą ListaZwierząt, będącą czymś w rodzaju zwykłej listy lub tablicy, w której mieszczą się wszystkie obiekty zwierzęta.

Dzięki tej klase możemy poruszać się na liście zwierząt między poszczególnymi jej elementami.

Tworząc nowy obiekt za pomocą konstruktora Node, zmienna next ustawiana jest na wartość null, ponieważ gdy będziemy chcieli dodać nowe zwierzę do listy, będziemy musieli dadać je na koniec listy, czyli w miejsce wartości null.

Ponadto, dzięki klasie Node możemy dostać się do zdefiniowanych dla każdego zwierzęcia metod typu void, (takich jak show(), setNazwa(), setUbarwienie() itp.) w kontekście konkretngo zwierzęcia. Metoda setInne() odnosi się do cechy charakterystycznej, każdego gatunku, którą wyróżnia się każdy gatunek.

Klasa Delfin oraz pozostałe klasy z innych gatunków, dziedziczą po abstrakcyjnej klasie Zwierze.

Cechą charakteryzującą dla delfinów jest ich inteligencja, podawana w skali IQ.

W konstruktorze cztery pierwsze argumenty przekazywane są do konstruktora Zwierza, po którym dziedziczy Delfin, a ostatni kopiowany jest do wewnętrznej zmiennej, jaką jest IQ.

Metoda show() zamieszczona jest w każdej z klas różnych gatunków. Wyświetla ona wszystkie informacje o zwierzęciu w przejrzysty dla użytkownika sposób. Ponieważ nazwa, wysokość, waga i ubarwienie należą do klasy zwierze, trzeba odwołać się do nich za pomocą następującego zwrotu: Zwierze::ubarwienie, poprzedzając go słówkiem this.

ZamienNaNapis(ostream& out) jest funkcją, zapisującą do strumienia wyjściowego out informacje o utworzonym zwierzęciu w określonym formacie. Argumentem jest tutaj plik, który jest strumieniem utworzonym w funkcji save() z klasy ListaZwierzat. Liczba 1 jest identyfikatorem gatunku. W tym przypadku oznacza ona rodzinę delfinów.*/

void setNazwa(){

char noweImie[100];

cout << endl << "Podaj nowe imie dla delfina \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> noweImie;

this->Zwierze::nazwa = new char[strlen(noweImie) + 1];

strcpy(this->Zwierze::nazwa, noweImie);

cout << "Imie zostalo zmienione na \""

<< this->Zwierze::nazwa << "\"." << endl;

}

void setWysokosc(){

int nowaWys;

cout << endl << "Podaj nowa wysokosc dla delfina \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> nowaWys;

this->Zwierze::wysokosc = nowaWys;

cout << "Wysokosc zwierzecia \"" << this->Zwierze::nazwa

<< "\" zostala zmieniona na "

<< this->Zwierze::wysokosc << "." << endl;

}

void setWaga(){

double nowaWaga;

cout << endl << "Podaj nowa wage dla delfina \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> nowaWaga;

this->Zwierze::waga = nowaWaga;

cout << "Waga zwierzecia \"" << this->Zwierze::nazwa

<< "\" zostala zmieniona na " << this->Zwierze::waga

<< "." << endl;

}

void setUbarwienie(){

char noweUb[100];

cout << "\nPodaj nowy kolor ubarwienia dla delfina \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> noweUb;

this->Zwierze::ubarwienie = new char[strlen(noweUb)+1];

strcpy(this->Zwierze::ubarwienie, noweUb);

cout << "Ubarwienie zwierzecia \"" << this->Zwierze::nazwa

<< "\" zostalo zmienione na kolor \""

<< this->Zwierze::ubarwienie << "\"." << endl;

}

void setInne(){

int noweIQ;

cout << "\nPodaj nowy iloraz inteligencji dla delfina \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> noweIQ;

IQ = noweIQ;

cout << "Iloraz inteligencji zwierzecia \""

<< this->Zwierze::nazwa << "\" zostala zmieniona na "

<< IQ << "." << endl;

}

};

/*Za pomocą setNazwa() zmieniamy nazwę zwierzęcia. Odbywa się to w trybie tekstowym na konsoli. Użytkownik pytany jest o nowe imię na jakie ma być zmienione stare. Zmienna noweImie jest typu char. Z góry ograniczona jest pojemność tej zmiennej przez sto znaków. Dzięki temu zmiennej tej nie trzeba pamiętać kasować, ponieważ znika ona sama z pamięci po zakączeniu wykonywania metody.

NoweImie kopiowane jest do nazwy za pomocą strcpy.

Na koniec użytkownik dostaje potwierdzenie zmiany imienia, poprzez wyświetlenie go na ekran, odwołując się do nazwy zwierza, na rzecz którego imie zostało zmienione.

Podobnie odbywa się to w metodzie setWysokosc() i setWaga(). Z tą tylko różnicą, że wysokość i waga zwierzęcia jest zapisana w zmiennej typu int i nowa wartość przypisywana jest do starej zmiennej za pomocą znaku równości.

W setUbarwienie() wszystko odbywa się identycznie jak w setNazwa(), ponieważ ubarwienie jest też typu char.

Metoda setInne() nie różni się wiele od setWysokosc() i setWaga() opisanych powyżej. Jest to funkcja występująca w każdym ze zwierząt, lecz w każdym z nich ustawia nowe wartości dla innych zmiennych (opisujących cechy charakterystyczne każdego ze zwierzęcia).

Tu nie trzeba odwoływać się do zmiennej opisującą cechę szczególną z klasy zwierze, poniewzaż tam ona nie występuje. Jest to zmienna powiązana z tą klasą i może być używana tylko w kontekście tej klasy.*/

class Kot : public Zwierze {

public:

int dlugoscOgona;

Kot(char* nazwa, int wysokosc, double waga, char* ubarwienie,

int dlugoscOgona):Zwierze(nazwa, wysokosc, waga, ubarwienie){

this->dlugoscOgona = dlugoscOgona;

}

void show(){

cout << endl << "***INFORMACJE O KOCIE***" << endl << endl

<< " Nazwa: " << this->Zwierze::nazwa << endl

<< " --> wysokosc: "

<< this->Zwierze::wysokosc << "cm" << endl

<< " --> waga: "

<< this->Zwierze::waga << "kg" << endl

<< " --> ubarwienie: "

<< this->Zwierze::ubarwienie << endl

<< " --> dlugosc ogona: "

<< dlugoscOgona << "cm" << endl << endl;

}

void zamienNaNapis(ostream& out){

out << endl << 2 << ";"

<< nazwa << ";"

<< wysokosc << ";"

<< waga << ";"

<< ubarwienie << ";"

<< dlugoscOgona;

}

void setNazwa(){

char noweImie[100];

cout << endl << "Podaj nowe imie dla kota \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> noweImie;

this->Zwierze::nazwa = new char[strlen(noweImie) + 1];

strcpy(this->Zwierze::nazwa, noweImie);

cout << "Imie zostalo zmienione na \""

<< this->Zwierze::nazwa << "\"." << endl;

}

void setWysokosc(){

int nowaWys;

cout << endl << "Podaj nowa wysokosc dla kota \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> nowaWys;

this->Zwierze::wysokosc = nowaWys;

cout << "Wysokosc zwierzecia \"" << this->Zwierze::nazwa

<< "\" zostala zmieniona na "

<< this->Zwierze::wysokosc << "." << endl;

}

void setWaga(){

double nowaWaga;

cout << endl << "Podaj nowa wage dla kota \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> nowaWaga;

this->Zwierze::waga = nowaWaga;

cout << "Waga zwierzecia \"" << this->Zwierze::nazwa

<< "\" zostala zmieniona na " << this->Zwierze::waga

<< "." << endl;

}

/*W tej klasie oraz w kolejnych pięciu klasach zwierząt, które nie są krzyżówkami gatunków, wszystko odbywa się analogicznie do klasy Delfin, dlatego też w poszukiwaniu opisów tej i kolejnych klas odsyłam do komentarzy z klasy poprzedniej.

Cechą szczególną tej klasy jest długość ogona kota.

Numerem identyfikującym gatunek jest liczba 2 przydzielana w metodzie zamienNaNapis(ostream& out).*/

void setUbarwienie(){

char noweUb[100];

cout << endl << "Podaj nowy kolor ubarwienia dla kota \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> noweUb;

this->Zwierze::ubarwienie = new char[strlen(noweUb) + 1];

strcpy(this->Zwierze::ubarwienie, noweUb);

cout << "Ubarwienie zwierzecia \"" << this->Zwierze::nazwa

<< "\" zostalo zmienione na kolor \""

<< this->Zwierze::ubarwienie << "\"." << endl;

}

void setInne(){

int nowaDlOgona;

cout << endl << "Podaj nowa dlugosc ogona dla delfina \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> nowaDlOgona;

dlugoscOgona = nowaDlOgona;

cout << "Dlugosc ogona zwierzecia \""

<< this->Zwierze::nazwa << "\" zostala zmieniona na "

<< dlugoscOgona << "cm." << endl;

}

};

class Bocian : public Zwierze{

public:

int dlugoscDzioba;

Bocian(char*nazwa, int wysokosc, double waga, char* ubarwienie,

int dlugoscDzioba):Zwierze(nazwa,wysokosc,waga,ubarwienie){

this->dlugoscDzioba = dlugoscDzioba;

}

void show(){

cout << "\n***INFORMACJE O BOCIANIE***" << endl << endl

<< " Nazwa: " << this->Zwierze::nazwa << endl

<< " --> wysokosc: "

<< this->Zwierze::wysokosc << "cm" << endl

<< " --> waga: "

<< this->Zwierze::waga << "kg" << endl

<< " --> ubarwienie: "

<< this->Zwierze::ubarwienie << endl

<< " --> dlugosc dzioba: "

<< dlugoscDzioba << "cm" << endl << endl;

}

void zamienNaNapis(ostream& out){

out << endl << 3 << ";"

<< nazwa << ";"

<< wysokosc << ";"

<< waga << ";"

<< ubarwienie << ";"

<< dlugoscDzioba;

}

void setNazwa(){

char noweImie[100];

cout << endl << "Podaj nowe imie dla bociana \""

<< this->Zwierze::nazwa << "\"." << endl;

cin >> noweImie;

this->Zwierze::nazwa = new char[strlen(noweImie) + 1];

strcpy(this->Zwierze::nazwa, noweImie);

cout << endl << "Imie zostalo zmienione na \""

<< this->Zwierze::nazwa << "\"." << endl;

}

void setWysokosc(){

int nowaWys;

cout << endl << "Podaj nowa wysokosc dla bociana \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> nowaWys;

this->Zwierze::wysokosc = nowaWys;

cout << "Wysokosc zwierzecia \"" << this->Zwierze::nazwa

<< "\" zostala zmieniona na "

<< this->Zwierze::wysokosc << "." << endl;

}

void setWaga(){

double nowaWaga;

cout << endl << "Podaj nowa wage dla bociana \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> nowaWaga;

this->Zwierze::waga = nowaWaga;

cout << "Waga zwierzecia \"" << this->Zwierze::nazwa

<< "\" zostala zmieniona na " << this->Zwierze::waga

<< "." << endl;

}

void setUbarwienie(){

char noweUb[100];

cout << "\nPodaj nowy kolor ubarwienia dla bociana \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> noweUb;

this->Zwierze::ubarwienie = new char[strlen(noweUb) + 1];

strcpy(this->Zwierze::ubarwienie, noweUb);

cout << "Ubarwienie zwierzecia \"" << this->Zwierze::nazwa

<< "\" zostalo zmienione na kolor \""

<< this->Zwierze::ubarwienie << "\"." << endl;

}

void setInne(){

int nowaDlDzioba;

cout << endl << "Podaj nowa dlugosc dzioba dla bociana \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> nowaDlDzioba;

dlugoscDzioba = nowaDlDzioba;

cout << "Dlugosc dzioba zwierzecia \""

<< this->Zwierze::nazwa << "\" zostala zmieniona na "

<< dlugoscDzioba << "cm." << endl;

}

};

class Zajac : public Zwierze{

public:

int dlugoscUszu;

Zajac(char* nazwa, int wysokosc, double waga, char* ubarwienie,

int dlugoscUszu):Zwierze(nazwa,wysokosc,waga,ubarwienie){

this->dlugoscUszu = dlugoscUszu;

}

void show(){

cout << endl << "***INFORMACJE O ZAJACU***" << endl << endl

<< " Nazwa: " << this->Zwierze::nazwa << endl

<< " --> wysokosc: "

<< this->Zwierze::wysokosc << "cm" << endl

<< " --> waga: "

<< this->Zwierze::waga << "kg" << endl

<< " --> ubarwienie: "

<< this->Zwierze::ubarwienie << endl

<< " --> dlugosc uszu: " << dlugoscUszu << "cm"

<< endl << endl;

}

void zamienNaNapis(ostream& out){

out << endl << 4 << ";"

<< nazwa << ";"

<< wysokosc << ";"

<< waga << ";"

<< ubarwienie << ";"

<< dlugoscUszu;

}

void setNazwa(){

char noweImie[100];

cout << endl << "Podaj nowe imie dla zajaca \""

<< this->Zwierze::nazwa << "\"." << endl;

cin >> noweImie;

this->Zwierze::nazwa = new char[strlen(noweImie) + 1];

strcpy(this->Zwierze::nazwa, noweImie);

cout << endl << "Imie zostalo zmienione na \""

<< this->Zwierze::nazwa << "\"." << endl;

}

void setWysokosc(){

int nowaWys;

cout << endl << "Podaj nowa wysokosc dla zajaca \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> nowaWys;

this->Zwierze::wysokosc = nowaWys;

cout << "Wysokosc zwierzecia \"" << this->Zwierze::nazwa

<< "\" zostala zmieniona na "

<< this->Zwierze::wysokosc << "." << endl;

}

void setWaga(){

double nowaWaga;

cout << endl << "Podaj nowa wage dla zajaca \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> nowaWaga;

this->Zwierze::waga = nowaWaga;

cout << "Waga zwierzecia \"" << this->Zwierze::nazwa

<< "\" zostala zmieniona na " << this->Zwierze::waga

<< "." << endl;

}

void setUbarwienie(){

char noweUb[100];

cout << endl << "Podaj nowy kolor ubarwienia dla zajaca \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> noweUb;

this->Zwierze::ubarwienie = new char[strlen(noweUb) + 1];

strcpy(this->Zwierze::ubarwienie, noweUb);

cout << "Ubarwienie zwierzecia \"" << this->Zwierze::nazwa

<< "\" zostalo zmienione na kolor \""

<< this->Zwierze::ubarwienie << "\"." << endl;

}

void setInne(){

int nowaDlUszu;

cout << endl << "Podaj nowa dlugosc uszu dla zajaca \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> nowaDlUszu;

dlugoscUszu = nowaDlUszu;

cout << "Dlugosc uszu zwierzecia \""

<< this->Zwierze::nazwa << "\" zostala zmieniona na "

<< dlugoscUszu << "cm." << endl;

}

};

class Ryba : public Zwierze{

public:

int maxZanurzenie;

Ryba(char* nazwa, int wysokosc, double waga, char* ubarwienie,

int maxZanurzenie):Zwierze(nazwa,wysokosc,waga,ubarwienie){

this->maxZanurzenie = maxZanurzenie;

}

void show(){

cout << endl << "***INFORMACJE O RYBIE***" << endl << endl

<< " Nazwa: " << this->Zwierze::nazwa << endl

<< " --> wysokosc: "

<< this->Zwierze::wysokosc << "cm" << endl

<< " --> waga: "

<< this->Zwierze::waga << "kg" << endl

<< " --> ubarwienie: "

<< this->Zwierze::ubarwienie << endl

<< " --> maksymalne zanurzenie: "

<< maxZanurzenie << "m" << endl << endl;

}

void zamienNaNapis(ostream& out){

out << endl << 5 << ";"

<< nazwa << ";"

<< wysokosc << ";"

<< waga << ";"

<< ubarwienie << ";"

<< maxZanurzenie;

}

void setNazwa(){

char noweImie[100];

cout << endl << "Podaj nowe imie dla ryby \""

<< this->Zwierze::nazwa << "\"." << endl;

cin >> noweImie;

this->Zwierze::nazwa = new char[strlen(noweImie) + 1];

strcpy(this->Zwierze::nazwa, noweImie);

cout << endl << "Imie zostalo zmienione na \""

<< this->Zwierze::nazwa << "\"." << endl;

}

void setWysokosc(){

int nowaWys;

cout << endl << "Podaj nowa wysokosc dla ryby \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> nowaWys;

this->Zwierze::wysokosc = nowaWys;

cout << "Wysokosc zwierzecia \"" << this->Zwierze::nazwa

<< "\" zostala zmieniona na "

<< this->Zwierze::wysokosc << "." << endl;

}

void setWaga(){

double nowaWaga;

cout << endl << "Podaj nowa wage dla ryby \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> nowaWaga;

this->Zwierze::waga = nowaWaga;

cout << "Waga zwierzecia \"" << this->Zwierze::nazwa

<< "\" zostala zmieniona na " << this->Zwierze::waga

<< "." << endl;

}

void setUbarwienie(){

char noweUb[100];

cout << endl << "Podaj nowy kolor ubarwienia dla ryby \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> noweUb;

this->Zwierze::ubarwienie = new char[strlen(noweUb) + 1];

strcpy(this->Zwierze::ubarwienie, noweUb);

cout << "Ubarwienie zwierzecia \"" << this->Zwierze::nazwa

<< "\" zostalo zmienione na kolor \""

<< this->Zwierze::ubarwienie << "\"." << endl;

}

void setInne(){

int noweMax;

cout << "\nPodaj nowe maksymalne zanurzenie dla ryby \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> noweMax;

maxZanurzenie = noweMax;

cout << "Maksymalne zanurzenie zwierzecia \""

<< this->Zwierze::nazwa << "\" zostalo zmieniona na "

<< maxZanurzenie << "m." << endl;

}

};

class Slon : public Zwierze{

public:

int glosnosc; //w dB

Slon(char* nazwa, int wysokosc, double waga, char* ubarwienie,

int glosnosc):Zwierze(nazwa, wysokosc, waga, ubarwienie){

this->glosnosc = glosnosc;

}

void show(){

cout << "\n***INFORMACJE O SLONIU***" << endl << endl

<< " Nazwa: " << this->Zwierze::nazwa << endl

<< " --> wysokosc: "

<< this->Zwierze::wysokosc << "cm" << endl

<< " --> waga: "

<< this->Zwierze::waga << "kg" << endl

<< " --> ubarwienie: "

<< this->Zwierze::ubarwienie << endl

<< " --> glosnosc trabienia: " << glosnosc << "dB"

<< endl << endl;

}

void zamienNaNapis(ostream& out){

out << endl << 6 << ";"

<< nazwa << ";"

<< wysokosc << ";"

<< waga << ";"

<< ubarwienie << ";"

<< glosnosc;

}

void setNazwa(){

char noweImie[100];

cout << endl << "Podaj nowe imie dla slonia \""

<< this->Zwierze::nazwa << "\"." << endl;

cin >> noweImie;

this->Zwierze::nazwa = new char[strlen(noweImie) + 1];

strcpy(this->Zwierze::nazwa, noweImie);

cout << endl << "Imie zostalo zmienione na \""

<< this->Zwierze::nazwa << "\"." << endl;

}

void setWysokosc(){

int nowaWys;

cout << endl << "Podaj nowa wysokosc dla slonia \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> nowaWys;

this->Zwierze::wysokosc = nowaWys;

cout << "Wysokosc zwierzecia \"" << this->Zwierze::nazwa

<< "\" zostala zmieniona na "

<< this->Zwierze::wysokosc << "." << endl;

}

void setWaga(){

double nowaWaga;

cout << endl << "Podaj nowa wage dla slonia \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> nowaWaga;

this->Zwierze::waga = nowaWaga;

cout << "Waga zwierzecia \"" << this->Zwierze::nazwa

<< "\" zostala zmieniona na " << this->Zwierze::waga

<< "." << endl;

}

void setUbarwienie(){

char noweUb[100];

cout << "\nPodaj nowy kolor ubarwienia dla slonia \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> noweUb;

this->Zwierze::ubarwienie = new char[strlen(noweUb) + 1];

strcpy(this->Zwierze::ubarwienie, noweUb);

cout << "Ubarwienie zwierzecia \"" << this->Zwierze::nazwa

<< "\" zostalo zmienione na kolor \""

<< this->Zwierze::ubarwienie << "\"." << endl;

}

void setInne(){

int nowaGlosnosc;

cout << "\nPodaj nowa glosnosc trabienia dla slonia \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> nowaGlosnosc;

glosnosc = nowaGlosnosc;

cout << "Glosnosc trabienia zwierzecia \""

<< this->Zwierze::nazwa << "\" zostalo zmieniona na "

<< glosnosc << "dB." << endl;

}

};

class Wielblad : public Zwierze{

public:

int iloscGarbow;

Wielblad(char*nazwa, int wysokosc, double waga, char*ubarwienie,

int iloscGarbow):Zwierze(nazwa, wysokosc, waga, ubarwienie){

this->iloscGarbow = iloscGarbow;

}

void show(){

cout << "\n***INFORMACJE O WIELBLADZIE***" << endl << endl

<< " Nazwa: " << this->Zwierze::nazwa << endl

<< " --> wysokosc: "

<< this->Zwierze::wysokosc << "cm" << endl

<< " --> waga: "

<< this->Zwierze::waga << "kg" << endl

<< " --> ubarwienie: "

<< this->Zwierze::ubarwienie << endl

<< " --> ilosc garbow: "

<< iloscGarbow << endl << endl;

}

void zamienNaNapis(ostream& out){

out << endl << 7 << ";"

<< nazwa << ";"

<< wysokosc << ";"

<< waga << ";"

<< ubarwienie << ";"

<< iloscGarbow;

}

void setNazwa(){

char noweImie[100];

cout << endl << "Podaj nowe imie dla wielblada \""

<< this->Zwierze::nazwa << "\"." << endl;

cin >> noweImie;

this->Zwierze::nazwa = new char[strlen(noweImie) + 1];

strcpy(this->Zwierze::nazwa, noweImie);

cout << endl << "Imie zostalo zmienione na \""

<< this->Zwierze::nazwa << "\"." << endl;

}

void setWysokosc(){

int nowaWys;

cout << endl << "Podaj nowa wysokosc dla wielblada \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> nowaWys;

this->Zwierze::wysokosc = nowaWys;

cout << "Wysokosc zwierzecia \"" << this->Zwierze::nazwa

<< "\" zostala zmieniona na "

<< this->Zwierze::wysokosc << "." << endl;

}

void setWaga(){

double nowaWaga;

cout << endl << "Podaj nowa wage dla wielblada \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> nowaWaga;

this->Zwierze::waga = nowaWaga;

cout << "Waga zwierzecia \"" << this->Zwierze::nazwa

<< "\" zostala zmieniona na " << this->Zwierze::waga

<< "." << endl;

}

void setUbarwienie(){

char noweUb[100];

cout << "\nPodaj nowy kolor ubarwienia dla wielblada \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> noweUb;

this->Zwierze::ubarwienie = new char[strlen(noweUb) + 1];

strcpy(this->Zwierze::ubarwienie, noweUb);

cout << "Ubarwienie zwierzecia \"" << this->Zwierze::nazwa

<< "\" zostalo zmienione na kolor \""

<< this->Zwierze::ubarwienie << "\"." << endl;

}

void setInne(){

int nowaIloscG;

cout << "\nPodaj nowa glosnosc trabienia dla wielblada \""

<< this->Zwierze::nazwa << "\":" << endl;

cin >> nowaIloscG;

iloscGarbow = nowaIloscG;

cout << "Ilosc garbow zwierzecia \""

<< this->Zwierze::nazwa << "\" zostalo zmieniona na "

<< iloscGarbow << "." << endl;

}

};

class KotoBocian : public Kot, public Bocian{

protected:

char* nazwa;

public:

KotoBocian(char* nazwa, int wysokosc, double waga,

char* kUbarwienie, char* bUbarwienie,

int dlugoscOgona, int dlugoscDzioba):

Kot(nazwa, wysokosc, waga, kUbarwienie, dlugoscOgona),

Bocian(nazwa,wysokosc,waga,bUbarwienie,dlugoscDzioba){

this->nazwa = new char[strlen(nazwa) + 1];

strcpy(this->nazwa, nazwa);

}

KotoBocian(Kot& k, Bocian& b, char* nazwa):

Kot(k.nazwa,k.wysokosc,k.waga,k.ubarwienie,

k.dlugoscOgona), Bocian(b.nazwa, b.wysokosc, b.waga,

b.ubarwienie, b.dlugoscDzioba){

this->nazwa = new char[strlen(nazwa) + 1];

strcpy(this->nazwa, nazwa);

}

void show(){

cout << "\n***INFORMACJE O KOTO-BOCIANIE***\n" << endl

<< " Nazwa: " << nazwa << endl

<< " --> wysokosc: "

<< (this->Kot::wysokosc+this->Bocian::wysokosc)/2

<< "cm" << endl

<< " --> waga: "

<< (this->Kot::waga + this->Bocian::waga)/2 << "kg\n"

<< " --> ubarwienie: "

<< this->Kot::ubarwienie << "-"

<< this->Bocian::ubarwienie << endl

<< " --> dlugosc ogona: "

<< this->Kot::dlugoscOgona << "cm" << endl

<< " --> dlugosc dzioba: "

<< this->Bocian::dlugoscDzioba << "cm\n" << endl;

}

void zamienNaNapis(ostream& out){

out << endl << 8 << ";"

<< nazwa << ";"

<< (this->Kot::wysokosc + this->Bocian::wysokosc)/2

<< ";" << (this->Kot::waga + this->Bocian::waga)/2

<< ";" << this->Kot::ubarwienie << "-"

<< this->Bocian::ubarwienie << ";"

<< dlugoscOgona << ";"

<< dlugoscDzioba;

}

void setNazwa(){

char noweImie[100];

cout << endl << "Podaj nowe imie dla koto-bociana \""

<< nazwa << "\"." << endl;

cin >> noweImie;

this->Kot::nazwa = new char[strlen(noweImie) + 1];

strcpy(Kot::nazwa, noweImie);

this->Bocian::nazwa= new char[strlen(noweImie) + 1];

strcpy(Bocian::nazwa, noweImie);

nazwa = noweImie;

cout << endl << "Imie zostalo zmienione na \""

<< nazwa << "\"." << endl;

}

/*Klasa KotoBocian jest pierwszą z klas, w której na skutek eksperymentów medycznych powstają tzw. krzyżówki zwierząt.

Klasa ta dziedziczy z klas zwierząt normalnych (kota i bociana) i zgodnie z prawem wielodziedziczenia, pośrednio z klasy Zwierze.

W każdej z tych trzech klas są po dwa konstruktory, z któruch jeden daje możliwość krzyżowania mieszkających już w Zoo zwierząt, a drugi tworzenia zupełnie nowego obirktu podając wszystkie parametry po kolei.

W ten sposób mamy możliwość stworzenia KotoBociana, przez podanie referencji do obiektów istniejących.

Podobnie jak klasy prostych zwierząt, klasa ta ma funkcję show(), która musi byś zdefiniowana, ponieważ jest ona wirtualną metodą w klasie Zwierze, a KotoBocian dziedziczy ze Zwierza, choć nie bezpośrednio.

W krzyżówkach wysokość oraz waga są wyliczane jako średnia odu zwierząt z których powstały. Ubarwienie zaś, jest mieszanką dwuczłonową nazwą koloru (np. srebrno-złoty).

Zmiana poszczególnych parametrów odbywa się analogicznie do metod z klas zwierząt prostych, jednakże zmiany przepisywane są do obu podgatunków krzyżówki. */

void setWysokosc(){

int nowaWys;

cout << endl << "Podaj nowa wysokosc dla koto-bociana \""

<< nazwa << "\":" << endl;

cin >> nowaWys;

this->Kot::wysokosc = nowaWys;

this->Bocian::wysokosc = nowaWys;

cout << "Wysokosc zwierzecia \"" << nazwa

<<"\" zostala zmieniona na "

<< (this->Kot::wysokosc+this->Bocian::wysokosc)/2

<< "." << endl;

}

void setWaga(){

double nowaWaga;

cout << endl << "Podaj nowa wage dla koto-bociana \""

<< nazwa << "\":" << endl;

cin >> nowaWaga;

this->Bocian::waga = nowaWaga;

this->Kot::waga = nowaWaga;

cout << "Waga zwierzecia \"" << nazwa

<< "\" zostala zmieniona na "

<< (this->Kot::waga + this->Bocian::waga)/2

<< "." << endl;

}

void setUbarwienie(){

char noweUb[100];

cout << "\nPodaj nowy kolor ubarwienia dla koto-bociana \""

<< nazwa << "\":" << endl;

cin >> noweUb;

this->Kot::ubarwienie = new char[strlen(noweUb) + 1];

strcpy(Kot::ubarwienie, noweUb);

this->Bocian::ubarwienie = new char[strlen(noweUb) + 1];

strcpy(Bocian::ubarwienie, noweUb);

cout << "Ubarwienie zwierzecia \"" << nazwa

<< "\" zostalo zmienione na kolor \""

<< this->Kot::ubarwienie <<"-"

<< this->Bocian::ubarwienie << "\"." << endl;

}

void setInne(){

int nowaDlOgona;

int nowaDlDzioba;

cout << "\nPodaj nowa dlugosc ogna i "

<< "dzioba dla koto-bociana \""

<< nazwa << "\":" << endl;

cin >> nowaDlOgona >> nowaDlDzioba;

this->Bocian::dlugoscDzioba = nowaDlDzioba;

this->Kot::dlugoscOgona = nowaDlOgona;

cout << "Dlugosc ogona i dzioba zwierzecia \"" << nazwa

<< "\" zostaly zmieniona na " << dlugoscOgona

<< "cm i " << dlugoscDzioba << "cm." << endl;

}

~KotoBocian(){

delete[] nazwa;

}

};

/*Przy zmianie parametrów w śród cech charakterystycznych wymagane jest podanie obydwu cech, które zostały odziedziczone po rodzicach, czyli gatunkach macierzystych. W przypadku KotoBociana będzie to długość dzioba oraz długość ogona.

Destruktor pola char* nazwa. Destruktor wykorzystywany jest w klasie ListaZwierzat w metodzie remove(), która służy do usuwania zwierząt z Zoo.*/

class SlonioRyba : public Slon, public Ryba{

protected:

char* nazwa;

public:

SlonioRyba(char* nazwa, int wysokosc, double waga,

char* sUbarwienie, char* rUbarwienie,

int glosnosc, int maxZanurzenie):

Slon(nazwa, wysokosc, waga, sUbarwienie, glosnosc),

Ryba(nazwa, wysokosc, waga, rUbarwienie, maxZanurzenie){

this->nazwa = new char[strlen(nazwa) + 1];

strcpy(this->nazwa, nazwa);

}

SlonioRyba(Slon& s, Ryba& r, char* nazwa):

Slon(s.nazwa,s.wysokosc,s.waga,s.ubarwienie,s.glosnosc),

Ryba(r.nazwa,r.wysokosc,r.waga,r.ubarwienie,r.maxZanurzenie){

this->nazwa = new char[strlen(nazwa) + 1];

strcpy(this->nazwa, nazwa);

}

void show(){

cout << "\n***INFORMACJE O SLONIO-RYBIE***\n" << endl

<< " Nazwa: " << nazwa << endl

<< " --> wysokosc: "

<< (this->Slon::wysokosc+this->Ryba::wysokosc)/2

<< "cm" << endl

<< " --> waga: "

<< (this->Slon::waga + this->Ryba::waga)/2 << "kg\n"

<< " --> ubarwienie: "

<< this->Slon::ubarwienie << "-"

<< this->Ryba::ubarwienie << endl

<< " --> glosnosc trabienia: "

<< this->Slon::glosnosc << "bD" << endl

<< " --> maksymalne zanurzenie: "

<< this->Ryba::maxZanurzenie<< "m" << endl << endl;

}

void zamienNaNapis(ostream& out){

out << endl << 9 << ";"

<< nazwa << ";"

<< (this->Slon::wysokosc+this->Ryba::wysokosc)/2 << ";"

<< (this->Slon::waga + this->Ryba::waga)/2 << ";"

<< this->Slon::ubarwienie <<"-"

<< this->Ryba::ubarwienie << ";"

<< glosnosc << ";"

<< maxZanurzenie;

}

void setNazwa(){

char noweImie[100];

cout << endl << "Podaj nowe imie dla slonio-ryby \""

<< nazwa << "\"." << endl;

cin >> noweImie;

Slon::nazwa = new char[strlen(noweImie) + 1];

strcpy(Slon::nazwa, noweImie);

Ryba::nazwa = new char[strlen(noweImie) + 1];

strcpy(Ryba::nazwa, noweImie);

nazwa = noweImie;

cout << endl << "Imie zostalo zmienione na \""

<< nazwa << "\"." << endl;

}

/*W klasie SlonioRyba wszystkie jej składowe zdefiniowane są analogicznie do klasy KotoBocian.

numerem identyfikującym ten gatunek jest kod 9.*/

void setWysokosc(){

int nowaWys;

cout << endl << "Podaj nowa wysokosc dla slonio-ryby \""

<< nazwa << "\":" << endl;

cin >> nowaWys;

this->Slon::wysokosc = nowaWys;

this->Ryba::wysokosc = nowaWys;

cout << "Wysokosc zwierzecia \"" << nazwa

<< "\" zostala zmieniona na "

<< (this->Slon::wysokosc+this->Ryba::wysokosc)/2

<< "." << endl;

}

void setWaga(){

double nowaWaga;

cout << endl << "Podaj nowa wage dla slonio-ryby \""

<< nazwa << "\":" << endl;

cin >> nowaWaga;

this->Slon::waga = nowaWaga;

this->Ryba::waga = nowaWaga;

cout << "Waga zwierzecia \"" << nazwa

<< "\" zostala zmieniona na "

<< (this->Slon::waga + this->Ryba::waga)/2

<< "kg." << endl;

}

void setUbarwienie(){

char noweUb[100];

cout << "\nPodaj nowy kolor ubarwienia dla slonio-ryby \""

<< nazwa << "\":" << endl;

cin >> noweUb;

this->Slon::ubarwienie = new char[strlen(noweUb) + 1];

strcpy(this->Slon::ubarwienie, noweUb);

this->Ryba::ubarwienie = new char[strlen(noweUb) + 1];

strcpy(this->Ryba::ubarwienie, noweUb);

cout << "Ubarwienie zwierzecia \"" << nazwa

<< "\" zostalo zmienione na kolor \""

<< this->Slon::ubarwienie << "-"

<< this->Ryba::ubarwienie << "\"." << endl;

}

void setInne(){

int nowaGlosnosc;

int noweMaxZanurzenie;

cout << "\nPodaj nowa glosnosc i maksymalne zanurzenie"

<< " dla slonio-ryby \"" << nazwa << "\":" << endl;

cin >> nowaGlosnosc >> noweMaxZanurzenie;

this->Slon::glosnosc = nowaGlosnosc;

this->Ryba::maxZanurzenie = noweMaxZanurzenie;

cout << "Glosnosc i maksymalne zanurzenie zwierzecia \""

<< nazwa << "\" zostaly zmieniona na " << glosnosc

<< "dB i " << maxZanurzenie << "m." << endl;

}

~SlonioRyba(){

delete[] nazwa;

}

};

class DelfinoZajac : public Delfin, public Zajac{

protected:

char* nazwa;

public:

DelfinoZajac(char* nazwa, int wysokosc, double waga,

char* dUbarwienie, char* zUbarwienie,

int IQ, int dlugoscUszu): Delfin(nazwa,

wysokosc, waga, dUbarwienie, IQ), Zajac(nazwa,

wysokosc, waga, zUbarwienie, dlugoscUszu){

this->nazwa = new char[strlen(nazwa) + 1];

strcpy(this->nazwa, nazwa);

}

DelfinoZajac(Delfin& d, Zajac& z, char* nazwa):

Delfin(d.nazwa, d.wysokosc, d.waga, d.ubarwienie, d.IQ),

Zajac(z.nazwa,z.wysokosc,z.waga,z.ubarwienie,z.dlugoscUszu){

this->nazwa = new char[strlen(nazwa) + 1];

strcpy(this->nazwa, nazwa);

}

void show(){

cout << "\n***INFORMACJE O DELFINO-ZAJACU***\n" << endl

<< " Nazwa: " << nazwa << endl

<< " --> wysokosc: "

<< (this->Delfin::wysokosc+this->Zajac::wysokosc)/2

<< "cm" << endl

<< " --> waga: "

<< (this->Delfin::waga + this->Zajac::waga)/2

<< "kg" << endl

<< " --> ubarwienie: "

<< this->Delfin::ubarwienie << "-"

<< this->Zajac::ubarwienie << endl

<< " --> iloraz inteligencji: "

<< this->Delfin::IQ << " IQ " << endl

<< " --> dlugosc uszu: "

<< this->Zajac::dlugoscUszu<< "cm" << endl << endl;

}

void zamienNaNapis(ostream& out){

out << endl << 10 << ";"

<< nazwa << ";"

<< (this->Delfin::wysokosc + this->Zajac::wysokosc)/2

<< ";" << (this->Delfin::waga + this->Zajac::waga)/2

<< ";" << this->Delfin::ubarwienie << "-"

<< this->Zajac::ubarwienie << ";"

<< IQ << ";"

<< dlugoscUszu;

}

void setNazwa(){

char noweImie[100];

cout << endl << "Podaj nowe imie dla delfino-zajaca \""

<< nazwa << "\"." << endl;

cin >> noweImie;

Delfin::nazwa = new char[strlen(noweImie) + 1];

strcpy(Delfin::nazwa, noweImie);

Zajac::nazwa = new char[strlen(noweImie) + 1];

strcpy(Zajac::nazwa, noweImie);

nazwa = noweImie;

cout << endl << "Imie zostalo zmienione na \""

<< nazwa << "\"." << endl;

}

void setWysokosc(){

int nowaWys;

cout << "\nPodaj nowa wysokosc dla delfino-zajaca \""

<< nazwa << "\":" << endl;

cin >> nowaWys;

this->Delfin::wysokosc = nowaWys;

this->Zajac::wysokosc = nowaWys;

cout << "Wysokosc zwierzecia \"" << nazwa

<< "\" zostala zmieniona na "

<< (this->Delfin::wysokosc + this->Zajac::wysokosc)/2

<< "cm." << endl;

}

void setWaga(){

double nowaWaga;

cout << endl << "Podaj nowa wage dla delfino-zajaca \""

<< nazwa << "\":" << endl;

cin >> nowaWaga;

this->Delfin::waga = nowaWaga;

this->Zajac::waga = nowaWaga;

cout << "Waga zwierzecia \"" << nazwa

<< "\" zostala zmieniona na "

<< (this->Delfin::waga + this->Zajac::waga)/2

<< "." << endl;

}

void setUbarwienie(){

char noweUb[100];

cout << endl << "Podaj nowy kolor ubarwienia "

<< "dla delfino-zajaca \"" << nazwa << "\":" << endl;

cin >> noweUb;

this->Delfin::ubarwienie = new char[strlen(noweUb) + 1];

strcpy(this->Delfin::ubarwienie, noweUb);

this->Zajac::ubarwienie = new char[strlen(noweUb) + 1];

strcpy(this->Zajac::ubarwienie, noweUb);

cout << "Ubarwienie zwierzecia \"" << nazwa

<< "\" zostalo zmienione na kolor \""

<< this->Delfin::ubarwienie << "-"

<< this->Zajac::ubarwienie

<< "\"." << endl;

}

void setInne(){

int noweIQ;

int nowaDlUszu;

cout << endl << "Podaj nowe IQ i nowa dlugosc uszu "

<< "dla delfino-zajaca \"" << nazwa << "\":" << endl;

cin >> noweIQ >> nowaDlUszu;

Delfin::IQ = noweIQ;

Zajac::dlugoscUszu = nowaDlUszu;

cout << "IQ i dlugosc uszu zwierzecia \"" << nazwa

<< "\" zostaly zmieniona na " << IQ << " IQ "

<< "i " << dlugoscUszu << "cm." << endl;

}

~DelfinoZajac(){

delete[] nazwa;

}

};

class ListaZwierzat : public BazaDanych{

private:

Node* head;

int licznik;

public:

ListaZwierzat(){

head = NULL;

licznik = 0;

}

void save(){

ofstream out("dane.txt");

if(!out) cout << "Error!!!" << endl;

for(int i = 0 ; i < licznik; i++){

Zwierze* z = pobierz(i);

z->zamienNaNapis(out);

}

out.close();

}

/*ListaZwierzat to klasa dziedzicząca z abstrakcyjnej BazyDanych, której wirtualne funktcje muszą być zdefiniowane tutaj. Są to metoda save() i load().

Prywatną składową jest między innymi zmienna typu wskaźnikowego klasy Node.

W konstruktorze zmienna head, która wskazywać ma pierwszy element każdej listy. Na początku, kiedy lista jest tylko tworzona jest jeszcze pusta, dlatego licznik, który zlicza ilość zwierząt, ma wartość 0.

W metodzie save() otwierany jest strumień wyjściowy, którym jest plik tekstowy dane.txt. W przypadku wystąpienia błędu, czyli nieudanej próbie otwarcia strumienia, wyswietlany jest komunikat o błądzie. Jeśli wszystko jest w porządku, to w pętli, która wykonuje się tyle razy, ile wskazuje licznik, czyli tyle razy ile jest zwierząt na liście, wywoływane jest po kolei każde zwierzę i na rzecz kazdego z nich wywoływana jest metoda zamienNaNapis(...). Parametrem tej funkcji jest utworzony wcześniej strumień wyjściowy out. Na koniec, kiedy wszystkie zwierzęta wysłane są już do pliku i w nim zapisane, strumień jest zamykany.

W funkcji load() otwierany jest z kolei strumień wejściowy in. Odczytuje on zawartość pliku, w którym wcześniej zostały zapisane informacje o stanie zoo (zawartość bazy danych).

W pętli while, która wykonuje się aż do momentu, kiedy istnieje strumień wejściowy, odczytywane są po kolei wszystkie dane. Najpierw kod gatunku, po którym ignorowany jest jeden znak, ponieważ wszystkie informacje odseparowane są znakiem ;.

Później, za pomocą trzyparametrowej funkcji getline(), pobierana jest nazwa. Pierwszy parametrem jest nazwa zmiennej, do której ma być zapisana informacja, następnym ilość znaków, a na końcu określony jest symbol, na którym ma być zakończone odczytywanie jeśli nazwa jest krótsza niż sto znaków.

Później w zależności od kodu zwierzęcia wczytywane są pozostałe dane. Barwa wczytywana jest także w zależności od gatunku zwierzęcia, ponieważ barwy krzyżówek są dwuczłonowe.

Na koniec dodawane są zwierzęta do listy, za pomocą funkcji add(...), której parametrem jest konstruktor danego zwierzęcia. */

void load(){

ifstream in("dane.txt");

if(!in) cout << "Nie znaleziono pliku!" << endl;

while(in){

//ID gatunku

int kod;

in >> kod;

in.ignore(1);

char nazwa[100];

in.getline(nazwa, 100, ';');

int wys;

in >> wys;

in.ignore(1);

double waga;

in >> waga;

in.ignore(1);

char barwa[100];

//rozpoznanie zwierzecia

switch(kod){

case 1:

//ubarwienie

in.getline(barwa, 100, ';');

//cecha szczególna

int IQ;

in >> IQ;

add(new Delfin(nazwa, wys, waga, barwa, IQ));

break;

case 2:

//ubarwienie

in.getline(barwa, 100, ';');

//cecha szczególna

int dlugoscOgona;

in >> dlugoscOgona;

add(new Kot(nazwa,wys,waga,barwa,dlugoscOgona));

break;

case 3:

in.getline(barwa, 100, ';');

int dlugoscDzioba;

in >> dlugoscDzioba;

add(new Bocian(nazwa, wys, waga,

barwa,dlugoscDzioba));

break;

case 4:

in.getline(barwa, 100, ';');

int dlugoscUszu;

in >> dlugoscUszu;

add(new Zajac(nazwa,wys,waga,barwa,dlugoscUszu));

break;

case 5:

in.getline(barwa, 100, ';');

int maxZanurzenie;

in >> maxZanurzenie;

add(new Ryba(nazwa,wys,waga,barwa,maxZanurzenie));

break;

case 6:

in.getline(barwa, 100, ';');

int glosnosc;

in >> glosnosc;

add(new Slon(nazwa, wys, waga, barwa, glosnosc));

break;

case 7:

in.getline(barwa, 100, ';');

int iloscGarbow;

in >> iloscGarbow;

add(new Wielblad(nazwa, wys, waga,

barwa,iloscGarbow));

break;

case 8:

char barwaKota[100];

in.getline(barwaKota, 100, '-');

char barwaBociana[100];

in.getline(barwaBociana, 100, ';');

int ogon;

in >> ogon;

in.ignore(1);

int dziob;

in >> dziob;

add((Bocian*)(new KotoBocian(

*(new Kot(nazwa, wys, waga, barwaKota, ogon)),

*(new Bocian(nazwa, wys, waga,

barwaBociana, dziob)),

nazwa)));

break;

/*Ponieważ KotoBocian dziedziczy z dwóch klas, kota i bociana, a lista dodaje obiekty typu zwierze* należy dokonać zawężenia referencji do jednego typu, kota lub bociana. Pozostałe mieszanki gatunków dodawane są w analogiczny sposób.*/

case 9:

char barwaSlonia[100];

in.getline(barwaSlonia, 100, '-');

char barwaRyby[100];

in.getline(barwaRyby, 100, ';');

int glosn;

in >> glosn;

in.ignore(1);

int maxZan;

in >> maxZan;

add((Slon*)(new SlonioRyba(

*(new Slon(nazwa, wys, waga, barwaSlonia, glosn)), *(new Ryba(nazwa,wys,waga,barwaRyby,maxZan)), nazwa)));

break;

case 10:

char barwaDelfina[100];

in.getline(barwaDelfina, 100, '-');

char barwaZajaca[100];

in.getline(barwaZajaca, 100, ';');

int iq;

in >> iq;

in.ignore(1);

int dlUszu;

in >> dlUszu;

add((Delfin*)(new DelfinoZajac(

*(new Delfin(nazwa,wys,waga,barwaDelfina,iq)),

*(new Zajac(nazwa,wys,waga,barwaZajaca,dlUszu)),

nazwa)));

break;

}

in.ignore(1000, '\n');

}

Zwierze* pobierz(int index){

Node* temp = head;

for(int i = 0;i < index; i++){

if(temp == NULL){

return 0;

}

temp = temp->next;

}

if(temp == NULL){

return 0;

}

return temp->zwierz;

}

void add(Zwierze* noweZwierze){

if(head == NULL){

head = new Node(noweZwierze);

}else{

Node* temp = head;

while(temp->next != NULL){

temp = temp->next;

}

temp->next = new Node(noweZwierze);

}

licznik++;

}

/*Metoda pobierz(int index) zwraca adres zwierzącia.

Metoda add(Zwierze* noweZwierze) dodaje na koniec listy nowe zwierzę. Jeżeli head ma wartość NULL, jej wartość zostaje zmienaina na nowe zwierze za pomocą wywołania konstruktora Node(...). W przeciwnym wypadku element next, który jest zawsze pusty, zostaje zapisany przez nowe zwierzę. Pętla while przelatuje najpierw do ostatniego elementu listy. Licznik wzrasta o jeden.*/

void remove(int index){

if(head == NULL) return;

//usuwanie pierwszsego elemtnu

if(index == 0){

Node* oldHead = head;

head = head->next;

delete oldHead;

licznik--;

return;

}

Node* temp = head->next;

Node* previous = head;

for(int i = 1;i < index; i++){

if(temp == NULL)

return;

previous = temp;

temp = temp->next;

}

if(temp == NULL) return;

previous->next = temp->next;

delete temp;

licznik--;

}

int getLicznik(){ return licznik; }

Zwierze* getZwierze(int index){

Node* temp = head;

if(temp == NULL){

cout << "Lista jest pusta!" << endl;

return 0;

}

for(int i = 0;i < index; i++){

if(temp == NULL){

cout << "Wyszedles poza liste!" << endl;

return 0;

}

temp = temp->next;

}

if(temp == NULL){

cout << "Wyszedles poza liste!" << endl;

return 0;

}

temp->zwierz;

temp->show();

return 0;

}

Zwierze* setNazwa(int index){

Node* temp = head;

if(temp == NULL){

cout << "Lista jest pusta!" << endl;

return 0;

}

for(int i = 0;i < index; i++){

if(temp == NULL){

cout << "Wyszedles poza liste!" << endl;

return 0;

}

temp = temp->next;

}

if(temp == NULL){

cout << "Wyszedles poza liste!" << endl;

return 0;

}

temp->zwierz;

temp->setNazwa();

return 0;

}

/*Metoda remove usuwa element z listy o podanym indeksie. Zwierzęta, których indeksy są większe od podanego jako parametr, przesuwane są o jeden do tyłu, a licznik maleje o jeden.

getLicznik() zwraca aktualny stan licznika.

getZwierze() wywołuje metodę show() ze zwierzęcia o podanym indeksie na liście.

Podobnie jest z kolejnymi metodami, które zmieniają poszczególne parametry zwierząt.*/

Zwierze* setWysokosc(int index){

Node* temp = head;

if(temp == NULL){

cout << "Lista jest pusta!" << endl;

return 0;

}

for(int i = 0;i < index; i++){

if(temp == NULL){

cout << "Wyszedles poza liste!" << endl;

return 0;

}

temp = temp->next;

}

if(temp == NULL){

cout << "Wyszedles poza liste!" << endl;

return 0;

}

temp->zwierz;

temp->setWysokosc();

return 0;

}

Zwierze* setWaga(int index){

Node* temp = head;

if(temp == NULL){

cout << "Lista jest pusta!" << endl;

return 0;

}

for(int i = 0;i < index; i++){

if(temp == NULL){

cout << "Wyszedles poza liste!" << endl;

return 0;

}

temp = temp->next;

}

if(temp == NULL){

cout << "Wyszedles poza liste!" << endl;

return 0;

}

temp->zwierz;

temp->setWaga();

return 0;

}

Zwierze* setUbarwienie(int index){

Node* temp = head;

if(temp == NULL){

cout << "Lista jest pusta!" << endl;

return 0;

}

for(int i = 0;i < index; i++){

if(temp == NULL){

cout << "Wyszedles poza liste!" << endl;

return 0;

}

temp = temp->next;

}

if(temp == NULL){

cout << "Wyszedles poza liste!" << endl;

return 0;

}

temp->zwierz;

temp->setUbarwienie();

return 0;

}

Zwierze* setInne(int index){

Node* temp = head;

if(temp == NULL){

cout << "Lista jest pusta!" << endl;

return 0;

}

for(int i = 0;i < index; i++){

if(temp == NULL){

cout << "Wyszedles poza liste!" << endl;

return 0;

}

temp = temp->next;

}

if(temp == NULL){

cout << "Wyszedles poza liste!" << endl;

return 0;

}

temp->zwierz;

temp->setInne();

return 0;

}

void show(){

cout << endl << endl << " ------------------" << endl

<< " Zawartosc ZOO: " << endl

<< " ------------------" << endl

<< endl;

Node* temp = head;

while(temp != NULL){

temp->show();

temp = temp->next;

}

void sort(char typ){

//tablica tymczasowa

Zwierze** zwierzaki = new Zwierze*[getLicznik()];

for(int z = 0; z < getLicznik(); z++){

zwierzaki[z] = pobierz(z);

}

int minindex;

//sortowanie

switch(typ){

case 'A':

for(int i = 0; i < this->getLicznik(); i++){

minindex = i;

for(int j = i; j < this->getLicznik(); j++){

if(strcmp(zwierzaki[i]->nazwa,zwierzaki[j]->nazwa)>0){

minindex = j;

//zamiana

Zwierze* temp = zwierzaki[minindex];

zwierzaki[minindex] = zwierzaki[i];

zwierzaki[i] = temp;

}

break;

case 'B':

for(int i = 0; i < this->getLicznik(); i++){

minindex = i;

for(int j = i; j < this->getLicznik(); j++){

if(zwierzaki[i]->wysokosc > zwierzaki[j]->wysokosc){

minindex = j; //zamiana

Zwierze* temp = zwierzaki[minindex];

zwierzaki[minindex] = zwierzaki[i];

zwierzaki[i] = temp;

}

break;

/*Metoda show() wyświetla zawartość całego zoo.

Metoda sort(char typ) sortuje listę według wskazanego pola.

Do tablicy zwierzaki wprowadzane są adresy wszystkich zwierząt.

Rozpoczyna się sortowanie, w zalerzności od podanego typu, po nazwach i ubarwieniu (alfabetycznie) oraz (rosnąco) po wartościach pól waga i wysokosc.

Strcmp porównuje dwie wartości typu char. Wyrażenie to zwraca wynik większy od zera, gdy pierwsza wartość jest większa. Jeśli tak jest, dokonuje się zamiana kolejności poszczególnych elementów, sortując je.

Przy porównywaniu wysokości i wagi nie używamy strcmp, lecz zwykłago znaku porównania.*/

case 'C':

for(int i = 0; i < this->getLicznik(); i++){

minindex = i;

for(int j = i; j < this->getLicznik(); j++){

if(zwierzaki[i]->waga > zwierzaki[j]->waga){

minindex = j; //zamiana

Zwierze* temp = zwierzaki[minindex];

zwierzaki[minindex] = zwierzaki[i];

zwierzaki[i] = temp;

}

break;

case 'D':

for(int i = 0; i < this->getLicznik(); i++){

minindex = i;

for(int j = i; j < this->getLicznik(); j++){

if(strcmp(zwierzaki[i]->ubarwienie,

zwierzaki[j]->ubarwienie)>0){

minindex = j;

//zamiana

Zwierze* temp = zwierzaki[minindex];

zwierzaki[minindex] = zwierzaki[i];

zwierzaki[i] = temp;

}

break;

}

//wyswietlenie listy:

for(int zz = 0; zz < getLicznik(); zz++){

zwierzaki[zz]->show();

}

};

//stworzenie listy dla zwierząt:

ListaZwierzat lista;

int showMenu(){

//menu:

system("cls");

cout << "\n\n >>> M E N U <<< \n" << endl;

cout << "1: Pokaz zawartosc calego ZOO" << endl;

cout << "2: Pokaz wszystko o zwierzeciu..." << endl;

cout << "3: Zmien parametry zwierzecia..." << endl;

cout << "4: Wyswietl posortowana liste zwierzat..." << endl;

cout << "5: Wprowadz nowe zwierze..." << endl;

cout << "6: Usun zwierze..." << endl;

cout << "7: Odczytaj baze danych" << endl;

cout << "8: Zachowaj baze danych" << endl;

cout << "9: SAVE & EXIT" << endl;

cout << "10: EXIT\n" << endl;

int wybor;

cout << "Wybieram opcje: ";

cin >> wybor;

if(!cin){

cout << "ERROR!!! --> Nieprawidlowa liczba" << endl;

cin.clear();

cin.ignore(1000, '\n');

system("pause");

return 1; //Powrót do menu głównego

}

/*W showMenu() wyświetlane jest menu. W funkcji main odwołanie do niego jest zapętlone aż do momentu, w którym nie zostanie zwrócona wartość 0.

Wybierać można z menu różne funkcje, podając liczby.

W przypadku podania znaku zamiast liczby wyświetla się komunikat o błędzie.*/

if (wybor < 1 || wybor > 10){

//Powrót do menu głównego

return 1;

}

switch(wybor){

case 1: //Zawartość całego zoo:

lista.show();

break;

case 2: //Info o zwierzęciu:

system("cls");

int z;

cout << "\nPadaj numer zwierzecia, na temat ktorego "

<< "chcesz uzyskac informacje: ";

cin >> z;

if (z<0){

//Powrót do menu głównego

return 1;

}

lista.getZwierze(z);

break;

case 3: //Zmiana parametrów:

system("cls");

cout << "\nJaki parametr zamierzasz zmienic?:" << endl;

cout << "A: nazwe " << endl;

cout << "B: wysokosc " << endl;

cout << "C: wage " << endl;

cout << "D: ubarwienie " << endl;

cout << "E: ceche szczegolna " << endl;

cout << "F: powrot do menu glownego " << endl;

cout << "G: SAVE && EXIT\n" << endl;

char x;

cout << "Wybieram opcje: ";

cin >> x;

if (x!='A' && x!='B' && x!='C' && x!='D' && x!='E' && x!='F' || x =='G'){

//Powrót do menu głównego

return 1;

}

int y;

if (x != 'F'){

cout << "\nPadaj numer zwierzecia, ktorego "

<< "parametr chcesz zmienic: ";

cin >> y;

}

switch(x){

case 'A':

lista.setNazwa(y);

break;

case 'B':

lista.setWysokosc(y);

break;

case 'C':

lista.setWaga(y);

break;

case 'D':

lista.setUbarwienie(y);

break;

case 'E':

lista.setInne(y);

break;

case 'F':

break;

}

break;

/*Jeśli użytkownik wybierze liczbę spoza menu, następuje powrót do menu.

Wybór pierwszej opcji wywołuję metodę show() na rzecz listy.

Delej wykonują się funkcje w zalerzności od życzeń użytkownika.*/

case 4: //Sortowanie:

system("cls");

cout << "\nSortuj wedlug:" << endl;

cout << "A: nazwy (alfabetycznie)" << endl;

cout << "B: wysokosci (rosnaco)" << endl;

cout << "C: wagi (rosnaco)" << endl;

cout << "D: ubarwienia (alfabetycznie)" << endl;

cout << "E: powrot do menu glownego " << endl;

cout << "F: SAVE && EXIT\n" << endl;

char s;

cout << "Wybieram opcje: ";

cin >> s;

if (s!='A' && s!='B' && s!='C' && s!='D' && s!='E' || s=='F'){

//Powrót do menu głównego

return 1;

}

switch(s){

case 'A':

//Nazwa

lista.sort('A');

break;

case 'B':

//Wysokosc

lista.sort('B');

break;

case 'C':

//Waga

lista.sort('C');

break;

case 'D':

//Ubarwienie

lista.sort('D');

break;

case 'E':

break;

}

break;

case 5: //Nowy obiekt:

system("cls");

cout << "\nWybierz gatynek zwierzecia do wprowadzenia:" << endl;

cout << "A: delfin" << endl;

cout << "B: bocian" << endl;

cout << "C: kot" << endl;

cout << "D: ryba" << endl;

cout << "E: slon" << endl;

cout << "F: wielblad" << endl;

cout << "G: zajac" << endl;

cout << "H: koto-bocian" << endl;

cout << "I: slonio-ryba" << endl;

cout << "J: delfino-zajac" << endl;

cout << "K: powrot do menu glownego " << endl;

cout << "L: SAVE && EXIT\n" << endl;

char g;

cout << "Wybieram opcje: ";

cin >> g;

if (g!='A' && g!='B' && g!='C' && g!='D' && g!='E' && g!='F' && g!='G' && g!='H' && g!='I' && g!='J' && g!='K' || g=='L'){

//Powrót do menu głównego

return 1;

}

char nazwa[100];

int wysokosc;

double waga;

char ubarwienie[100];

char ubarwienie2[100];

int cecha;

int cecha2;

switch(g){

case 'A':

cout << "Podaj nazwe (imie) dla nowego delfina: ";

cin >> nazwa;

cout << "\nwysokosc (cm): ";

cin >> wysokosc;

cout << "\nwage (kg): ";

cin >> waga;

cout << "\nubarwienie: ";

cin >> ubarwienie;

cout << "\niloraz inteligencji (IQ): ";

cin >> cecha;

lista.add(new Delfin(nazwa, wysokosc, waga, ubarwienie, cecha));

cout << "\nZwierze zostalo dodane!" << endl;

lista.getZwierze(lista.getLicznik()-1);

break;

case 'B':

cout << "Podaj nazwe (imie) dla nowego bociana: ";

cin >> nazwa;

cout << "\nwysokosc (cm): ";

cin >> wysokosc;

cout << "\nwage (kg): ";

cin >> waga;

cout << "\nubarwienie: ";

cin >> ubarwienie;

cout << "\ndlugosc dzioba (cm): ";

cin >> cecha;

lista.add(new Bocian(nazwa, wysokosc, waga, ubarwienie, cecha));

cout << "\nZwierze zostalo dodane!" << endl;

lista.getZwierze(lista.getLicznik()-1);

break;

case 'C':

cout << "Podaj nazwe (imie) dla nowego kota: ";

cin >> nazwa;

cout << "\nwysokosc (cm): ";

cin >> wysokosc;

cout << "\nwage (kg): ";

cin >> waga;

cout << "\nubarwienie: ";

cin >> ubarwienie;

cout << "\ndlugosc ogona (cm): ";

cin >> cecha;

lista.add(new Kot(nazwa, wysokosc, waga, ubarwienie, cecha));

cout << "\nZwierze zostalo dodane!" << endl;

lista.getZwierze(lista.getLicznik()-1);

break;

case 'D':

cout << "Podaj nazwe (imie) dla nowej ryby: ";

cin >> nazwa;

cout << "\nwysokosc (cm): ";

cin >> wysokosc;

cout << "\nwage (kg): ";

cin >> waga;

cout << "\nubarwienie: ";

cin >> ubarwienie;

cout << "\nmaksymalne zanurzenie(m): ";

cin >> cecha;

lista.add(new Ryba(nazwa, wysokosc, waga, ubarwienie, cecha));

cout << "\nZwierze zostalo dodane!" << endl;

lista.getZwierze(lista.getLicznik()-1);

break;

case 'E':

cout << "Podaj nazwe (imie) dla nowego slonia: ";

cin >> nazwa;

cout << "\nwysokosc (cm): ";

cin >> wysokosc;

cout << "\nwage (kg): ";

cin >> waga;

cout << "\nubarwienie: ";

cin >> ubarwienie;

cout << "\nglosnosc trabienia(dB): ";

cin >> cecha;

lista.add(new Slon(nazwa, wysokosc, waga, ubarwienie, cecha));

cout << "\nZwierze zostalo dodane!" << endl;

lista.getZwierze(lista.getLicznik()-1);

break;

case 'F':

cout << "Podaj nazwe (imie) dla nowego wielblada:";

cin >> nazwa;

cout << "\nwysokosc (cm): ";

cin >> wysokosc;

cout << "\nwage (kg): ";

cin >> waga;

cout << "\nubarwienie: ";

cin >> ubarwienie;

cout << "\nilosc garbow: ";

cin >> cecha;

lista.add(new Wielblad(nazwa, wysokosc, waga, ubarwienie, cecha));

cout << "\nZwierze zostalo dodane!" << endl;

lista.getZwierze(lista.getLicznik()-1);

break;

case 'G':

cout << "Podaj nazwe (imie) dla nowego zajaca: ";

cin >> nazwa;

cout << "\nwysokosc (cm): ";

cin >> wysokosc;

cout << "\nwage (kg): ";

cin >> waga;

cout << "\nubarwienie: ";

cin >> ubarwienie;

cout << "\ndlugosc uszu (cm): ";

cin >> cecha;

lista.add(new Zajac(nazwa, wysokosc, waga, ubarwienie, cecha));

cout << "\nZwierze zostalo dodane!" << endl;

lista.getZwierze(lista.getLicznik()-1);

break;

case 'H':

cout << "Podaj nazwe (imie) dla nowego koto-bociana: ";

cin >> nazwa;

cout << "\nwysokosc (cm): ";

cin >> wysokosc;

cout << "\nwage (kg): ";

cin >> waga;

cout << "\nubarwienie kota: ";

cin >> ubarwienie;

cout << "\nubarwienie bociana: ";

cin >> ubarwienie2;

cout << "\ndlugosc ogona (cm): ";

cin >> cecha;

cout << "\ndlugosc dzioba (cm): ";

cin >> cecha2;

lista.add((Kot*)(new KotoBocian(nazwa, wysokosc, waga, ubarwienie, ubarwienie2, cecha, cecha2)));

cout << "\nZwierze zostalo dodane!" << endl;

lista.getZwierze(lista.getLicznik()-1);

break;

case 'I':

cout <<"Podaj nazwe (imie) dla nowej slonio-ryby:"; cin >> nazwa;

cout << "\nwysokosc (cm): ";

cin >> wysokosc;

cout << "\nwage (kg): ";

cin >> waga;

cout << "\nubarwienie slonia: ";

cin >> ubarwienie;

cout << "\nubarwienie rybu: ";

cin >> ubarwienie2;

cout << "\nglosnosc trabienia (dB): ";

cin >> cecha;

cout << "\nmaksymalne zanurzenie (m): ";

cin >> cecha2;

lista.add((Slon*)(new SlonioRyba(nazwa, wysokosc, waga, ubarwienie, ubarwienie2, cecha, cecha2)));

cout << "\nZwierze zostalo dodane!" << endl;

lista.getZwierze(lista.getLicznik()-1);

break;

case 'J':

cout << "Podaj nazwe (imie) dla nowego delfino-zajaca:";

cin >> nazwa;

cout << "\nwysokosc (cm): ";

cin >> wysokosc;

cout << "\nwage (kg): ";

cin >> waga;

cout << "\nubarwienie delfina: ";

cin >> ubarwienie;

cout << "\nubarwienie zajaca: ";

cin >> ubarwienie2;

cout << "\niloraz inteligencji (IQ): ";

cin >> cecha;

cout << "\ndlugosc uszu (cm): ";

cin >> cecha2;

lista.add((Delfin*)(new DelfinoZajac(nazwa, wysokosc, waga, ubarwienie, ubarwienie2, cecha, cecha2)));

cout << "\nZwierze zostalo dodane!" << endl;

lista.getZwierze(lista.getLicznik()-1);

break;

case 'K':

break;

}

break;

case 6: //Usuwanie obiektu:

system("cls");

int ind;

cout << "\nPodaj numer zwierzecia, ktore chcesz usunac\n"

<< "lub wpisz \"-1\" aby powrocic do menu glownego: " << endl;

cin >> ind;

ind -= 1;

if (ind < 0) break;

lista.remove(ind);

break;

case 7: //Ładowanie listy:

system("cls");

lista.load();

cout << "\nBaza danych zostala zaladowana.\n" << endl;

break;

case 8: //Zachowanie listy:

system("cls");

lista.save();

cout << "Lista zostala zachowana!" << endl;

break;

case 9: //Zachowanie listy i wyjście:

lista.save();

return 0;

case 10:

return 0;

}

system("pause");

return 1;

}

int main() {

//intro:

int ooo = 0;

while(ooo<35){

system("cls");

ooo++;

}

ooo = 0;

while(ooo<30){

cout << "\n\n\n\n\n\n"

<< "\n ZZZZZZZZZZZZZZZZZZZZZZ OOOOOO OOOOOO "

<< "\n ZZZZZZZZZZZZZZZZZZZZZZ OOOOOOOOOOOO OOOOOOOOOOOO "

<< "\n ZZZZZZZZZZZZZZZZZZZZZZ OOOOOOOOOOOOOOOO OOOOOOOOOOOOOOOO "

<< "\n ZZZZZZ OOOOOO OOOOOO OOOOOO OOOOOO "

<< "\n ZZZZZZ OOOOOOO OOOOOO OOOOOOO OOOOOO "

<< "\n ZZZZZZZZZZZZZZZZZZZZZZ OOOOOOOOOOOOOOOOOO OOOOOOOOOOOOOOOOOO "

<< "\n ZZZZZZZZZZZZZZZZZZZZZZ OOOOOOOOOOOOOO OOOOOOOOOOOOOO "

<< "\n ZZZZZZZZZZZZZZZZZZZZZZ OOOOOOOO OOOOOOOO ";

system("cls");

ooo++;

}

ooo = 0;

while(ooo<60){

system("cls");

ooo++;

}

//menu:

while(showMenu());

return 0;

}

/*Funkcja main() zaczyna swoje wukonywanie od tzw. intro, które wyświetla na ekranie kilka sekund duży napis zoo.

Póżniej uruchamiane jest menu programu. Funkcja showMenu() została zapętlona do momentu zwrócenia przez nią wartości 0. Jeśli natomiast użytkownik poda złą liczbę lub znak w menu, zwracana jest wartość 1 przez co następuje powrót do głównego menu.*/