Re: 1 i 2

[slaythemall]

*PRACOWNIK
*
#pragma once
#include <string.h>
#include <iostream>
#include "Data.h"
#include "Napis.h"

using namespace std;

class Pracownik
{
        Napis m_Imie;
        Napis m_Nazwisko;
        Data m_DataUrodzenia;
        const int m_nIDZatrudnienia;
public:
        Pracownik(const char* im = "", const char * naz = "", int dzien = 1, int
miesiac = 1, int rok = 2000);
        Pracownik(const Pracownik & wzor);
        ~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;
        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)
        {
                wy << p.m_Imie;
                wy.width(20);
                wy << p.m_Nazwisko;
                wy.width(20);
                wy << p.m_DataUrodzenia;;
                return wy;
        };
        friend istream & operator >> (istream & we, Pracownik & p)
        {
                we >> p.m_Imie >> p.m_Nazwisko >> p.m_DataUrodzenia;
                return we;
        };
};

#include "Pracownik.h"

int counter = 0;

Pracownik::Pracownik(const char * im, const char * naz, int dzien, int
miesiac, int rok) :    //konstruktor domyślny
        m_Imie(im),
        m_Nazwisko(naz),
        m_DataUrodzenia(dzien, miesiac, rok),
        m_nIDZatrudnienia(counter + 1)
{
        counter++;
}

Pracownik::Pracownik(const Pracownik & wzor)
:m_DataUrodzenia(wzor.m_DataUrodzenia),
m_nIDZatrudnienia(wzor.m_nIDZatrudnienia), m_Imie(wzor.m_Imie),
m_Nazwisko(m_Nazwisko)                                                          
                                                                                
                                        //konstruktor kopiujacy
{
}


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

void Pracownik::Wpisz()
{
        char Imie[25], Nazwisko[30];
        cout << "Podaj imie\n";
        cin >> Imie;
        cout << "Podaj nazwisko\n";
        cin >> Nazwisko;
        m_Imie.Ustaw(Imie);
        m_Nazwisko.Ustaw(Nazwisko);
        m_DataUrodzenia.Wpisz();
}

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
{
        int sprNazwisko = SprawdzNazwisko(wzorzec.Nazwisko());
        if (sprNazwisko != 0)
                return sprNazwisko;
        int sprImie = SprawdzImie(wzorzec.Imie());
        if (sprImie != 0)
                return sprImie;
        int sprData = m_DataUrodzenia.Porownaj(wzorzec.m_DataUrodzenia);
        if (sprData != 0)
                return -sprData;
        return 0;
}


Pracownik & Pracownik::operator=(const Pracownik & wzor)                        
                                        //operator
przypisania
{
        if (this != &wzor)
        {

                this->m_Imie = wzor.m_Imie;
                this->m_Nazwisko = wzor.m_Nazwisko;
                this->m_DataUrodzenia = Data(wzor.m_DataUrodzenia);
        }
        return *this;
}

bool Pracownik::operator==(const Pracownik & wzor) const                        
                                        //operator
porownania
{
        if (m_Imie == wzor.m_Imie &&
                m_Nazwisko == wzor.m_Nazwisko &&
                m_DataUrodzenia.Porownaj(wzor.m_DataUrodzenia) == 0 &&
                m_nIDZatrudnienia == wzor.m_nIDZatrudnienia)
                return true;
        else return false;
}


*NAPIS*

#pragma once
#define _CRT_SECURE_NO_WARNINGS

#include <iostream>

using namespace std;

class Napis
{
public:
        Napis(const char* nap = "");
        Napis(const Napis& wzor);
        ~Napis(void);
private:
        char *m_pszNapis;
        int m_nDl; //ilosc znakow m_psz;
public:
        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)
        {
                wy << p.Zwroc();
                return wy;
        };
        friend istream & operator >> (istream & we, Napis & p)
        {
                char *nowy = new char[100];
                we >> nowy;
                p.Ustaw(nowy);
                return we;
        };



};

#include "Napis.h"

