LABKI 6 CPP POZDROO LECIMU W HUJ

#include "Data.h"

Data::Data(int d, int m, int r)
{
    this->Ustaw(d, m, r);
}
Data::~Data(void)
{
}
void Data::Ustaw(int d, int m, int r)
{
    this->m_nDzien = d;
    this->m_nMiesiac = m;
    this->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
{
    std::cout << this->m_nDzien << "-" << this->m_nMiesiac << "-" << this->m_nRok << std::endl;
}

void Data::Wpisz()
{
    int d, m, r;
    std::cout << "Podaj dzien: ";
    std::cin >> d;

    std::cout << "Podaj miesiac: ";
    std::cin >> m;

    std::cout << "Podaj rok: ";
    std::cin >> r;

    Ustaw(d, m, r);
}

void Data::Koryguj()
{
    if(this->m_nMiesiac == 1 || this->m_nMiesiac == 3 || this->m_nMiesiac == 5 || this->m_nMiesiac == 7 || this->m_nMiesiac == 8 || this->m_nMiesiac == 10 || this->m_nMiesiac == 12)
    {
        if (this->m_nDzien > 31) this->m_nDzien = 31;
    }
    else
    {
        if (this->m_nDzien > 30) this->m_nDzien = 30;
    }

        if (this->m_nMiesiac == 2)
        {
            if (this->m_nRok % 4 ==0)
            {
                if (this->m_nDzien > 29) this->m_nDzien = 29;
            }
            else if (this->m_nDzien > 28) this->m_nDzien = 28;
        }
}


int Data::Porownaj(const Data & wzor) const
{
    if (wzor.m_nDzien == this->m_nDzien && wzor.m_nMiesiac == this->m_nMiesiac && wzor.m_nRok == this->m_nRok) return 0;
    if(wzor.m_nRok > this->m_nRok) return 1;
    if (wzor.m_nRok == this->m_nRok && wzor.m_nMiesiac > this->m_nMiesiac) return 1;
    if (wzor.m_nRok == this->m_nRok && wzor.m_nMiesiac == this->m_nMiesiac && wzor.m_nDzien > this->m_nDzien) return 1;
    return -1;
}
ostream& operator<<(ostream &wy, const Data &d) {
    return wy << d.m_nDzien << '-' << d.m_nMiesiac << '-' << d.m_nRok << '\n';

}
istream& operator >> (istream &we, Data & d) {
    char c;

    if (&we == &cin) we >> d.m_nDzien >> d.m_nMiesiac >> d.m_nRok;
    else we >> d.m_nDzien >> c >> d.m_nMiesiac >> c >> d.m_nRok;

    d.Koryguj();

    return we;

}



#include "Napis.h"

Napis::Napis(const char* nap)
{
    this->m_nDl = strlen(nap);
    this->m_pszNapis = new char[this->m_nDl];
    strcpy(this->m_pszNapis, nap);
}

Napis::~Napis()
{
    //this->m_nDl = -1;
    //delete[] m_pszNapis;
}

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

void Napis::Ustaw(const char* nowy_napis)
{
    this->m_nDl = strlen(nowy_napis);
    this->m_pszNapis = new char[this->m_nDl];
    strcpy(this->m_pszNapis, nowy_napis);
}

void Napis::Wypisz() const
{
    std::cout<<this->m_pszNapis << '\t';;
}

void Napis::Wpisz()
{
    std::cin >> this->m_pszNapis;
}

int Napis::SprawdzNapis(const char* por_napis) const
{
    if (strcmp(por_napis, this->m_pszNapis) == 0) return 0;
    if (strcmp(por_napis, this->m_pszNapis)>0) return 1;
    return -1;
}
Napis::Napis(const Napis &wzor) {
    this->m_nDl = wzor.m_nDl;
    this->m_pszNapis = new char[this->m_nDl];
    strcpy(this->m_pszNapis, wzor.m_pszNapis);

}
Napis& Napis::operator=(const Napis &wzor) {
    //delete[] this->m_pszNapis;
    this->m_nDl = wzor.m_nDl;
    this->m_pszNapis = new char[this->m_nDl];
    strcpy(this->m_pszNapis, wzor.m_pszNapis);
    return *this;
}
bool Napis::operator==(const Napis &wzor) const
{
    return strcmp(this->m_pszNapis, wzor.m_pszNapis) == 0;
}
ostream & operator<<(ostream & wy, const Napis &p) {
    return wy << p.m_pszNapis;
}
istream & operator >> (istream &we, Napis & p)
{
    char z[256];
    we.width(256);
    we >> z;
    p.Ustaw(z);
    return we;

}


#include "Pracownik.h"

Pracownik::Pracownik(const char* im , const char * naz, int dzien, int miesiac, int rok) : m_nIDZatrudnienia(*(int*)this)
{
    this->Imie(im);
    this->Nazwisko(naz);
    this->DataUrodzenia(dzien, miesiac, rok);
}

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
{
    m_Imie.Wypisz();
    m_Nazwisko.Wypisz();
    m_DataUrodzenia.Wypisz();
}

void Pracownik::Wpisz()
{
    std::cout <<"Podaj imie: ";
    this->m_Imie.Wpisz();
    std::cout << "Podaj nazwisko: ";
    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 (this->SprawdzNazwisko(wzorzec.Nazwisko()) < 0)
        return -1;
    if (this->SprawdzNazwisko(wzorzec.Nazwisko()) > 0)
        return 1;
    if (this->SprawdzNazwisko(wzorzec.Nazwisko()) == 0)
    {
        if (this->SprawdzImie(wzorzec.Imie()) < 0)
            return -1;
        if (this->SprawdzImie(wzorzec.Imie()) > 0)
            return 1;
        if (this->SprawdzImie(wzorzec.Imie()) == 0)
        {
            if (this->m_DataUrodzenia.Porownaj(wzorzec.m_DataUrodzenia) < 0)
                return -1;
            if (this->m_DataUrodzenia.Porownaj(wzorzec.m_DataUrodzenia) > 0)
                return 1;
            if (this->m_DataUrodzenia.Porownaj(wzorzec.m_DataUrodzenia) == 0)
            return 0;
        }
    }
    return 0;
}
Pracownik::Pracownik(const Pracownik &wzor) : m_nIDZatrudnienia(*(int*)&wzor) {
    this->m_Imie = wzor.m_Imie;
    this->m_Nazwisko = wzor.m_Nazwisko;
    this->m_DataUrodzenia = wzor.m_DataUrodzenia;
}
Pracownik& Pracownik::operator=(const Pracownik &wzor) {
    if (this == &wzor) return *this;

    this->~Pracownik();
    new (this) Pracownik(wzor);

    return *this;

}
bool Pracownik::operator==(const Pracownik & wzor) const {
    return this->Porownaj(wzor) == 0;

}
ostream & operator<<(ostream & wy, const Pracownik &p) {
    return wy << p.m_Imie << " " << p.m_Nazwisko << " " << p.m_DataUrodzenia;

}
istream & operator>>(istream & we, Pracownik &p) {
    return we >> p.m_Imie >> p.m_Nazwisko >> p.m_DataUrodzenia;

}

#include "TablicaPracownikow.h"

using namespace std;
TablicaPracownikow::TablicaPracownikow(void)
{
    m_nLiczbaPracownikow = 0;
}



void TablicaPracownikow::Dodaj(const Pracownik & p)
{
    Pracownik pr = p;

    for (int i = 0; i < m_nLiczbaPracownikow; i++)
    {
        if (m_pTablica[i].Porownaj(pr) == 0)
        {
            cout << "Istnieje juz taki pracownik!" << endl;
            return;
        }
    }
    Pracownik tmp1, tmp2;
    if (m_nLiczbaPracownikow < 19)
    {
        m_nLiczbaPracownikow++;

        for (int i = 0; i < m_nLiczbaPracownikow - 1; i++)
        {
            if (m_pTablica[i].Porownaj(pr) < 0)
            {
                tmp1 = m_pTablica[i];
                m_pTablica[i] = pr;

                for (int j = i + 1; j < m_nLiczbaPracownikow; j++)
                {
                    tmp2 = m_pTablica[j];
                    m_pTablica[j] = tmp1;
                    tmp1 = tmp2;
                }
                cout << "Dodano!" << endl;
                return;
            }
        }
        m_pTablica[m_nLiczbaPracownikow - 1] = pr;
        cout << "Dodano!" << endl;
    }
    else
    {
        cout << "Przekroczony rozmiar tablicy" << endl;
    }
}

void TablicaPracownikow::Usun(const Pracownik & wzorzec)
{
    int usunieto = 0;
    for (int i = 0; i < m_nLiczbaPracownikow; i++)
    {
        if (m_pTablica[i].Porownaj(wzorzec) == 0)
        {
            m_nLiczbaPracownikow--;
            for (int j = i; j < m_nLiczbaPracownikow; j++)
            {
                m_pTablica[j] = m_pTablica[j + 1];
            }
            usunieto = 1;
            cout << "Pracownik usunięty" << endl;
        }
    }
    if (usunieto!=1)
        cout << "Nie ma takiego pracownika!" << endl;
    usunieto = 0;
}

void TablicaPracownikow::WypiszPracownikow() const
{
    if (m_nLiczbaPracownikow <= 0) cout << "Brak pracowników do wyświetlenia" << endl;
    else
        for (int i = 0; i < m_nLiczbaPracownikow; i++)
        {
            m_pTablica[i].Wypisz();
        }
}

const Pracownik* TablicaPracownikow::Szukaj(const char* nazwisko, const char* imie) const
{
    for (int i = 0; i < m_nLiczbaPracownikow; i++)
    {
        if (m_pTablica[i].SprawdzImie(imie) == 0)
        {
            if (m_pTablica[i].SprawdzNazwisko(nazwisko) == 0)
            {
                return &m_pTablica[i];
            }
        }
    }
    return NULL;
}
ostream& operator<< (ostream& wy, const TablicaPracownikow& t) {
    for (int i = 0; i < t.m_nLiczbaPracownikow; i++) wy << t.m_pTablica[i];

    return wy;
}
istream& operator>> (istream& we, TablicaPracownikow& a) {
    Pracownik p;

    while (we.peek() != -1) {
        we >> p;
        a.Dodaj(p);
        we.ignore();
    }

    return we;
}




#include "Pracownik.h"
#include "Napis.h"
#include "Data.h"
#include"TablicaPracownikow.h"
#include <conio.h>
#include <fstream>

using namespace std;
int main()
{
    TablicaPracownikow tablica;
    Pracownik* p = new Pracownik();
    int dec = -1;

    while (dec != 0)
    {
        system("cls");
        cout << "________________________________" << endl;
        cout << "|0 - wyjscie                   |" << endl;
        cout << "|1 - wypisz pracownikow        |" << endl;
        cout << "|2 - dodaj pracownika          |" << endl;
        cout << "|3 - usun pracownika           |" << endl;
        cout << "|4 - znajdz pracownika         |" << endl;
        cout << "|5 - dodaj do pliku            |" << endl;
        cout << "|6 - pobierz z pliku           |" << endl;
        cout << "|______________________________|" << endl;
        cin >> dec;
        system("cls");
        switch (dec)
        {
        case 0: {
            exit(0);
                }
        case 1: {
            cout << "LISTA PRACOWNIKOW" << endl;
            tablica.WypiszPracownikow();
            break;
                }
        case 2:
            {
            cout << "DODAWANIE PRACOWNIKA" << endl;
            p->Wpisz();
            tablica.Dodaj(*p);
            break;
            }
        case 3:
        {
            cout << "USUWANIE PRACOWNIKA" << endl;
            cout << "Podaj pracownika do usuniecia" << endl;
            p->Wpisz();
            tablica.Usun(*p);
            break;
        }
        case 4: {
            cout << "SZUKANIE PRACOWNIKA" << endl;
            Napis imie;
            Napis nazwisko;
            cout << "Imię i nazwisko:";
            imie.Wpisz();
            nazwisko.Wpisz();

            if (tablica.Szukaj(nazwisko.Zwroc(), imie.Zwroc()) == NULL)
                cout << "Nie znaleziono takiego pracownika!" << endl;
            else
            {
                cout << "Znaleziony pracownik:" << endl;
                tablica.Szukaj(nazwisko.Zwroc(), imie.Zwroc())->Wypisz();
            }
            break;
                }
        case 5: {
            char filename[64];
            cout << "Nazwa Pliku:";
            cin >> filename;

            ofstream file(filename);
            file << tablica;
            file.close();

            cout << "Dodano do pliku" << filename << '\n';
            break;
                }
        case 6: {
            char filename[32];
            cout << "Podaj nazwe pliku: ";
            cin >> filename;

            ifstream file(filename);
            if (!file.good()) {
                cout << "Bład lub plik nie istnieje";
                break;
            }
            file >> tablica;
            cout << "Pobrano pracowników " << filename << '\n';
            file.close();
                }
        }
        getch();
    }

    return 0;
}