DWORD err = GetLastError();
(void)err;

BOOL res = CloseHandle(f);
assert(res);
(void)res;

template<typename T>
class unused
{
public:
    unused(T v) : v(v) {}
    unused(unused const& v) : v(v.v) {}
    operator T () const {return v;}
private:
    void operator = (unused const&);
    T volatile const v;
};

unused<DWORD> err = GetLastError();

unused<BOOL> res = CloseHandle(fout);
assert(res);

#define REMARK_VERIFY(x) LBRACE auto tmp = x; assert(x); RBRACE

#define LBRACE do {
#define RBRACE } while(false)

struct errors
{
  UINT m_lasterror;
  error_t m_errno, m_doserrno;

  errors() : m_lasterror(GetLastError()), m_errno(::errno), m_doserrno(::_doserrno) {}

  operator bool() const { return m_lasterror||m_errno||m_doserrno; }
};

template<class Value, class Assertion = Pofigu>
struct unused
{
  Value m_value;
  errors m_errors;

  unused(Value v) : m_value(v) { Assertion::assert(v, m_errors); }
};

struct Pofigu         { template<class Value> static void assert(Value v,   errors const& e) {               } };
struct AssertNoErrors { template<class Value> static void assert(Value v,   errors const& e) { ::assert(!e); } };
struct AssertNonZero  { template<class Value> static void assert(Value v,   errors const& e) { ::assert(v);  } };
struct AssertZero     { template<class Value> static void assert(Value v,   errors const& e) { ::assert(!v); } };
struct AssertHResult  {                       static void assert(HRESULT v, errors const& e) { ::assert(SUCCEEDED(hr)); } };

U>unused<std::string> res = FetchName(db);
U>assert(!res.empty());
U>

assert(!res->empty());

VERIFY(CloseHandle(x));

R>    unused(unused const& v) : v(v.v) {}
R>private:
R>    void operator = (unused const&);
R>

unused<DWORD> res = GetLastError();
checkError( res );

R>

unused<std::string> res = FetchName(db);
assert(!res.empty());

template<class T>
class unused : noncopyable
{
#ifdef _DEBUG

  T data;
public:
  unused(const T& v) : data(v) {}
  operator const T& () const { return data; }

#else

public:
  unused(const T& v) {}
  operator const T& () const { PANIC(); }

#endif
};

К>Всё-таки, unused — это write-only. Ассерт — это уже не совсем unused

К>template<class T>
К>class unused : noncopyable
К>{
К>#ifdef _DEBUG
К>  T data;
К>public:
К>  unused(const T& v) : data(v) {}
К>  operator const T& () const { return data; }
К>#else
К>public:
К>  unused(const T& v) {}
К>  operator const T& () const { PANIC(); }
К>#endif
К>};
К>

DWORD volatile err = GetLastError();

DWORD err = GetLastError();
(void)err;

R>DWORD err = GetLastError();
R>(void)err;

R>BOOL res = CloseHandle(f);
R>assert(res);
R>(void)res;
R>

#include "error_handler.hpp"

#include <exception>
#include <iostream>
#include <string>

#include <windows.h>

using namespace std;
using namespace err;

HRESULT test_ok()
{
    return S_OK;
}

HRESULT test_false()
{
    return S_FALSE;
}

HRESULT test_error()
{
    return E_INVALIDARG;
}

BOOL test_win32_success()
{
    return TRUE;
}

BOOL test_win32_error()
{
    SetLastError(HRESULT_CODE(E_FAIL));
    return FALSE;
}

