#include <cstring>
#include <functional>
#include <iostream>
#include <memory>
#include <stddef.h>
#include <string>
#include <type_traits>
#include <utility>
#include <windows.h>

template <class T>
    T &&multiple_forward(typename std::remove_reference<T>::type &t)
        { return static_cast<T &&>(t); }
template <class T>
    T const &multiple_forward(typename std::remove_reference<T>::type &&t)
        { return t; }

template <class ErrorHandler, class F, class... Params>
    void trial_exec(
        ErrorHandler const &error_handler,
        F const &f,
        Params &&... params)
{
    for (;;)
        try
        {
            f(multiple_forward<Params>(params)...);
            break;
        }
        catch (...)
        {
            error_handler();
        }
}

std::string WinErrorCodeDescription(DWORD err_code)
{
    char *msg_buf = 0;

    FormatMessageA(
        FORMAT_MESSAGE_ALLOCATE_BUFFER |
        FORMAT_MESSAGE_FROM_SYSTEM |
        FORMAT_MESSAGE_IGNORE_INSERTS,
        0,
        err_code,
        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
        (char *)&msg_buf,
        0,
        0);

    try
    {
        std::string result = msg_buf ? msg_buf : "Not enough memory";
        LocalFree(msg_buf);
        return result;
    }
    catch (...)
    {
        LocalFree(msg_buf);
        throw;
    }
}

class OpeningFileError : public std::exception
{
public:
    OpeningFileError(DWORD err_code) :
        m_msg(std::make_shared<std::string>("Failed to open file: " + WinErrorCodeDescription(err_code)))
    {}

    virtual char const *what() const throw()
    {
        return m_msg->c_str();
    }

private:
    std::shared_ptr<std::string> m_msg;
};

class WritingFileError : public std::exception
{
public:
    WritingFileError(DWORD err_code) :
        m_msg(std::make_shared<std::string>("Failed to write file: " + WinErrorCodeDescription(err_code)))
    {}

    virtual char const *what() const throw()
    {
        return m_msg->c_str();
    }

private:
    std::shared_ptr<std::string> m_msg;
};

class OutputFile
{
public:
    OutputFile(
        char const *filename,
        std::function<void ()> const &error_handler)
    {
        trial_exec(error_handler, open_file, filename, m_handle);
    }

    ~OutputFile()
    {
        if (m_handle)
            CloseHandle(m_handle);
    }

    void write(char const *data, size_t size)
    {
        DWORD bytes_written;
        if (!WriteFile(m_handle, data, size, &bytes_written, 0))
            throw WritingFileError(GetLastError());
    }

    template <size_t size>
        void write(char const (&data)[size])
    {
        write(data, size);
    }

private:
    OutputFile(OutputFile const &);
    void operator =(OutputFile const &);

private:
    static void open_file(char const *filename, HANDLE &out_handle)
    {
        out_handle = CreateFileA(
            filename,
            GENERIC_WRITE,
            0,
            0,
            CREATE_ALWAYS,
            FILE_ATTRIBUTE_NORMAL,
            0);
        if (out_handle == INVALID_HANDLE_VALUE)
            throw OpeningFileError(GetLastError());
    }

    HANDLE m_handle;
};

class X
{
public:
    void foo(
        char const *filename,
        std::function<void()> const &error_handler)
    {
        f();                                       // некая куча операций
        OutputFile bar(filename, error_handler);   // пытаемся открыть файл bar
        do_something_with_bar(bar, error_handler); // что-то делаем с файлом bar
    }

    void f()
    {
        std::cout << "foo operations" << std::endl;
    }

    void do_something_with_bar(
        OutputFile &file,
        std::function<void ()> const &error_handler)
    {
        trial_exec(
            error_handler,
            [&file]()
                {
                    char const *s = "something";
                    file.write(s, std::strlen(s));
                }
            );
    }
};

void file_error_handler()
{
    try
    {
        throw;
    }
    catch (OpeningFileError &err)
    {
        if (MessageBoxA(0, err.what(), "Error", MB_RETRYCANCEL | MB_ICONERROR) != IDRETRY)
            throw err;
    }
    catch (WritingFileError &err)
    {
        if (MessageBoxA(0, err.what(), "Error", MB_RETRYCANCEL | MB_ICONERROR) != IDRETRY)
            throw;
    }
}

int main()
{
    try
    {
        X().foo("test.txt", file_error_handler);
    }
    catch (OpeningFileError &)
    {}
    catch (WritingFileError &)
    {}
    catch (std::exception &e)
    {
        MessageBoxA(0, e.what(), "Error", MB_OK);
    }
}