<repo_name>AlexeyMagdich/OOP<file_sep>/Person.h
﻿// основной модуль, содержит класс 'Person', который в свою очередь содержит остальные классы

#pragma once

#include "stdafx.h"
#include "Name.h"
#include "Address.h"

// 'дефайны' для перечисления 'Sex'

#define M Person::Sex::MALE
#define F Person::Sex::FEMALE
#define U Person::Sex::UNKNOWN

class Person
{
public:
	enum Sex { MALE, FEMALE, UNKNOWN };
	static int size;                                  
													  
private:		
	const int number;
	Name      name;
	Address   address;
	Sex       sex;	
							        
public: 											  
	Person();                                    
	Person(std::string fn, std::string ln);              
	Person(std::string fn, std::string ln, std::string c, std::string r);
	Person(const Name& n, const Address& a, Sex s);
	Person(const Name* n, const Address* a, Sex s);
	Person(const Person& p);                     
	~Person() { size--; };               
						
	void SetName(std::string fn, std::string ln);
	void SetName(const Name& n);
	void SetAddress(std::string c, std::string r);
	void SetAddress(const Address& a);   
	void SetSex(Sex s);			         
	void PrintBasicInfo() const;     
	void PrintSex() const;
	static void ShowSize();              
	Person& operator=(const Person& p);  
};<file_sep>/Performer.cpp
﻿#include "stdafx.h"
#include "Performer.h"

/* ----- КОНСТРУКТОРЫ ----- */

Performer::Performer()
	: Firstdate(), Lastdate(), Jobtitle("")
{ };

Performer::Performer(const Date& fd, const Date& ld, const std::string j)
	: IsOk(CheckPerformer(fd, ld, j)), Firstdate(fd), Lastdate(ld), Jobtitle(j)
{ };

Performer::Performer(const Performer& p)
	: IsOk(CheckPerformer(p.Firstdate, p.Lastdate, p.Jobtitle)), Firstdate(p.Firstdate), Lastdate(p.Lastdate), Jobtitle(p.Jobtitle)
{ };

/* ----- МЕТОДЫ ----- */

void Performer::SetFirstdate(const Date d)
{
	Firstdate = d;
};

void Performer::SetLastdate(const Date d)
{
	Lastdate = d;
};

void Performer::SetJobtitle(std::string j)
{
	Jobtitle = j;
};

void Performer::SetPerformInfo(const Date& fd, const Date& ld, const std::string j)
{
	Firstdate = fd;
	Lastdate = ld;
	Jobtitle = j;
};

void Performer::PrintPerformInfo()
{
	std::cout << "Дата устройства: " << Firstdate.dd << "." << Firstdate.mm << "." << Firstdate.yyyy << std::endl;
	std::cout << "Дата увольнения: " << Lastdate.dd  << "." << Lastdate.mm  << "." << Lastdate.yyyy  << std::endl;
	std::cout << "Специализация:   " << Jobtitle     << std::endl;
};<file_sep>/Person.cpp
﻿#include "stdafx.h"
#include "Person.h"

int Person::size = 0;                              // инициализация статического свойства

/* ----- КОНСТРУКТОРЫ ------ */

Person::Person() 
	 : name(), address(), sex(UNKNOWN), number(size++)
{ };

Person::Person(std::string fn, std::string ln) 
	: name(fn, ln), address("", ""), sex(UNKNOWN), number(size++)
{ };

Person::Person(std::string fn, std::string ln, std::string c, std::string r)
	: name(fn, ln), address(c, r), sex(UNKNOWN), number(size++)
{ };

Person::Person(const Person& p) 
	: name(p.name), address(p.address), sex(UNKNOWN), number(size++)
{ };

Person::Person(const Name& n, const Address& a, Sex s)
	: name(n), address(a), sex(s), number(size++)
{ };

Person::Person(const Name* n, const Address* a, Sex s)
	: name(*n), address(*a), sex(s), number(size++)
{ };

/* ----- МЕТОДЫ ----- */

void Person::SetName(std::string fn, std::string ln)
{
	this->name.SetName(fn, ln);
	this->sex = UNKNOWN;
};

void Person::SetName(const Name& n)
{
	this->name.SetName(n);
};

void Person::SetAddress(std::string c, std::string r)
{
	this->address.SetAddress(c, r);
};

void Person::SetAddress(const Address& a)
{
	this->address.SetAddress(a);
};

void Person::SetSex(Sex s)
{
	this->sex = s;
};

