main.cpp

#include <iostream>

#include <vector>

#include "Point.h"

#include "Unit.h"

// === Композиция (является частью)

//Часть(член) является частью объекта(класса).

//Часть(член) может принадлежать только одному объекту(классу) за раз.

//Часть(член) существует, управляемая объектом(классом).

//Часть(член) не знает о существовании объекта(класса).

//int main()

//{

// std::cout << "Enter a Unit name: ";

// std::string name;

// std::cin >> name;

//

// Unit unit(name, Point(3, 5));

//

// int x{}, y{};

//

// while (true)

// {

// std::cout << unit;

//

// std::cout << "Enter a new X coord: ";

// std::cin >> x;

//

// std::cout << "Enter a new Y coord: ";

// std::cin >> y;

//

// unit.moveTo(x, y);

// }

//

// return 0;

//}

// === Агрегация (имеет)

//Часть(член) является частью целого(класса).

//Часть(член) может принадлежать более чем одному целому(классу) за раз.

//Часть(член) существует, не управляемая целым(классом).

//Часть(член) не знает о существовании целого(класса).

//class Worker

//{

//private:

// std::string _name;

//public:

// Worker(std::string name): _name{name} {}

// std::string getName() { return _name; }

//};

//

//class Department

//{

//private:

// Worker* _worker;

//public:

// Department(Worker* worker = nullptr):

// _worker{worker} {}

//};

//

//int main()

//{

// Worker* worker = new Worker("Brus");

//

// {

// Department dep(worker);

// }

//

// std::cout << worker->getName() << "\n\n";

//

// delete worker;

//

// return 0;

//}

// === Сравнение композиции и агрегации

//В композиции :

//Используются обычные переменные - члены.

//Используются указатели, если класс реализовывает собственное управление памятью(происходит динамическое выделение / освобождение памяти).

//Класс ответственный за создание / уничтожение своих частей.

//

//В агрегации :

//Используются указатели / ссылки, которые указывают / ссылаются на части вне класса.

//Класс не несёт ответственности за создание / уничтожение своих частей.

// === Ассоциация (использует)

//Первый объект(член) не связан со вторым объектом(классом).

//Первый объект(член) может принадлежать одновременно сразу нескольким объектам(классам).

//Первый объект(член) существует, не управляемый вторым объектом(классом).

//Первый объект(член) может знать или не знать о существовании второго объекта(класса).

//

//class Doctor;

//

//class Patient

//{

//private:

// std::string _name;

// std::vector<Doctor*> _doctors;

//

// void addDoctor(Doctor* doc)

// {

// _doctors.push_back(doc);

// }

//

//public:

// Patient(std::string name) : _name(name) {}

//

// std::string getName() const { return _name; }

//

// friend std::ostream& operator<<(std::ostream& out, const Patient& pat);

// friend class Doctor;

//};

//

//class Doctor

//{

//private:

// std::string _name;

// std::vector<Patient*> _patients;

//

//public:

// Doctor(std::string name) : _name(name) {}

//

// void addPatient(Patient* pat)

// {

// _patients.push_back(pat);

//

// pat->addDoctor(this);

// }

//

// std::string getName() const { return _name; }

//

// friend std::ostream& operator<<(std::ostream& out, const Doctor& doc);

//};

//

//std::ostream& operator<<(std::ostream& out, const Patient& pat)

//{

// unsigned int length = pat._doctors.size();

// if (length == 0)

// {

// out << pat.getName() << " has no doctors right now";

// return out;

// }

//

// out << pat._name << " is seeing doctors: ";

// for (unsigned int i = 0; i < length; ++i)

// out << pat._doctors[i]->getName() << ' ';

//

// return out;

//}

//

//std::ostream& operator<<(std::ostream& out, const Doctor& doc)

//{

// unsigned int length = doc._patients.size();

// if (length == 0)

// {

// out << doc._name << " has no patients right now";

// return out;

// }

//

// out << doc._name << " is seeing patients: ";

// for (unsigned int i = 0; i < length; ++i)

// out << doc._patients[i]->getName() << ' ';

//

// return out;

//}

//

//

//int main()

//{

// Patient* p1 = new Patient("Brus");

// Patient* p2 = new Patient("Chack");

// Patient* p3 = new Patient("Arnold");

//

// Doctor* d1 = new Doctor("John");

// Doctor* d2 = new Doctor("Tom");

//

// d1->addPatient(p1);

//

// d2->addPatient(p1);

// d2->addPatient(p3);

//

// std::cout << *d1 << '\n';

// std::cout << *d2 << '\n';

// std::cout << *p1 << '\n';

// std::cout << *p2 << '\n';

// std::cout << *p3 << '\n';

//

// delete p1;

// delete p2;

// delete p3;

//

// delete d1;

// delete d2;

//

// return 0;

//}

//Свойства Композиция Агрегация Ассоциация

//---------- -------- ---------- ----------

//Отношения Части - целое Части - целое Объекты не связаны между собой

//

//Члены могут

// принадлежать сразу

// нескольким классам Нет Да Да

//

//Существование членов

// управляется классами Да Нет Нет

//

//Вид отношений Однонаправленные Однонаправленные Однонаправленные или Двунаправленные

//

//Тип отношений «Часть чего - то» «Имеет» «Использует»

// === Наследование (является)

class Human

{

public:

std::string _name;

int _age;

Human(std::string name = "", int age = 0):

_name{name}, _age{age} {}

std::string getName() { return _name; }

int getAge() { return _age; }

};

class Player: public Human

{

public:

int _average;

int _points;

Player(int average = 0, int points = 0):

_average{average}, _points{points} {}

};

class Employee : public Human

{

public:

int _id;

int _salary;

Employee(int id = 0, int salary = 0):

_id{id}, _salary{salary} {}

void printInfo()

{

std::cout << _id << ". " << _name << " = " << _salary << "\n\n";

}

};

class Supervisor: public Employee

{

public:

int _items[5];

Supervisor() {}

};

int main()

{

Player p;

p._name = "Chack";

std::cout << p.getName();

std::cout << "\n\n";

Employee e(12, 20000);

e._name = "Tom";

e.printInfo();

return 0;

}

Point.h

#pragma once

#ifndef POINT_H

#define POINT_H

class Point

{

private:

int _x;

int _y;

public:

Point() : _x{}, _y{} {}

Point(int x, int y): _x{x}, _y{y} {}

void set(int x, int y)

{

_x = x;

_y = y;

}

friend std::ostream& operator<<(std::ostream& out, const Point& point);

};

std::ostream& operator<<(std::ostream& out, const Point& point)

{

out << "(" << point._x << ", " << point._y << ")\n";

return out;

}

#endif

Unit.h

#pragma once

#ifndef UNIT_H

#define UNIT_H

#include <string>

#include "Point.h"

class Unit

{

private:

std::string _name;

Point _location;

public:

Unit(const std::string& name, const Point& location):

_name{name}, _location{location} {}

void moveTo(int x, int y)

{

_location.set(x, y);

}

friend std::ostream& operator<<(std::ostream& out, const Unit& unit);

};

std::ostream& operator<<(std::ostream& out, const Unit& unit)

{

out << unit._name << " located at " << unit._location << "\n";

return out;

}

#endif