PV913AnimalOstream

#include <iostream>
#include <vector>
#include <string>
#include <math.h>
#include <chrono>



class Polygon
{
protected:
    std::vector<float> sides;

public:
    Polygon& addSide(float size) { sides.push_back(size); return *this; };
    Polygon& setSide(int sideId, float size)
    {
        sides[sideId] = size; return *this;
    };
    float getSide(int sideId)const { return sides[sideId]; };
    virtual float perimeter()const
    {
        float per{ 0 };
        for (const auto& side : sides)
        {
            per += side;
        }
        return per;
    };
    virtual float area()const;

    const Polygon& sidesInfo()const
    {
        for (int i{ 0 }; i < sides.size(); ++i)
        {
            std::cout << " Side " << char('A' + i) << " is " << sides[i] << " long\n";
        }
        return *this;
    }

    std::string name()const
    {
        std::string nm{ typeid(*this).name() }; //"class Polygon"
        return nm.substr(5);
    }

    const Polygon& info()const
    {
        std::cout << name() << ":\n"
            << " Perimeter: " << perimeter()
            << " Area: " << area() << '\n';
        sidesInfo();
        std::cout << '\n';

        return *this;
    }

};

float Polygon::area()const
{
    return -1;
}

class Rectangle : public Polygon
{
public:
    Rectangle(float sideA, float sideB) { addSide(sideA); addSide(sideB); };
    virtual float perimeter()const override { return Polygon::perimeter() * 2; };
    virtual float area()const  override { return getSide(0) * getSide(1); }
};

class Square : public Rectangle
{
public:
    Square(float sideA) : Rectangle{ sideA, sideA } {};
};

class Triangle : public Polygon
{
public:
    Triangle(float sideA, float sideB, float sideC)
    {
        addSide(sideA).addSide(sideB).addSide(sideC);
    };
    virtual float area()const override
    {
        const float p{ perimeter() / 2 };
        return sqrt(p * (p - getSide(0)) * (p - getSide(1)) * (p - getSide(2)));
    }
};

class Parent
{
    int val;
public:
    Parent(int valP) : val{ valP }
    {
        std::cout << "Parent constructed! for " << this << '\n';
    };
    Parent() : Parent{ 0 } {};
    int getVal()const { return val; };
    virtual const Parent& info()const { std::cout << "Parent with val = " << val << '\n'; return *this; };
    virtual ~Parent();
};

Parent::~Parent() { std::cout << "Parent destructed! for " << this << '\n'; };

class Child : public Parent
{
    int* storage;
    int size;
public:
    Child(int sizeP, int valP) : Parent{ valP }, storage{ new int[sizeP] }, size{ sizeP }
    {
        std::cout << "Child constructed! for " << this << '\n';
    };
    Child() : Child{ 5, 42 } {};
    virtual const Child& info()const override { std::cout << "Child with val = " << getVal() << '\n'; return *this; };
    virtual ~Child()override { delete[] storage; std::cout << "Child destructed! for " << this << '\n'; };
};

void infoPrint(Parent par)
{
    par.info();
}

class ParentD
{
public:
    void name() { std::cout << "Parent->name()\n"; };
    virtual ~ParentD() {};
};

class ChildD : public ParentD
{
    int val{ 42 };
public:
    void print() { std::cout << "Child->print() " << val << '\n'; };
};

void modVal(const int* val)
{
    int* ptr;
    //ptr = val;
    ptr = const_cast<int*>(val);
    *ptr = 555;
    std::cout << *ptr << '\n';
}

void printVal(int* val)
{
    std::cout << "PrintVal() " << *val << '\n';
}

ParentD* objGenerator()
{
    return (rand() % 2) ? new ParentD : new ChildD;
}

class Animal
{
protected:
    std::string name;
public:
    Animal(std::string nameP) : name{ nameP } {};
    virtual std::ostream& print(std::ostream& out)const
    {
        out << "Base Animal " << name << '\n';
        return out;
    };