void Person::PrintSex() const
{
	std::cout << "Пол:     ";
	if (sex == MALE)
		std::cout << "МУЖ";
	else if (sex == FEMALE)
		std::cout << "ЖЕН";
	std::cout << std::endl;
};

void Person::PrintBasicInfo() const
{
	this->name.PrintName();
	this->PrintSex();
	if (this->address.IsEmptyAddress() == false)
	{
		this->address.PrintAddress();
	};
	std::cout << std::endl;
};

void Person::ShowSize()
{
	std::cout << "Размер = " << size << std::endl;
};

Person& Person::operator=(const Person& p)
{
	this->name    = p.name;
	this->address = p.address;
	this->sex     = p.sex;

	return *this;
};<file_sep>/OOP.cpp
﻿#include "stdafx.h"
#include "Employee.h"
#include "Error.h"

int main()
{
	setlocale(LC_ALL, "Russian");

	try
	{
		Employee e1;

		e1.SetName("Лёша", "Магдич");
		e1.SetAddress("Беларусь", "Минск");
		e1.SetSex(M);
		e1.SetFirstdate(*(new Performer::Date(1,7, 2013)));
		e1.SetLastdate(*(new Performer::Date(9, 7, 2016)));
		e1.SetJobtitle("Программист");

		e1.PrintBasicInfo();
		e1.PrintPerformInfo();

		Employee e2(
			2,
			(new Name("Артём", "Синица")),
			(new Address("Беларусь", "Минск")),
			M,
			*(new Performer::Date(16, 11, 2014)),
			*(new Performer::Date(17, 3, 2016)),
			"Разработчик"
			);

		std::cout << std::endl << " ---------- " << std::endl << std::endl;

		e2.PrintBasicInfo();
		e2.PrintPerformInfo();

		std::cout << std::endl;
	}
	catch (Error e)
	{
		std::cout << "ОШИБКА #" << e.code << " - " << e.message << std::endl;
	};

    return 0;
};


<file_sep>/Name.h
﻿class Name
{
private:
    std::string Firstname;
    std::string Lastname;

public:
	Name();
	Name(std::string fn, std::string ln);
	Name(const Name& n);
	~Name() { };

	void SetName(std::string fn, std::string ln);
	void SetName(const Name& n);
	void PrintName() const;

private:
	bool IsOk;                                      // необходима для метода CheckName (инициализируется этим методом)
	bool CheckName(std::string fn, std::string ln); // проверяет аргмента на наличие ошибок, если успех - генерирует исключение
};<file_sep>/Name.cpp
﻿#include "stdafx.h"
#include "Name.h"

/* ----- CONSTRUCTORS ----- */

Name::Name()
	: Firstname(""), Lastname("")
{ };

// перед инициализацией при создании объекта, в первую очередь инициализируется переменная IsOk,
// причём её значение будет true, если в методе CheckName() или CheckAddress() не будут обнаружены
// критические ошибки, которые повлекут за собой генерацию исключения (см. модуль Error)

Name::Name(std::string fn, std::string ln)
	: IsOk(CheckName(fn, ln)), Firstname(fn), Lastname(ln)
{ };

Name::Name(const Name& n)
	: IsOk(CheckName(n.Firstname, n.Lastname)), Firstname(n.Firstname), Lastname(n.Lastname)
{ };

/* ----- МЕТОДЫ ----- */

void Name::SetName(std::string fn, std::string ln)
{
	Firstname = fn;
	Lastname = ln;
};
void Name::SetName(const Name& n)
{
	Firstname = n.Firstname;
	Lastname = n.Lastname;
};

void Name::PrintName() const
{
	std::cout << "Имя:     " << Firstname << std::endl;
	std::cout << "Фамилия: " << Lastname << std::endl;
};<file_sep>/Error.h
﻿// модуль содержит в себе класс 'Error', необходимый для генерации исключений, где
// исключение порождает объект класса 'Error', причём объект конструируется в момент
// генерации (throw). Объект ошибки включает в себя код (отсчёт от ERROR_CODE == 0) ошибки
// информативное сообщение (причина), а также указатель на "аварийный" объект

#define ERROR_CODE          0
#define INCORRECT_SYMBOLS   "0123456789"
#define ERROR_MSG_COUNTRY   "Некорретное название страны"
#define ERROR_MSG_REGION    "Некорретное название региона"
#define ERROR_MSG_FIRSTNAME "Неккоретное имя"
#define ERROR_MSG_LASTNAME  "<NAME>"
#define ERROR_MSG_DAY       "Некорректная дата (число)"
#define ERROR_MSG_MONTH     "Некорреткная дата (месяц)"
#define ERROR_MSG_YEAR      "Некорректная дата (год)"
#define ERROR_MSG_JOBTITLE  "Некорректное название работы"