using namespace std;

Napis::Napis(const char* nap)
{
        this->m_nDl = strlen(nap) + 1; //+1 bo koniec lancucha
        this->m_pszNapis = new char[this->m_nDl]; //pamiec dla nowego char o
len=m_nDl
        strcpy_s(this->m_pszNapis, this->m_nDl, nap);
}

Napis::~Napis(void)
{
        delete[](this->m_pszNapis); //zwalnianie pamieci
        this->m_pszNapis = 0; //pusty lancuch
}

Napis::Napis(const Napis& wzor) {
        this->m_nDl = strlen(wzor.m_pszNapis) + 1;
        this->m_pszNapis = new char[this->m_nDl];
        strcpy_s(this->m_pszNapis, this->m_nDl, wzor.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 << this->m_pszNapis << " ";
}

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

int Napis::SprawdzNapis(const char* por_napis) const
{
        int check;
        if (strcmp(this->m_pszNapis, por_napis) == 1) {
                check = 1;
        }
        else if (strcmp(this->m_pszNapis, por_napis) == 0) {
                check = 0;
        }
        else {
                check = -1;
        }
        return check;
}

Napis & Napis::operator= (const Napis & wzor) {  //przeladowanie operatora
przypisania???

        if (this != &wzor)                                                      
                                        //spr czy this !=wzor
        {
                delete[] this->m_pszNapis;                                      
                                //zniszczyc obiekt                              
                        
                this->m_nDl = strlen(wzor.m_pszNapis) + 1;                      
                //częsc konstruktorowa                                  
jednym z pol skl jest wskaznik, wiec lepiej przeładowac, zeby działał tak,
jak potrzebujemy
                this->m_pszNapis = new char[strlen(wzor.m_pszNapis) + 1];
                strcpy_s(this->m_pszNapis, this->m_nDl, wzor.m_pszNapis);
        }
        return *this;

}

bool Napis:: operator== (const Napis & wzor) const { //przeladowanie
operatora porownania ??

        if (this->m_pszNapis == wzor.m_pszNapis && this->m_nDl == wzor.m_nDl) {
                return true;
        }
        else
                return false;
}

*DATA*

#pragma once
#include<iostream>

using namespace std;

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

        friend ostream& operator<<(ostream & wy, const Data & d)
        {
                //wy << d.Dzien() << " " << d.Miesiac() << " " << d.Rok(); 
                wy << d.Dzien();
                wy.width(5);
                wy << d.Miesiac();
                wy.width(5);
                wy << d.Rok();
                return wy;
        };
        friend istream& operator >> (istream & we, Data & d)
        {
                we >> d.m_nDzien >> d.m_nMiesiac >> d.m_nRok;

                return we;
                //      d.Koryguj();
        };

};

#include "Data.h"
using namespace std;

Data::Data(int d, int m, int r)
{
        Ustaw(d, m, r);
}

Data::~Data(void)
{
}

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

int Data::Dzien(void) const
{
        return m_nDzien;
}

int Data::Miesiac(void) const
{
        return m_nMiesiac;
}

int Data::Rok(void) const
{
        return m_nRok;
}

void Data::Wypisz(void) const
{
        cout << m_nDzien << "-" << m_nMiesiac << "-" << m_nRok << endl;
}

void Data::Wpisz(void)
{
        int dz, ms, rk;
        cout << "Podaj dzien:"; cin >> dz;
        cout << "Podaj miesiac:"; cin >> ms;
        cout << "Podaj rok:"; cin >> rk;
        Ustaw(dz, ms, rk);
}

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

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



&lt;b>TABLICA*

#pragma once
#include "Pracownik.h"
#include "Data.h"
#include <fstream>
#include <string>

class TablicaPracownikow
{
        Pracownik m_pTablica[20];
        int m_nLiczbaPracownikow;
public:
        TablicaPracownikow(void);
        ~TablicaPracownikow(void);
        void Dodaj(const Pracownik & p);
        void Usun(const Pracownik wzorzec);
        void WypiszPracownikow() const;
        const Pracownik* Szukaj(const char* nazwisko, const char* imie) const;

