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;
};