int main()
try
{
    test_ok() || die;

    HRESULT hr = test_false() || die;
    if (hr != S_FALSE)
        throw runtime_error("wrong HRESULT");

    try
    {
        test_error() || die;
        throw runtime_error("didn't die");
    }
    catch (hresult_error & e)
    {
        if (e.hresult() != E_INVALIDARG)
            throw runtime_error("wrong HRESULT");
    }

    test_ok() || die("should be OK");
    test_ok() || die("should be OK with 1 parameter %1%")(1);
    test_ok() || die("should be OK with 10 parameters %1% %2% %3% %4% %5% %6% %7% %8% %9% %10%")(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

    try
    {
        test_error() || die("should throw");
        throw runtime_error("didn't die");
    }
    catch (hresult_error & e)
    {
        if (string(e.what()) != string("should throw"))
            throw runtime_error("wrong exception message");
    }

    try
    {
        test_error() || die("should throw with 10 parameters %1% %2% %3% %4% %5% %6% %7% %8% %9% %10%")(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        throw runtime_error("didn't die");
    }
    catch (hresult_error & e)
    {
        if (string(e.what()) != string("should throw with 10 parameters 1 2 3 4 5 6 7 8 9 10"))
            throw runtime_error("wrong exception message");
    }

    try
    {
        test_error() || die("should throw with 1 parameter %1%")(1);
        throw runtime_error("didn't die");
    }
    catch (hresult_error & e)
    {
        if (string(e.what()) != string("should throw with 1 parameter 1"))
            throw runtime_error("wrong exception message");
    }

    test_win32_success() || die;

    try
    {
        test_win32_error() || die;
        throw runtime_error("didn't die");
    }
    catch (win32_error & e)
    {
        if (e.error_code() != HRESULT_CODE(E_FAIL))
            throw runtime_error("wrong error code");
    }

    test_win32_success() || die("should be OK");

    try
    {
        HANDLE file = CreateFile(L"c:\\some_dir\\some_other_dir\\some_file", 0, 0, 0, 0, 0, 0)
            || die("can't create file");
        throw runtime_error("didn't die");
    }
    catch (win32_error &)
    {}

    if (hresult_error::format_message(E_FAIL) != string("Unspecified error\r\n"))
        throw runtime_error("wrong HRESULT message");

    if (win32_error::format_message(ERROR_ACCESS_DENIED) != string("Access is denied.\r\n"))
        throw runtime_error("wrong GetLastError message");

    cout << "SUCCEEDED\n";
}
catch (exception & e)
{
    cerr << "FAILED: " << e.what() << endl;
    return -1;
}

R>>>Тут теряется информация (иногда сводить придётся к void). Так чем же хуже ещё к этому и дать отлаживающему пользователю информацию в удобной форме?

error_code foo()
{
    if(!api::bar())
    {
        DWORD err = GetLastError();
        (void)err;
        return error_x;
    }
...

bool init()
{
    return SUCCEEDED(CoInitialize(NULL));
}

/// \return NULL при ошибке
/// \throw none
int* get();


// реализация 1
int* get()
{
  // механизм (выделения памяти) используется, ошибки не свернуты  => нарушение контракта
  return new int;
}

// реализация 2
int* get()
{
  // механизм (выделения памяти) используется, ошибки свернуты  => один из выходов
  return new(std::nothrow) int;
}

// реализация 3
int* get()
{
  // Отказались от механизма => один из выходов
  return g_int_ptr;
}

errno value is not necessarily the same as the actual error code returned by a system call from the Windows operating systems. To access the actual operating system error code, use the _doserrno variable, which contains this value.

RL_API int rl_thread_create(rl_thread_t* thr, rl_thread_start_t func, void* arg, rl_thread_prio_t prio, size_t stack_size)
{
    rl_thread_impl_t*           impl;
    DWORD                       werr;
    int                         err;
    int                         win_prio;

    if (thr == 0 || func == 0)
        return RL_ERR_INVALID_ARG;

    if (stack_size > UINT_MAX)
        stack_size = UINT_MAX;
    impl = (rl_thread_impl_t*)malloc(sizeof(rl_thread_impl_t));
    if (impl == 0)
        return RL_ERR_NOMEM;
    thr->impl = impl;
    impl->func = func;
    impl->arg = arg;
    impl->res = 0;
    rl_atomic_size_store(&impl->rc, 2, rl_memory_order_nonatomic);
    impl->handle = (HANDLE)_beginthreadex(0, (unsigned)stack_size, rl_thread_func, impl, 0, 0);
    if (impl->handle == 0 || (uintptr_t)impl->handle == (uintptr_t)-1)
    {
        err = errno;
        (void)err;
        assert(!"failed to start a thread");
        free(impl);
        return RL_ERR_OTHER;
    }
    if (prio != rl_thread_prio_normal)
    {
        win_prio = THREAD_PRIORITY_NORMAL;
        if (prio == rl_thread_prio_lowest)
            win_prio = THREAD_PRIORITY_LOWEST;
        else if (prio == rl_thread_prio_low)
            win_prio = THREAD_PRIORITY_BELOW_NORMAL;
        else if (prio == rl_thread_prio_high)
            win_prio = THREAD_PRIORITY_ABOVE_NORMAL;
        else if (prio == rl_thread_prio_highest)
            win_prio = THREAD_PRIORITY_HIGHEST;
        if (0 == SetThreadPriority(impl->handle, win_prio))
        {
            werr = GetLastError();
            (void)werr;
            assert(!"failed to set thread's priority");
        }
    }
    return 0;
}




RL_API int rl_thread_detach(rl_thread_t thr)
{
    rl_thread_impl_t*           impl;
    DWORD                       err;

    if (thr.impl == 0)
        return RL_ERR_INVALID_ARG;

    impl = (rl_thread_impl_t*)thr.impl;
    if (FALSE == CloseHandle(impl->handle))
    {
        assert(!"failed to close thread's handle");
        err = GetLastError();
        (void)err;
        return RL_ERR_OTHER;
    }
    if (1 == rl_atomic_size_fetch_sub(&impl->rc, 1, rl_memory_order_relaxed))
        free(impl);
    return 0;
}

R>RL_API int rl_thread_create(rl_thread_t* thr, rl_thread_start_t func, void* arg, rl_thread_prio_t prio, size_t stack_size)
R>

struct ReturnCode
{
  string message;
  int code;
};