// сообщаем о том, что будут использваться классы 'Address' и 'Name'

class Address;
class Name;
class Performer;

class Error
{
public:
	const static int ERROR_COUNTRY   = ERROR_CODE + 1;
	const static int ERROR_REGION    = ERROR_CODE + 2;
	const static int ERROR_FIRSTNAME = ERROR_CODE + 3;
	const static int ERROR_LASTNAME  = ERROR_CODE + 4;
	const static int ERROR_DAY       = ERROR_CODE + 5;
	const static int ERROR_MONTH     = ERROR_CODE + 6;
	const static int ERROR_YEAR      = ERROR_CODE + 7;
	const static int ERROR_JOBTITLE  = ERROR_CODE + 8;

	int code;
	std::string message;
	const Address* erraddress;
	const Name* errname;
	const Performer* errperformer;

	Error(int c, std::string msg, const Address* ea);
	Error(int c, std::string msg, const Name* en);
	Error(int c, std::string msg, const Performer* ep);
};<file_sep>/Employee.cpp
﻿#include "stdafx.h"
#include "Employee.h"

/* ----- КОНСТРУКТОРЫ ----- */

Employee::Employee(const Name* n, const Address* a, Sex s) 
	: Person::Person(n, a, s)
{ };

Employee::Employee(const Employee& e) 
	: Person::Person(e)
{ };

Employee::Employee(
	int id,
	const Name* n,
	const Address* a,
	Sex s,
	const Performer::Date& fd,
	const Performer::Date& ld,
	std::string j)
	: ID(id), Person(n, a, s), Performer(fd, ld, j)
{ };

/* ----- МЕТОДЫ ----- */

void Employee::SetID(int id)
{
	this->ID = id;
};

void Employee::SetFirstdate(const Date d)
{
	Performer::SetFirstdate(d);
};

void Employee::SetLastdate(const Date d)
{
	Performer::SetLastdate(d);
};

void Employee::SetJobtitle(std::string j)
{
	Performer::SetJobtitle(j);
};

void Employee::PrintPerformInfo()
{
	std::cout << "ID:              " << size << std::endl;
	this->Performer::PrintPerformInfo();
};<file_sep>/Employee.h
﻿#pragma once
#include "Person.h"
#include "Performer.h"

class Employee : public Person, protected Performer
{
public:
	 Employee() { };
	 Employee(const Name* n, const Address* a, Sex s);
	 Employee(const Employee& e);
	 Employee(
		 int id,
		 const Name* n,
		 const Address* a,
		 Sex s,
		 const Performer::Date& fd,
		 const Performer::Date& ld,
		 std::string j);
	~Employee() { };
	
private:
	int ID;

public:
	void SetID(int id);
	void SetFirstdate(const Date d);
	void SetLastdate(const Date d);
	void SetJobtitle(std::string j);
	void PrintPerformInfo();
};
<file_sep>/Address.cpp
﻿#include "stdafx.h"
#include "Address.h"

/* ----- КОНСТРУКТОРЫ ----- */

Address::Address()
	: Country(""), Region("")
{ };

Address::Address(std::string c, std::string r)
	: IsOk(CheckAddress(c, r)), Country(c), Region(r)
{ };

Address::Address(const Address& a)
	: IsOk(CheckAddress(a.Country, a.Region)), Country(a.Country), Region(a.Region)
{ };

/* ----- МЕТОДЫ ----- */

void Address::SetAddress(std::string c, std::string r)
{
	Country = c;
	Region = r;
};

void Address::SetAddress(const Address& a)
{
	SetAddress(a.Country, a.Region);
};

void Address::PrintAddress() const
{
	std::cout << "Страна:  " << this->Country << std::endl;
	std::cout << "Город:   " << this->Region << std::endl;
};

bool Address::IsEmptyAddress() const
{
	return (Country.empty() || Region.empty()) ? true : false;
};<file_sep>/Error.cpp
﻿#include "stdafx.h"
#include "Error.h"
#include "Person.h"
#include "Performer.h"

/* ----- КОНСТРУКТОРЫ ------ */

Error::Error(int c, std::string msg, const Address* ea)
	: code(c), erraddress(ea)
{
	this->message = msg;
};