        void zapisz();
        void wczytaj();
};

#include "TablicaPracownikow.h"



TablicaPracownikow::TablicaPracownikow(void):m_nLiczbaPracownikow(0)
{
}


TablicaPracownikow::~TablicaPracownikow(void)
{
}

void TablicaPracownikow::Dodaj(const Pracownik & p)
{
        if (m_nLiczbaPracownikow == 20)
        {
                cout << "Brak miejsca na dodanie nowego pracownika\n";
                return;
        }
        for (int i = 0; i < m_nLiczbaPracownikow; i++)
        {
                if (m_pTablica[i].Porownaj(p) == 0)
                {
                        return;
                }
        }
        m_pTablica[m_nLiczbaPracownikow++] = p;
}

void TablicaPracownikow::Usun(const Pracownik wzorzec) {

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

void TablicaPracownikow::WypiszPracownikow() const {
        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 ((strcmp(m_pTablica[i].Imie(), imie) == 0) &&
(strcmp(m_pTablica[i].Nazwisko(), nazwisko) == 0))
                {
                        return &(m_pTablica[i]);
                }
        }
        return NULL;
}

void TablicaPracownikow::zapisz() {
        fstream plik;
        plik.open("plik.txt");
        
        for (int i = 0; i < this->m_nLiczbaPracownikow; i++) {
                plik << this->m_pTablica[i];
        }
        plik.close();
}

void TablicaPracownikow::wczytaj() {
        fstream plik;
        plik.open("plik.txt", ios::in | ios::out);
        if (plik.good()) {
                while (!plik.eof()) {
                        Pracownik pracownik;
                        plik >> pracownik;
                        this->Dodaj(pracownik);
                }
                plik.close();
        }
        
}

*
MAIN*

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include "TablicaPracownikow.h"
#include "Pracownik.h"
#include "Data.h"
#include "Napis.h"
#include <stdio.h>

using namespace std;

int main()
{
        char znak;
        TablicaPracownikow tablicaPracownikow;
        while (1)
        {
                cout << "Operacje:\n"
                        << "d - Dodaj pracownika\n"
                        << "u - Usun pracownika\n"
                        << "w - Wypisz pracownikow\n"
                        << "s - Wyszukaj pracownika\n"
                        << "z - Zapisz do pliku\n"
                        << "p - Wypisz z pliku\n"
                        << "q - Wyjdz\n";
                        

                cin >> znak;
                switch (znak)
                {
                case 'd':
                {
                        Pracownik pracownik;
                        pracownik.Wpisz();
                        tablicaPracownikow.Dodaj(pracownik);
                        break;
                }
                case 'u':
                {
                        Pracownik pracownik;
                        pracownik.Wpisz();
                        tablicaPracownikow.Usun(pracownik);
                        break;
                }
                case 'w':
                {
                        tablicaPracownikow.WypiszPracownikow();
                        break;
                }
                case 's':
                {
                        char imie[40], nazwisko[40];
                        cout << "Podaj imie szukanego pracownika\n";
                        cin >> imie;
                        cout << "Podaj nazwisko szukanego pracownika\n";
                        cin >> nazwisko;
                        const Pracownik* pracownik;
                        pracownik = tablicaPracownikow.Szukaj(nazwisko, imie);
                        if (pracownik != NULL)
                        {
                                (*pracownik).Wypisz();
                        }
                        else
                        {
                                cout << "Nie ma takiego pracownika\n";
                        }

                        break;
                }
                case 'z':
                {
                        tablicaPracownikow.zapisz();
                        break;
                }

                case 'p':
                {
                        tablicaPracownikow.wczytaj();
                        break;
                }
                case 'q':
                        return 0;
                default:
                        break;
                }
        }
}










--
View this message in context: 
http://octave.1599824.n4.nabble.com/1-i-2-tp4677888p4681388.html
Sent from the Octave - General mailing list archive at Nabble.com.