Napis========================================
#pragma once
#include <iostream>
#include <string.h>
using namespace std;

class Napis
{
private:
	char m_pszNapis[40];
public:
	Napis();
	~Napis();
	const char* Zwroc() const;
	void Ustaw(const char* nowy_napis);
	void Wypisz() const;
	void Wpisz();
	int SprawdzNapis(const char* por_napis) const;
};

#include "Napis.h"



Napis::Napis()
{
}


Napis::~Napis()
{
}


const char* Napis::Zwroc() const
{
	return m_pszNapis;
}


void Napis::Ustaw(const char* nowy_napis)
{
	strcpy_s(m_pszNapis, nowy_napis);
}

void Napis::Wypisz() const
{
	cout << m_pszNapis << endl;
}

void Napis::Wpisz()
{
	char napis[40];
	cout << "Tekst: " << endl;
	cin >> napis;
	Ustaw(napis);
}

int Napis::SprawdzNapis(const char* por_napis) const
{
	return strcmp(m_pszNapis, por_napis);
}


=================== Data
#pragma once
#include <iostream>
using namespace std;

class Data
{
private:
	int m_nDzien;
	int m_nMiesiac;
	int m_nRok;
public:
	Data();
	~Data();
	void Ustaw(int d, int m, int r);
	int Dzien() const;
	int Miesiac() const;
	int Rok() const;
	void Wypisz() const;
	void Wpisz();
	int Porownaj(const Data & wzor) const;
private:
	void Koryguj();
};

#include "Data.h"




Data::Data()
{
	m_nDzien = 1;
	m_nMiesiac = 1;
	m_nRok = 2000;
}


Data::~Data()
{
}

void Data::Ustaw(int d, int m, int r)
{
	m_nDzien = d;
	m_nMiesiac = m;
	m_nRok = r;
	Koryguj();
}


int Data::Dzien() const
{
	return this->m_nDzien;
}

int Data::Miesiac() const
{
	return this->m_nMiesiac;
}

int Data::Rok() const
{
	return this->m_nRok;
}

void Data::Wypisz() const
{
	cout << Dzien() << "-" << Miesiac() << "-" << Rok() << endl;
}

void Data::Wpisz()
{
	cout << "Podaj date: \nDzien: ";
	cin >> m_nDzien;
	cout << "Miesiac: ";
	cin >> m_nMiesiac;
	cout << "Rok: ";
	cin >> m_nRok;
	Koryguj();
}

void Data::Koryguj()
{
	if (m_nDzien < 1)
		m_nDzien = 1;
	if (m_nDzien > 29 && m_nMiesiac == 2 && (m_nRok % 4 == 0 && m_nRok % 100 != 0 || m_nRok % 400 == 0))
		m_nDzien = 28;
	else if (m_nDzien>30)
		m_nDzien = 29;
	if (m_nMiesiac < 1)
		m_nMiesiac = 1;
	if (m_nMiesiac > 12)
		m_nMiesiac = 12;
	if (m_nDzien > 31 && (m_nMiesiac == 1 || m_nMiesiac == 3 || m_nMiesiac == 5 || m_nMiesiac == 6 || m_nMiesiac == 7 || m_nMiesiac == 9 || m_nMiesiac == 11))
		m_nDzien = 31;
	else if (m_nDzien>30)
		m_nDzien = 30;
}

int Data::Porownaj(const Data & wzor) const
{
	if (wzor.m_nRok > m_nRok)
		return 1;
	else if (wzor.m_nRok < m_nRok)
		return -1;
	else if (wzor.m_nMiesiac > m_nMiesiac)
		return 1;
	else if (wzor.m_nMiesiac < m_nMiesiac)
		return -1;
	else if (wzor.m_nDzien > m_nDzien)
		return 1;
	else if (wzor.m_nDzien < m_nDzien)
		return -1;
	else
		return 0;
}

==========================Pracownik
#pragma once
#include "Napis.h"
#include "Data.h"
using namespace std;

class Pracownik
{
private:
	Napis m_Imie;
	Napis m_Nazwisko;
	Data m_DataUrodzenia;
public:
	Pracownik();
	~Pracownik();
	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;
	Pracownik* m_pNastepny;
	int Porownaj(const Pracownik& wzorzec) const;
};


#include "Pracownik.h"



Pracownik::Pracownik()
{
}


Pracownik::~Pracownik()
{
}

const char* Pracownik::Imie() const
{
	return this->m_Imie.Zwroc();
}

const char* Pracownik::Nazwisko() const
{
	return this->m_Nazwisko.Zwroc();
}

void Pracownik::Imie(const char* nowe_imie)
{
	this->m_Imie.Ustaw(nowe_imie);
}

void Pracownik::Nazwisko(const char* nowe_nazwisko)
{
	this->m_Nazwisko.Ustaw(nowe_nazwisko);
}

void Pracownik::DataUrodzenia(int nowy_dzien, int nowy_miesiac, int nowy_rok)
{
	this->m_DataUrodzenia.Ustaw(nowy_dzien, nowy_miesiac, nowy_rok);
}

void Pracownik::Wypisz() const
{
	this->m_Imie.Wypisz();
	this->m_Nazwisko.Wypisz();
	this->m_DataUrodzenia.Wypisz();
}