Error::Error(int c, std::string msg, const Name* en)
	: code(c), errname(en)
{
	this->message = msg;
};

Error::Error(int c, std::string msg, const Performer* ep)
	: code(c), errperformer(ep)
{
	this->message = msg;
};

/* ------ МЕТОДЫ ------- */

bool Name::CheckName(std::string fn, std::string ln)
{
	bool rc = true;

	for (int i = 0; i < 10; i++)
	{
		if (fn.find(INCORRECT_SYMBOLS[i]) != std::string ::npos) throw Error(Error::ERROR_FIRSTNAME, ERROR_MSG_FIRSTNAME, this);
		if (ln.find(INCORRECT_SYMBOLS[i]) != std::string ::npos) throw Error(Error::ERROR_LASTNAME, ERROR_MSG_LASTNAME, this);
	};

	return rc;
};

bool Address::CheckAddress(std::string c, std::string  r)
{
	bool rc = true;

	for (int i = 0; i < 10; i++)
	{
		if (c.find(INCORRECT_SYMBOLS[i]) != std::string ::npos) throw Error(Error::ERROR_COUNTRY, ERROR_MSG_COUNTRY, this);
		if (r.find(INCORRECT_SYMBOLS[i]) != std::string ::npos) throw Error(Error::ERROR_REGION, ERROR_MSG_REGION, this);
	};

	return rc;
};

bool Performer::CheckPerformer(const Date& fd, const Date& ld, const std::string j)
{
	bool rc = true;

	if (fd.dd < 0 || fd.dd > 31 || ld.dd < 0 || ld.dd > 31)
	{
		throw Error(Error::ERROR_DAY, ERROR_MSG_DAY, this);
	}
	else if (fd.mm < 0 || fd.mm > 12 || ld.mm < 0 || ld.mm > 12)
	{
		throw Error(Error::ERROR_MONTH, ERROR_MSG_MONTH, this);
	}
	else if (fd.yyyy < 1940 || fd.yyyy > 2016 || ld.yyyy < 1940 || ld.yyyy > 2016)
	{	
		throw Error(Error::ERROR_YEAR, ERROR_MSG_YEAR, this);
	}
	else
	{
		for (int i = 0; i < 10; i++)
		{
			if (j.find(INCORRECT_SYMBOLS[i]) != std::string::npos) throw Error(Error::ERROR_JOBTITLE, ERROR_MSG_JOBTITLE, this);
		};
	};

	return rc;
};

<file_sep>/Address.h
﻿// модуль содержит в себе вспомогательную информацию об объекте
// в модуле определён класс Address с набором необходимых конструкторов методов и свойств
// наибольший интерес - bool-переменная IsOk и метод CheckAddress()

class Address
{
private:
	std::string Country;
	std::string Region;

public:
	Address();
	Address(std::string c, std::string r);
	Address(const Address& a);
	~Address() { };

	void SetAddress(std::string c, std::string r);
	void SetAddress(const Address& a);
	void PrintAddress() const;
	bool IsEmptyAddress() const;

private:
	bool IsOk;                                        // необходима для метода CheckAddress (инициализируется этим методом)
	bool CheckAddress(std::string c, std::string r);  // проверяет аргмента на наличие ошибок, если успех - генерирует исключение
};<file_sep>/Performer.h
﻿class Performer
{
public:
	struct Date
	{
		int dd;
		int mm;
		int yyyy;

		Date(int dd = 0, int mm = 0, int yyyy = 0)
		{
			this->dd = dd;
			this->mm = mm;
			this->yyyy = yyyy;
		};

		Date(const Date& d)
		{
			this->dd = d.dd;
			this->mm = d.mm;
			this->yyyy = d.yyyy;
		};
	};

private:
	Date Firstdate;                   // первый день работы
	Date Lastdate;                    // последний день работы
	std::string Jobtitle;             // должность

protected:
	void SetFirstdate(const Date d);
	void SetLastdate(const Date d);
	void SetJobtitle(std::string j = "");

public:
	 Performer();
	 Performer(const Date& fd, const Date& ld, const std::string j);
	 Performer(const Performer& p);
	~Performer() { };

private:
	bool IsOk;
	bool CheckPerformer(const Date& fd, const Date& ld, const std::string j);

public:
	void SetPerformInfo(const Date& fd, const Date& ld, const std::string j);
	void PrintPerformInfo();
};<file_sep>/README.md
Это репозиторий, хранящий в себе мою хронологию изучения объектно-ориентированного программирования на основе языка C++, а также процесс освоения Git'a и GitHub'a.