    friend std::ostream& operator<<(std::ostream& out, const Animal& obj);
};

std::ostream& operator<<(std::ostream& out, const Animal& obj)
{
    return obj.print(out);
}

class Cat : public Animal
{
    std::string meh;
public:
    Cat(std::string nameP, std::string mehP) : Animal{ nameP }, meh{ mehP } {};
    virtual std::ostream& print(std::ostream& out)const override
    {
        out << "The Cat named " << name << " with " << meh << " meh!\n";
        return out;
    };
    void meow() { std::cout << "MEOW!\n"; };
};

class Dog : public Animal
{
    int weight;
public:
    Dog(std::string nameP, int weightP) : Animal{ nameP }, weight{ weightP} {};
    virtual std::ostream& print(std::ostream& out)const override
    {
        out << "The Dog named " << name << " weight is: " << weight << '\n';
        return out;
    };
    void woff() { std::cout << "WOFF!\n"; };
};

int main()
{
    Animal animal{ "Meduza" };
    Dog dog{ "Bobik", 60 };
    Cat cat{ "Murka", "white" };
    std::cout << animal << '\n';
    std::cout << dog << '\n';
    std::cout << cat << '\n';

    //Cat* catPtr{ new Cat };
    //Dog* dogPtr{ new Dog };
    //Animal* animals[2]{catPtr, dogPtr};


    //Dog* dPtr{ static_cast<Dog*>(animals[1]) };
    //dPtr->name();
    //dPtr->woff();

    /*for (const auto& animal : animals)
    {
        animal->name();

        Cat* cPtr{ static_cast<Cat*>(animal) };
        if (cPtr)
        {
            cPtr->meow();
        }

        Dog* dPtr{ static_cast<Dog*>(animal) };
        if (dPtr)
        {
            dPtr->woff();
        }
    }*/


    return 0;
    /*srand(time(nullptr));
    ParentD* objs[10];
    for (auto& obj : objs)
    {
        obj = objGenerator();
    }

    for (auto& obj : objs)
    {
        std::cout << typeid(*obj).name() << '\n';
        ChildD* cPtr{ (ChildD*)obj };

        if (cPtr)
        {
            std::cout << "Got ChildD object!";
            cPtr->print();
        }
        else
        {
            std::cout << "Got ParentD object!";
            obj->name();
        }
    }*/
    /*int* ptr;
    float fVal{ 36.6 };
    ptr = (int*)&fVal;
    std::cout << typeid(*ptr).name() << '\n';

    return 0; */

    //ParentD* parentPtr;
    //ChildD* childPtr{ new ChildD };

    //parentPtr = childPtr;
    //ChildD* cPtr;
    //cPtr = dynamic_cast<ChildD*>(parentPtr);

    //parentPtr->name();
    //cPtr->name();
    //cPtr->print();
    //
    //delete childPtr;
    //return 0;

    //Polygon* polygonPtr;

    //Rectangle* rectanglePtr{ new Rectangle{3,4} };
    //polygonPtr = rectanglePtr;
    //
    //std::cout << typeid(polygonPtr).name() << '\n';
    //std::cout << typeid(rectanglePtr).name() << '\n';

    //Triangle* trianglePtr{ new Triangle{3,4,5} };
    //polygonPtr = trianglePtr;

    //std::cout << typeid(polygonPtr).name() << '\n';
    //std::cout << typeid(trianglePtr).name() << '\n';

    //delete rectanglePtr;
    //delete trianglePtr;



    //const_cast<>()
    //static_cast<>()
    //dynamic_cast<>()
    //reinterpret_cast<>()
    const int cIntVal{ 42 };
    int intVal{ 33 };

    //std::cout << cIntVal << '\n';
    ////modVal(&intVal);
    //printVal(const_cast<int*>(&cIntVal));
    //std::cout << cIntVal << '\n';

    /*float* fPtr;
    fPtr = static_cast<float*>(&intVal);
    intVal = static_cast<int>(36.6);

    std::cout << *fPtr << '\n';*/
    //volatile

}