void Pracownik::Wpisz()
{
	cout << endl << "Dane pracownika:" << endl;
	this->m_Imie.Wpisz();
	this->m_Nazwisko.Wpisz();
	this->m_DataUrodzenia.Wpisz();
}

int Pracownik::SprawdzImie(const char* por_imie) const
{
	return this->m_Imie.SprawdzNapis(por_imie);
}

int Pracownik::SprawdzNazwisko(const char* por_nazwisko) const
{
	return this->m_Nazwisko.SprawdzNapis(por_nazwisko);
}

int Pracownik::Porownaj(const Pracownik& wzorzec) const
{
	if (SprawdzImie(wzorzec.Imie()) == 0 && SprawdzNazwisko(wzorzec.Nazwisko()) == 0 && m_DataUrodzenia.Porownaj(wzorzec.m_DataUrodzenia) == 0)
		return 0;
	else if (SprawdzNazwisko(wzorzec.Nazwisko()) > 0)
		return 1;
	else if (SprawdzNazwisko(wzorzec.Nazwisko()) < 0)
		return -1;
	else if (SprawdzImie(wzorzec.Imie()) > 0)
		return 1;
	else if (SprawdzImie(wzorzec.Imie())  < 0)
		return -1;
	else if (m_DataUrodzenia.Porownaj(wzorzec.m_DataUrodzenia) > 0)
		return 1;
	else if (m_DataUrodzenia.Porownaj(wzorzec.m_DataUrodzenia) < 0)
		return -1;
}

================Lista
#pragma once
#include "Pracownik.h"

class ListaPracownikow
{
	Pracownik* m_pPoczatek;
	int m_nLiczbaPracownikow;
public:
	ListaPracownikow();
	~ListaPracownikow();
	void Dodaj(const Pracownik& p);
	void Usun(const Pracownik &wzorzec);
	void WypiszPracownikow() const;
	const Pracownik* Szukaj(const char* nazwisko, const char* imie) const;
};


#include "ListaPracownikow.h"



ListaPracownikow::ListaPracownikow()
{
	m_pPoczatek = NULL;
	m_nLiczbaPracownikow = 0;
}


ListaPracownikow::~ListaPracownikow()
{
}

void ListaPracownikow::Dodaj(const Pracownik &p)
{
	Pracownik *nowy = new Pracownik(p);
	if (m_nLiczbaPracownikow == 0)
	{
		m_pPoczatek = nowy;
		m_nLiczbaPracownikow++;
	}
	else
	{
		Pracownik *tmp1 = m_pPoczatek;
		for (int i = 0; i < m_nLiczbaPracownikow; i++)
		{
			if (tmp1->Porownaj(*nowy) == -1)
			{

				if (tmp1->m_pNastepny)
					tmp1 = tmp1->m_pNastepny;
				else
				{
					tmp1->m_pNastepny = nowy;
					m_nLiczbaPracownikow++;
					break;
				}

			}
			else if (tmp1->Porownaj(*nowy) == 1)
			{
				Pracownik *tmp2 = m_pPoczatek;
				if (tmp1 == tmp2)
				{
					if (!m_pPoczatek->m_pNastepny)
						tmp2->m_pNastepny = NULL;
					m_pPoczatek = nowy;
					nowy->m_pNastepny = tmp1;
					m_nLiczbaPracownikow++;
				}
				else
				{
					while (tmp2->m_pNastepny != tmp1)
						tmp2 = tmp2->m_pNastepny;
					nowy->m_pNastepny = tmp1;
					tmp2->m_pNastepny = nowy;
					m_nLiczbaPracownikow++;
					break;
				}
				break;
			}
			else
				break;
		}
	}
}

void ListaPracownikow::Usun(const Pracownik &wzorzec)
{
	Pracownik* tmp = m_pPoczatek;
	Pracownik* p = new Pracownik(wzorzec);
	if (!tmp->Porownaj(*p))
	{
		m_pPoczatek = tmp->m_pNastepny;
		delete tmp;
		m_nLiczbaPracownikow--;
	}
	else {
		while (tmp->m_pNastepny->Porownaj(*p))
		{
			tmp = tmp->m_pNastepny;
		}
		Pracownik* usuwany = tmp->m_pNastepny;
		tmp->m_pNastepny = tmp->m_pNastepny->m_pNastepny;
		delete usuwany;
		m_nLiczbaPracownikow--;
	}
}

void ListaPracownikow::WypiszPracownikow() const
{
	cout << "\n=== Pracownicy: ===\n";
	Pracownik *tmp = m_pPoczatek;
	for (int i = 0; i < m_nLiczbaPracownikow; i++)
	{
		tmp->Wypisz();
		tmp = tmp->m_pNastepny;
	}
}

const Pracownik* ListaPracownikow::Szukaj(const char* nazwisko, const char* imie) const
{
	Pracownik* tmp = m_pPoczatek;
	for (int i = 0; i < m_nLiczbaPracownikow; i++)
	{
		if (tmp->SprawdzNazwisko(nazwisko) == 0 && tmp->SprawdzImie(imie) == 0)
		{
			return tmp;
			break;
		}
		tmp = tmp->m_pNastepny;
	}
	return nullptr;
}