second

Lesson_9/SmartPointer/Car.cpp

@@ -0,0 +1,15 @@
+
+#include "stdafx.h"
+#include "Car.h"
+
+Car::Car(const std::string& color)
+    : color_(color)
+{
+    std::cout << color_ << " car has been created\n";
+}
+Car::~Car() 
+{ std::cout << color_ << " car has been destroied\n"; }
+void Car::Drive()
+{
+    std::cout << ": "<< color_ << " car in move\n\n";
+}

Lesson_9/SmartPointer/Car.h

@@ -0,0 +1,14 @@
+#pragma once
+
+
+class Car
+{
+public:
+    Car(const std::string& color);
+    ~Car();
+    void Drive();
+    void GetCarColor();
+private:
+    std::string color_;
+};
+

Lesson_9/SmartPointer/CarFactory.cpp

@@ -0,0 +1,9 @@
+
+#include "stdafx.h"
+#include "CarFactory.h"
+#include "Car.h"
+
+std::unique_ptr<Car> CarFactory::BuildCar(const std::string& color)
+{
+    return std::unique_ptr<Car>(new Car(color));
+}

Lesson_9/SmartPointer/CarFactory.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "Car.h"
+
+class CarFactory
+{
+public:
+    std::unique_ptr<Car> BuildCar(const std::string& color);
+};
+

Lesson_9/SmartPointer/Driver.cpp

@@ -0,0 +1,106 @@
+
+#include "stdafx.h"
+#include "Driver.h"
+#include "DriverManager.h"
+#include "Car.h"
+#include "CarFactory.h"
+#include "autoschool.h"
+
+
+Driver::Driver(const std::string& name, std::shared_ptr<CarFactory> factory)
+    : factory_(factory)
+    , name_(name)
+{}
+void Driver::BuyCar(const std::string& color)
+{
+    car_ = factory_->BuildCar(color);
+    std::cout << "I bought a new car\n";
+    myManager_->GetPtrDriverWithCar(this);
+}
+
+void Driver::cleverGo()
+{
+    //int whatToDo = rand() % 3 + 1;//dont work with threads
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    std::uniform_int_distribution<> distrib(1, 2);
+    int random_number = distrib(gen);
+
+    if (car_ != nullptr)    //if driver has car - drive
+    {
+        std::cout << name_ << " have a car";
+        car_->Drive();
+        std::this_thread::sleep_for(std::chrono::milliseconds(2000));
+    }
+    else
+    {
+        std::cout << name_ << "'ll go on foot.... BUT....";
+        switch (random_number)
+        {
+            case 1: //buy a new car
+            {
+                this->BuyCar(this->SetCarColor());
+                std::cout << name_ << " have a car";
+                car_->Drive();
+                break;
+            }
+            case 2://try to buy used car
+            {
+                try
+                {
+                    Driver* p_driverWithCar = myManager_->GivePtrDriverWithCar();
+                    this->BuyUsedCar(p_driverWithCar);
+                    //this->BuyUsedCar(myManager_->GivePtrDriverWithCar()); //same as the two lines above
+                }
+                catch (const std::runtime_error& e)
+                {
+                    std::cout << e.what();
+                }
+                break;
+            }
+
+        }
+    }
+}
+void Driver::BuyUsedCar(Driver* d)
+{
+     car_ = d->SellCar();
+     std::cout << "I bought a used car\n";
+     myManager_->GetPtrDriverWithCar(this);
+}
+std::unique_ptr<Car> Driver::SellCar()
+{
+    return std::unique_ptr<Car> (car_.release());
+}
+void Driver::rememberMyManager(DriverManager* myM)
+{
+   this->myManager_ = myM;
+}
+DriverManager* Driver::sayNameMyManager()
+{
+    return this->myManager_;
+}
+void Driver::rememberMySchool(autoschool* myS)
+{
+    this->mySchool_ = myS;
+}
+autoschool* Driver::sayNameMySchool()
+{
+    return this->mySchool_;
+}
+Driver* Driver::giveDriverToBuyCar()
+{
+    return myManager_->GivePtrDriverWithCar();
+}
+std::string Driver::SetCarColor()
+{
+    if (name_ == "Sergey")
+        return "green";
+    else if (name_ == "Ivan")
+        return "blue";
+    else if (name_ == "Sasha")
+        return "black";
+    else if (name_ == "Masha")
+        return "red";
+    else return "silver";
+}

Lesson_9/SmartPointer/Driver.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "CarFactory.h"
+#include "Car.h"
+class DriverManager;
+class autoschool;
+
+class Driver
+{
+public:
+    Driver(const std::string& name, std::shared_ptr<CarFactory> factory);
+    void BuyCar(const std::string& color);
+    void BuyUsedCar(Driver* d);
+    std::unique_ptr<Car> SellCar();
+    void Go();
+    void cleverGo();
+    std::vector<int> canIbuyUsedCar();
+    void rememberMyManager(DriverManager* myM);
+    DriverManager* sayNameMyManager();
+    void rememberMySchool(autoschool* myS);
+    autoschool* sayNameMySchool();
+    Driver* giveDriverToBuyCar();
+    std::string SetCarColor();
+    int intRand(const int& min, const int& max);
+private:
+    std::unique_ptr<Car> car_;
+    std::shared_ptr<CarFactory> factory_;
+    std::string name_;
+    DriverManager* myManager_;
+    autoschool* mySchool_;
+};
+

Lesson_9/SmartPointer/DriverManager.cpp

