View difference between Paste ID: qBE5Fz8J and 9vaaJxvd

 PRACOWNIK.CPP
 
 #include "Pracownik.h"
 
 using namespace std;
 
 Pracownik::Pracownik(const char* imie, const char* nazwisko, int dzien, int miesiac, int rok) : m_DataUrodzenia(dzien, miesiac, rok), m_Imie(imie), m_Nazwisko(nazwisko), m_nIDZatrudnienia(m_nIDZatrudnienia)
 {
 }
 
 Pracownik::Pracownik(const Pracownik &wzor) : m_nIDZatrudnienia(m_nIDZatrudnienia + 1), m_Imie(wzor.m_Imie), m_Nazwisko(wzor.m_Nazwisko), m_DataUrodzenia(wzor.m_DataUrodzenia)
 {
 }
 
 Pracownik::~Pracownik()
 {
 }
 
 const char* Pracownik::Imie() const
 {
 	return m_Imie.Zwroc();
 }
 
 const char* Pracownik::Nazwisko() const
 {
 	return m_Nazwisko.Zwroc();
 }
 
 void Pracownik::Imie(const char* nowe_imie)
 {
 	m_Imie.Ustaw(nowe_imie);
 }
 
 void Pracownik::Nazwisko(const char* nowe_nazwisko)
 {
 	m_Nazwisko.Ustaw(nowe_nazwisko);
 }
 
 void Pracownik::DataUrodzenia(int nowy_dzien, int nowy_miesiac, int nowy_rok)
 {
 	m_DataUrodzenia.Ustaw(nowy_dzien, nowy_miesiac, nowy_rok);
 }
 
 void Pracownik::Wypisz() const
 {
 	m_Imie.Wypisz();
 	cout << '\t';
 	m_Nazwisko.Wypisz();
 	cout << '\t';
 	m_DataUrodzenia.Wypisz();
 }
 
 void Pracownik::Wpisz()
 {
 	cout << "Podaj imie            : ";
 	m_Imie.Wpisz();
 
 	cout << "Podaj nazwisko        : ";
 	m_Nazwisko.Wpisz();
 
 	cout << "Podaj date urodzenia" << endl;
 	m_DataUrodzenia.Wpisz();
 	//cout << endl;
 }
 
 int Pracownik::SprawdzImie(const char* por_imie) const
 {
 	return m_Imie.SprawdzNapis(por_imie);
 }
 
 int Pracownik::SprawdzNazwisko(const char* por_nazwisko) const
 {
 	return m_Nazwisko.SprawdzNapis(por_nazwisko);
 }
 
 int Pracownik::Porownaj(const Pracownik& wzorzec) const
 {
 	if (wzorzec.SprawdzNazwisko(m_Nazwisko.Zwroc()) == 0)
 	{
 		if (wzorzec.SprawdzNazwisko(m_Nazwisko.Zwroc()) == 0)
 		{
 			if (wzorzec.m_DataUrodzenia.Porownaj(m_DataUrodzenia) == 0)
 			{
 				return 0;
 			}
 			else
 			{
 				if (wzorzec.m_DataUrodzenia.Porownaj(m_DataUrodzenia) > 0)
 				{
 					return 1;
 				}
 				else
 				{
 					return -1;
 				}
 			}
 		}
 		else
 		{
 			if (wzorzec.SprawdzNazwisko(m_Nazwisko.Zwroc()) > 0)
 			{
 				return 1;
 			}
 			else
 			{
 				return -1;
 			}
 		}
 	}
 	else
 	{
 		if (wzorzec.SprawdzNazwisko(m_Nazwisko.Zwroc()) > 0)
 		{
 			return 1;
 		}
 		else
 		{
 			return -1;
 		}
 	}
 }
 
 Pracownik& Pracownik::operator=(const Pracownik &wzor)
 {
 	if (this == &wzor)
 		return *this;
 	m_DataUrodzenia = wzor.m_DataUrodzenia;
 	m_Imie = wzor.m_Imie;
 	m_Nazwisko = wzor.m_Nazwisko;
 }
 
 bool Pracownik::operator == (const Pracownik &wzor) const
 {
 	if (this == &wzor)
 		return true;
 	if (this->Porownaj(wzor) == 0)
 		return true;
 	else
 		return false;
 }
 
 ostream &operator<<(ostream& wy, const Pracownik &p)
 {
 	wy << p.m_Imie << endl << p.m_Nazwisko << endl << p.m_DataUrodzenia;
 	return wy;
 }
 
 istream &operator >> (istream& we, Pracownik &p)
 {
 	we >> p.m_Imie >> p.m_Nazwisko >> p.m_DataUrodzenia;
 	return we;
 }
 void Pracownik::WypiszDane()
 {
 	m_Imie.Wypisz();
 	cout << ' ';
 	m_Nazwisko.Wypisz();
 	cout << ' ';
 	m_DataUrodzenia.Wypisz();
 }
 
 Pracownik* Pracownik::KopiaObiektu()
 {
 	Pracownik* nowyPracownik;
 	nowyPracownik = new Pracownik(*this);
 	return nowyPracownik;
 }
 
 ///////////////////////////////////////////////////
 
 PRACOWNIK.H
 
 #pragma once
 #include "Napis.h"
 #include "Data.h"
 #include <iostream>
 
 class Pracownik
 {
 private:
 	Napis m_Imie;
 	Napis m_Nazwisko;
 	Data m_DataUrodzenia;
 	const int m_nIDZatrudnienia;
 public:
 	Pracownik(const char* imie = "", const char* nazwisko = "", int dzien = 1, int miesiac = 1, int rok = 2000);
 	Pracownik(const Pracownik &wzor);
 	~Pracownik();
 	Pracownik *m_pNastepny;
 	const char* Imie() const;
 	const char* Nazwisko() const;
 	void Imie(const char* nowe_imie);
 	void Nazwisko(const char* nowe_nazwisko);
 	void DataUrodzenia(int nowy_dzien, int nowy_miesiac, int nowy_rok);
 	void Wypisz() const;
 	void Wpisz();
 	int SprawdzImie(const char* por_imie) const;
 	int SprawdzNazwisko(const char* por_nazwisko) const;
 	int Porownaj(const Pracownik& wzorzec) const;
 	Pracownik &operator=(const Pracownik &wzor);
 	bool operator == (const Pracownik &wzor) const;
 	friend ostream &operator<<(ostream& wy, const Pracownik &p);
 	friend istream &operator >> (istream& we, Pracownik &p);
 	virtual void WypiszDane(); // wypisuje na ekranie wszystkie dane o pracowniku
 	virtual Pracownik* KopiaObiektu(); // zwraca nowo stworzonego obiektu
 
 };
 
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 NAPIS.CPP
 
 #define _CRT_SECURE_NO_WARNINGS
 #include "Napis.h"
 
 using namespace std;
 
 Napis::Napis(const char* napis)
 {
 	m_nDl = strlen(napis) + 1;
 	m_pszNapis = new char[m_nDl];
 	strcpy(m_pszNapis, napis);
 }
 
 Napis::Napis(const Napis &wzor)
 {
 	m_nDl = wzor.m_nDl;
 	m_pszNapis = new char[m_nDl];
 	strcpy(m_pszNapis, wzor.m_pszNapis);
 }
 
 Napis::~Napis()
 {
 	delete[] m_pszNapis;
 }
 
 const char* Napis::Zwroc() const
 {
 	return m_pszNapis;
 }
 
 void Napis::Ustaw(const char* nowy_napis)
 {
 	m_nDl = strlen(nowy_napis) + 1;
 	m_pszNapis = new char[m_nDl];
 	strcpy(m_pszNapis, nowy_napis);
 }
 
 void Napis::Wypisz() const
 {
 	cout << m_pszNapis;
 }
 
 void Napis::Wpisz()
 {
 	string napis;
 	cin >> napis;
 	Ustaw(napis.c_str());
 }
 
 int Napis::SprawdzNapis(const char* por_napis) const
 {
 	return strcmp(m_pszNapis, por_napis);
 }
 
 Napis & Napis::operator=(const Napis & wzor)
 {
 	if (this == &wzor)
 		return *this;
 	m_nDl = wzor.m_nDl;
 	m_pszNapis = new char[m_nDl];
 	strcpy(m_pszNapis, wzor.m_pszNapis);
 	return *this;
 }
 
 bool Napis::operator ==(const Napis & wzor) const
 {
 	if (this == &wzor)
 		return true;
 	if (m_nDl == wzor.m_nDl && strcmp(m_pszNapis, wzor.m_pszNapis) == 0)
 		return true;
 	else
 		return false;
 }
 
 ostream & operator << (ostream& wy, const Napis & p)
 {
 	wy << p.m_pszNapis;
 	return wy;
 }
 
 istream &operator >> (istream &we, Napis &p)
 {
 	string str;
 	we >> str;
 	p.m_nDl = str.length() + 1;
 	p.m_pszNapis = new char[p.m_nDl];
 	strcpy(p.m_pszNapis, str.c_str());
 	return we;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////
 
 NAPIS.H
 
 #pragma once
 #include <iostream>
 #include <string>
 
 using namespace std;
 
 class Napis
 {
 private:
 	char* m_pszNapis;
 	int m_nDl;
 public:
 	Napis(const char* napis = "");
 	Napis(const Napis &wzor);
 	~Napis();
 	const char* Zwroc() const;
 	void Ustaw(const char* nowy_napis);
 	void Wypisz() const;
 	void Wpisz();
 	int SprawdzNapis(const char* por_napis) const;
 	Napis & operator=(const Napis & wzor);
 	bool operator ==(const Napis & wzor) const;
 	friend ostream & operator << (ostream& wy, const Napis & p);
 	friend istream &operator >> (istream &we, Napis &p);
 };
 
 /////////////////////////////////////////////////////////////////////////////
 
 LISTA PRACOWNIKÓW.CPP
 
 #include "ListaPracownikow.h"
 
 #include<fstream>
 
 ListaPracownikow::ListaPracownikow()
 {
 	m_nLiczbaPracownikow = 0;
 	m_pPoczatek = nullptr;
 }
 
 
 ListaPracownikow::~ListaPracownikow()
 {
 }
 
 void ListaPracownikow::Dodaj(Pracownik& p)
 {
 	Pracownik* aktualny = m_pPoczatek;
 	Pracownik* nastepny;
 	int licznik = 0;
 	if (m_nLiczbaPracownikow == 0)
 	{
 		m_pPoczatek = &p;
 		p.m_pNastepny = nullptr;
 		m_nLiczbaPracownikow++;
 		return;
 	}
 	else if (m_nLiczbaPracownikow == 1)
 	{
 		if (aktualny->SprawdzNazwisko(p.Nazwisko()) > 0)
 		{
 			m_pPoczatek = &p;
 			p.m_pNastepny = aktualny;
 			m_nLiczbaPracownikow++;
 			return;
 		}
 		else if (aktualny->SprawdzNazwisko(p.Nazwisko()) < 0)
 		{
 			aktualny->m_pNastepny = &p;
 			p.m_pNastepny = nullptr;
 			m_nLiczbaPracownikow++;
 			return;
 		}
 	}
 	else
 	{
 		nastepny = aktualny->m_pNastepny;
 		if (aktualny->SprawdzNazwisko(p.Nazwisko()) > 0)
 		{
 			m_pPoczatek = &p;
 			p.m_pNastepny = aktualny;
 			m_nLiczbaPracownikow++;
 			return;
 		}
 		while (licznik <= m_nLiczbaPracownikow)
 		{
 			if (nastepny->SprawdzNazwisko(p.Nazwisko()) > 0)
 			{
 				aktualny->m_pNastepny = &p;
 				p.m_pNastepny = nastepny;
 				m_nLiczbaPracownikow++;
 				return;
 			}
 			else if (nastepny->SprawdzNazwisko(p.Nazwisko()) < 0)
 			{
 				aktualny = nastepny;
 				nastepny = aktualny->m_pNastepny;
 				licznik++;
 			}
 
 			if (nastepny == nullptr)
 			{
 				aktualny->m_pNastepny = &p;
 				p.m_pNastepny = nullptr;
 				m_nLiczbaPracownikow++;
 				return;
 			}
 		}
 	}
 }
 
 void ListaPracownikow::Usun(const Pracownik& wzorzec)
 {
 	Pracownik* aktualny = m_pPoczatek;
 	Pracownik* poprzedni = nullptr;
 	if (m_nLiczbaPracownikow == 0)
 	{
 		std::cout << "Brak pracownikow!" << std::endl;
 	}
 	else
 	{
 		for (int i = 0; i <= m_nLiczbaPracownikow; i++)
 		{
 			if (aktualny->Porownaj(wzorzec) == 0)
 			{
 				if (aktualny == m_pPoczatek)
 				{
 					m_pPoczatek = aktualny->m_pNastepny;
 					m_nLiczbaPracownikow--;
 					return;
 				}
 				else
 				{
 					poprzedni->m_pNastepny = aktualny->m_pNastepny;
 					m_nLiczbaPracownikow--;
 					return;
 				}
 
 			}
 			else
 			{
 				poprzedni = aktualny;
 				aktualny = aktualny->m_pNastepny;
 			}
 		}
 		std::cout << "Nie znaleziono podanego pracownika na liscie!" << std::endl;
 	}
 }
 
 void ListaPracownikow::WypiszPracownikow() const
 {
 	Pracownik* aktualny = m_pPoczatek;
 	if (m_nLiczbaPracownikow == 0)
 	{
 		std::cout << "Lista pracownikow jest pusta!" << std::endl;
 	}
 	else
 	{
 		for (int i = 1; i <= m_nLiczbaPracownikow; i++)
 		{
 			std::cout << "Pracownik #" << i << ": ";
 			aktualny->Wypisz();
 			aktualny = aktualny->m_pNastepny;
 		}
 	}
 }
 
 const Pracownik* ListaPracownikow::Szukaj(const char* nazwisko, const char* imie) const
 {
 	Pracownik* aktualny = m_pPoczatek;
 	if (m_nLiczbaPracownikow == 0)
 	{
 		std::cout << "Lista pracownikow jest pusta!" << std::endl;
 		return nullptr;
 	}
 	else
 	{
 		for (int i = 1; i <= m_nLiczbaPracownikow; i++)
 		{
 			if ((aktualny->SprawdzImie(imie) == 0) && (aktualny->SprawdzNazwisko(nazwisko) == 0))
 			{
 				std::cout << "Znaleziono pracownika!" << std::endl;
 				aktualny->Wypisz();
 				return aktualny;
 			}
 			else
 			{
 				aktualny = aktualny->m_pNastepny;
 			}
 		}
 		return nullptr;
 	}
 }
 
 void ListaPracownikow::ZapisDoPliku()const
 {
 	ofstream plik;
 	plik.open("lista.dat", fstream::out);
 	if (!plik.good())
 	{
 		cout << "Problem z otwarciem pliku docelowego!" << endl;
 	}
 	else
 	{
 		Pracownik* aktualny = m_pPoczatek;
 		for (int i = 0; i < m_nLiczbaPracownikow; i++)
 		{
 			if (aktualny != nullptr)
 			{
 				plik << *aktualny << endl;
 			}
 			aktualny = aktualny->m_pNastepny;
 		}
 	}
 	plik.close();
 }
 
 void ListaPracownikow::WczytajZPliku()
 {
 	ifstream plik;
 	plik.open("lista.dat", fstream::in);
 	if (!plik.good())
 	{
 		cout << "Plik z danymi nie istnieje!" << endl;
 	}
 	else
 	{
 		m_nLiczbaPracownikow = 0;
 		m_pPoczatek = nullptr;
 		Pracownik* temp = new Pracownik();
 		while (plik >> *temp)
 		{
 			Dodaj(*temp);
 			temp = new Pracownik();
 		}
 	}
 }
 
 ///////////////////////////////////////////////////////////////////////////////////
 
 LISTA PRACOWNIKÓW.H
 
 #pragma once
 #include "Pracownik.h"
 #include <iostream>
 
 using namespace std;
 
 class ListaPracownikow
 {
 public:
 	ListaPracownikow();
 	~ListaPracownikow();
 
 	void Dodaj(Pracownik& p);
 	void Usun(const Pracownik& wzorzec);
 	void WypiszPracownikow() const;
 	const Pracownik* Szukaj(const char* nazwisko, const char* imie) const;
 	void ZapisDoPliku()const;
 	void WczytajZPliku();
 private:
 	Pracownik* m_pPoczatek;
 	int m_nLiczbaPracownikow;
 };