PV913STDExceptExample

#include <iostream>
#include <exception>

class StorageException
{
    std::string error;
public:
    StorageException(std::string errorP) : error{ errorP } {};

    const char* getError()const { return error.c_str(); };
};

class FuncException : public StorageException
{
public:
    FuncException(std::string errorP) : StorageException{ errorP } {};
};


void funcThree()
{
    std::cout << "FuncThree Started!\n";

    //throw nullptr;
    //throw "Oops!";
    //throw 'Z';
    //throw -1;
    //throw FuncException{ "All bad :(" };
    throw std::runtime_error{ "FuncThree All Bad:(" };

    std::cout << "FuncThree Ended!\n";
}

void funcTwo()
{
    std::cout << "FuncTwo Started!\n";

    try
    {
        funcThree();
    }

    catch (char ex)
    {
        std::cout << "FuncTwo catches CHAR exception!\n";
    }

    std::cout << "FuncTwo Ended!\n";
}


void funcOne()
{
    std::cout << "FuncOne Started!\n";
    try
    {
        funcTwo();
    }

    catch (float ex)
    {
        std::cout << "FuncOne catches FLOAT exception!\n";
    }

    catch (bool ex)
    {
        std::cout << "FuncOne catches BOOL exception!\n";
    }

    catch (int ex)
    {
        std::cout << "FuncOne catches INT exception!\n";
    }

    std::cout << "FuncOne Ended!\n";
}



class Storage
{
    int arr[5]{1,2,3,4,5};
public:
    int& operator[](int idx)
    {
        if (idx >= 0 and idx < 5)
        {
            return arr[idx];
        }

        if (idx < 0)
        {
            throw StorageException{ "Too small index!" };
        }
        else
        {
            throw StorageException{ "Too big index!" };
        }

};
};

int main()
{
    Storage arr;
    try
    {
        funcThree();
        //std::cout << arr[-4] << '\n';
        //std::string str;
        //str.resize(LONG_MAX);
    }

    catch (const FuncException& ex)
    {
        std::cout << "FuncException: " << ex.getError() << '\n';
    }

    catch (const StorageException& ex)
    {
        std::cout << "StorageException: " <<  ex.getError() << '\n';
    }

    catch (const std::runtime_error& e) {
        std::cout << "Runtime error: " << e.what() << '\n';
    }

    catch (const std::bad_alloc& e) {
        std::cout << "Allocation failed: " << e.what() << '\n';
    }

    catch (std::exception& ex)
    {
        std::cout << "STD LIB exception " << ex.what() << '\n';
    }

    catch (int ex)
    {
        if (ex == -1)
        {
            std::cout << "funcThree error!\n";
        }
    }

    return 0;
}