main.cpp

#include <iostream>
#include <memory>
using namespace std;

// Базовый класс
class Base {
public:
    Base() { cout << "Base конструктор\n"; }
    Base(Base* obj) { cout << "Base конструктор копирования из указателя\n"; }
    Base(Base& obj) { cout << "Base конструктор копирования\n"; }
    virtual ~Base() { cout << "Base деструктор\n"; }

    // Перекрытый метод (не виртуальный)
    void show() { cout << "Base show()\n"; }

    // Виртуальный метод
    virtual void virtualShow() { cout << "Base virtualShow()\n"; }

    // Методы для проверки типа
    virtual string classname() { return "Base"; }
    virtual bool isA(string className) { return className == "Base"; }
};

// Класс-наследник
class Desc : public Base {
public:
    Desc() { cout << "Desc конструктор\n"; }
    Desc(Desc* obj) { cout << "Desc конструктор копирования из указателя\n"; }
    Desc(Desc& obj) { cout << "Desc конструктор копирования\n"; }
    ~Desc() { cout << "Desc деструктор\n"; }

    // Перекрытие метода (скрывает базовый)
    void show() { cout << "Desc show()\n"; }

    // Переопределение виртуального метода
    void virtualShow() override { cout << "Desc virtualShow()\n"; }

    // Переопределение методов проверки типа
    string classname() override { return "Desc"; }
    bool isA(string className) override { 
        return className == "Desc" || Base::isA(className);
    }
};

// Функции для демонстрации передачи параметров
void func1(Base obj) { cout << "func1 (передача по значению)\n"; }
void func2(Base* obj) { cout << "func2 (передача через указатель)\n"; }
void func3(Base& obj) { cout << "func3 (передача по ссылке)\n"; }

// Функции для демонстрации возврата значений
Base func4() { 
    Base obj; 
    cout << "func4 создает статический объект\n";
    return obj;
}
Base* func5() { 
    Base* obj = new Base();
    cout << "func5 создает динамический объект\n";
    return obj;
}
Base& func6() { 
    static Base obj;
    cout << "func6 возвращает статическую ссылку\n";
    return obj;
}

int main() {
    cout << "=== Демонстрация виртуальных методов ===\n";
    Base* basePtr = new Desc();
    basePtr->show();          // Вызовет Base::show() (не виртуальный)
    basePtr->virtualShow();   // Вызовет Desc::virtualShow()
    delete basePtr;

    cout << "\n=== Проверка типов ===\n";
    Base* obj = new Desc();
    cout << "classname: " << obj->classname() << endl;
    cout << "isA Base: " << obj->isA("Base") << endl;
    cout << "isA Desc: " << obj->isA("Desc") << endl;
    delete obj;

    cout << "\n=== Приведение типов ===\n";
    Base* testObj = new Desc();
    if (dynamic_cast<Desc*>(testObj)) {
        cout << "Приведение через dynamic_cast успешно\n";
    }
    if (testObj->isA("Desc")) {
        cout << "Приведение через isA успешно\n";
    }
    delete testObj;

    cout << "\n=== Передача параметров ===\n";
    Desc descObj;
    cout << "--- func1 (по значению): ";
    func1(descObj); // Вызовет конструктор копирования Base

    cout << "--- func2 (указатель): ";
    func2(&descObj);

    cout << "--- func3 (ссылка): ";
    func3(descObj);

    cout << "\n=== Возврат из функций ===\n";
    Base returnedObj = func4();
    Base* returnedPtr = func5();
    Base& returnedRef = func6();
    delete returnedPtr; // Освобождаем динамическую память

    cout << "\n=== Умные указатели ===\n";
    {
        unique_ptr<Base> uptr = make_unique<Desc>();
        cout << "unique_ptr выходит из области видимости...\n";
    }

    {
        shared_ptr<Base> sptr1 = make_shared<Desc>();
        {
            shared_ptr<Base> sptr2 = sptr1;
            cout << "Количество ссылок: " << sptr1.use_count() << endl;
        }
        cout << "Количество ссылок: " << sptr1.use_count() << endl;
    }

    return 0;
}