#include <iostream>

class Type {
public:
    Type() {
        std::cout << "created" << std::endl;
    }
    ~Type() {
        std::cout << "died" << std::endl;
    }
    int value = 0;
};

class SomeClass {
public:

    static Type field;
    int counter = 0;
    inline static int common_counter = 123;

    static SomeClass create(int value) {
        if (value < 1000) {
            throw std::invalid_argument("value less then 1000");
        }
        return SomeClass(value);
    }

private:
    SomeClass(int value) {
        counter = value;
    }

};

Type SomeClass::field;

const std::string NAME = "Alexey";
const std::string& f() {
    static std::string name = "Alexey";
    return name;
}

class Animal {
public:
    Animal(const std::string& name)
        : name_(name)
    {}

    virtual std::string Voice() const {
        return "not implemented";
    }
    virtual ~Animal() {
        std::cout << "Died animal: " << name_  << std::endl;
    }
private:
    std::string name_;
};

class Tiger : public Animal {
public:
    Tiger()
        : Animal("without name")
    {
    }
    Tiger(const std::string& name)
        : Animal(name)
    {}
    virtual std::string Voice() const override {
        return "rrrrrr";
    }

    ~Tiger() {
        std::cout << "Died tiger: " << Voice() << std::endl;
    }
};

class Wolf : public Animal {
public:
    using Animal::Animal;
    std::string Voice() const override {
        return "woooo";
    }
};

class Fox: public Animal {
    using Animal::Animal;
};


class A {
public:
    A() {
        std::cout << "A" << std::endl;
    }
    virtual ~A() {
        std::cout << "~A" << std::endl;
    }
};
class B : public A {
public:
    B() {
        std::cout << "B" << std::endl;

        ptr = new int[1000];
    }
    ~B() {
        delete ptr;
        std::cout << "~B" << std::endl;
    }
    int* ptr;
};
class C : public B {
    public:
    C() {
        std::cout << "C" << std::endl;
    }
    ~C() {
        std::cout << "~C" << std::endl;
    }
};

int main() {
    {
    SomeClass a = SomeClass::create(1000000);
    SomeClass b = SomeClass::create(1111111);
    a.field.value++;
    std::cout << a.field.value << std::endl;
    b.field.value++;
    std::cout << b.field.value << std::endl;
    std::cout << &a.field << " vs " << &b.field << std::endl;
    std::cout << &a.counter << " vs " << &b.counter << std::endl;
    a.create(10000);
    SomeClass::create(20000);
    }

    Tiger t;
    Wolf w("Alex");
    Fox f("Bob");

    try {

        try {
            ///....
        } catch(...) {
            std::cout << "";
            throw;
        }
    }catch(...) {

    }

    {
        Animal* t2 = new Tiger("Zoos");

        std::cout << t.Voice() << " " << w.Voice() << " " << f.Voice() << " " << t2->Voice()  << std::endl;
        delete t2;
    }
    {
        try {
            A* ptr = new C;
            delete ptr;
        } catch(...) {
            std::cout << "got exception" << std::endl;
        }

    }
}