@@ -0,0 +1,66 @@
+
+#include "stdafx.h"
+#include "DriverManager.h"
+#include "CarFactory.h"
+#include "Driver.h"
+#include "Car.h"
+#include "autoschool.h"
+int DriverManager::NumberOfManagers = 0;
+
+DriverManager::DriverManager(const std::string& nameManager, std::shared_ptr<CarFactory>& factory)
+    : factory_(factory)
+    , nameManager_(nameManager)
+{
+}
+void DriverManager::GetOneDriver(std::unique_ptr<Driver> CurrentDriver)
+{
+    DriversOwnedByManagers_.push_back(std::move(CurrentDriver));
+}
+void DriverManager::ThreaFunctionManager(int DriverNumber)
+{
+
+    int i = 4;
+    while (i)
+    {
+        DriversOwnedByManagers_[DriverNumber]->cleverGo();
+        std::this_thread::sleep_for(std::chrono::milliseconds(4000));
+        i--;
+    }
+}
+void DriverManager::startThread()
+{
+    std::vector<std::thread> threads;
+    for (unsigned currentDriverNumber = 0; currentDriverNumber < DriversOwnedByManagers_.size(); ++currentDriverNumber)
+    {
+        threads.push_back(std::thread(&DriverManager::ThreaFunctionManager, this, currentDriverNumber));
+        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+    }
+    for (auto& t : threads)
+    {
+        t.join();
+    }
+}
+void DriverManager::setFieldManagerToOnedDrivers(int k)
+{
+    DriversOwnedByManagers_[k]->rememberMyManager(this);
+}
+std::mutex mtx;
+void DriverManager::GetPtrDriverWithCar(Driver* NewDriverWhitCar)
+{
+    std::lock_guard<std::mutex> locked(mtx);
+    PtrDriversWithCar_.push_back(NewDriverWhitCar);
+}
+Driver* DriverManager::GivePtrDriverWithCar()
+{
+    std::lock_guard<std::mutex> locked(mtx);
+    if (PtrDriversWithCar_.empty())
+    {
+        throw std::runtime_error ("...tried to buy a used car but they aren�t\n");
+    }
+    Driver* p_DriverWithCar = PtrDriversWithCar_.back();
+    PtrDriversWithCar_.pop_back();
+    return p_DriverWithCar;
+}
+
+
+

Lesson_9/SmartPointer/DriverManager.h

@@ -0,0 +1,22 @@
+#pragma once
+#include "Driver.h"
+class autoschool;
+
+class DriverManager
+{
+public:
+    DriverManager(const std::string& nameManager, std::shared_ptr<CarFactory>& factory);
+    void GetOneDriver(std::unique_ptr<Driver> CurrentDriver);
+    void startThread();
+    void ThreaFunctionManager(int DriverNumber);
+    void setFieldManagerToOnedDrivers(int k);
+    void GetPtrDriverWithCar(Driver* NewDriverWhitCar);
+    Driver* GivePtrDriverWithCar();
+
+private:
+    std::string nameManager_;
+    std::shared_ptr<CarFactory> factory_;
+    std::vector<std::unique_ptr<Driver>> DriversOwnedByManagers_;
+    static int NumberOfManagers;//TODO ïîäóìàòü ÷òî ñ ýòèì ðåøèòü
+    std::vector<Driver*> PtrDriversWithCar_;
+};

Lesson_9/SmartPointer/SmartPointer.cpp

@@ -1,93 +1,16 @@
-#include <iostream>
-#include <string>
-#include <memory>
-
-class Car
-{
-public:
-    Car(const std::string& color)
-    : color_(color)
-    {
-        std::cout << color_ << " car has been created\n";
-    }
-    ~Car() { std::cout << color_ << " car has been destroied\n"; }
-
-    void Drive()
-    {
-        std::cout << color_ << " car in move\n";
-    }
-
-private:
-    std::string color_;
-};
-
-class CarFactory
-{
-public:
-    std::unique_ptr<Car> BuildCar(const std::string& color)
-    {
-        return std::unique_ptr<Car>(new Car(color));
-    }
-};
-
-class Driver
-{
-public:
-    Driver(const std::string& name, std::shared_ptr<CarFactory> factory)
-        : factory_(factory)
-        , name_(name)
-    {
-    }
-
-    void BuyCar(const std::string& color)
-    {
-        car_ = factory_->BuildCar(color);
-    }
-
-    // SellCar
-    // BuyUsedCar
-
-    void Go()
-    {
-        if (car_ != nullptr)
-        {
-            std::cout << name_ << " I have a car ";
-            car_->Drive();
-        }
-        else
-        {
-            std::cout << name_ << ": I'll go on foot\n";
-        }
-    }
-
-private:
-    std::unique_ptr<Car> car_;
-    std::shared_ptr<CarFactory> factory_;
-    std::string name_;
-};
+#include "stdafx.h"
+#include "Driver.h"
+#include "CarFactory.h"
+#include "Car.h"
+#include "DriverManager.h"
+#include "autoschool.h"
 
 int main()
 {
-    std::shared_ptr<CarFactory> factory(new CarFactory());
-    Driver driver1("Bob", factory);
-    driver1.Go();
-
-    driver1.BuyCar("red");
-    driver1.Go();
-
-    driver1.BuyCar("blue");
-    driver1.Go();
 
-
-    Driver driver2("Sam", factory);
-    driver2.Go();
-
-    driver2.BuyCar("red");
-    driver2.Go();
-
-    driver2.BuyCar("blue");
-    driver2.Go();
-
-
+    std::shared_ptr<CarFactory> factory(new CarFactory());
+    autoschool mySchool(5, 2, "Ivan",factory);
+    std::thread thp(&autoschool::threadfuct, &mySchool);
+    thp.join();
     return 0;
 }