enum CustomResultCode
{
    CustomResult_info_SUCCESS = 0,

    //Add more CustomResult_info_*
    //Add more CustomResult_error_*
    //Add more CustomResult_exception_*
};
struct Result
{
    enum CodeType
    {
        HRESULT_code = 0,
        NTSTATUS_code,
        LastError_code,
        Custom_code
    };
    CodeType type;
    LONG code;
};

C>enum CustomResultCode
C>{
C>    CustomResult_info_SUCCESS = 0,

C>    //Add more CustomResult_info_*
C>    //Add more CustomResult_error_*
C>    //Add more CustomResult_exception_*
C>};
C>struct Result
C>{
C>    enum CodeType
C>    {
C>        HRESULT_code = 0,
C>        NTSTATUS_code,
C>        LastError_code,
C>        Custom_code
C>    };
C>    CodeType type;
C>    LONG code;
C>};
C>

struct SourceCodeNotch
{
    const char* fileName;
    unsigned    lno;
    const char* funcName;
public:
    SourceCodeNotch(const char* fileName, unsigned lno, const char* funcName)
    {   // очевидно, что
    }
};


struct Status
{
    typedef int Code;

    enum 
    {
        Ok,
        GenericError,
        IllegalStateError,
        IllegalArgumentError,
        // добавить по вкусу
        ...
    } 

    class Error: std::exception // не обязательно, но весьма полезно
    {
        const Code code_;
        const SourceCodeNotch src_;
    public:
        Error(const SourceCodeNotch& src, Code code): src_(src), code_(code)
        {
        }
    };

    static void
    check(const SourceCodeNotch& src, Code code)
    {
        if (Ok != code)
        {
            throw Error(src, code);
        }
    }
};


class NoThrow {};


#define CREATE_SOURCE_CODE_NOTCH SourceCodeNotch(__FILE__, __LINE__, __FUNCTION__)
#define CHECK_STATUS(code) Status::check(CREATE_SOURCE_CODE_NOTCH, (code))

// Все функции овормляем так:

Status::Code
doSomething(const NoThrow&);

Status::Code
getSomething(const NoThrow&, int& res /* output parameter */);

#include "generated_api.h"

inline void
doSomething()
{
    CHECK_STATUS(doSomething(NoThrow()));
}

inline int
getSomething()
{
    int res;
    CHECK_STATUS(getSomething(NoThrow(), res));
    return res;
}

A>struct SourceCodeNotch
A>{
A>    const char* fileName;
A>    unsigned    lno;
A>    const char* funcName;
A>public:
A>    SourceCodeNotch(const char* fileName, unsigned lno, const char* funcName)
A>    {   // очевидно, что
A>    }
A>};

template <
    typename File = const char*
  , typename Line = File
  , typename Function = File
  >
class basic_location
{
    // понятно что тут... ;)
};

// и 
typedef basic_location<const char*, const char*, const char*> location;

Z>интересна, а зачем она вообще тогда там (в исключении) есть?

Z>... ну а так в целом, да... логирование решает проблему... когда оно есть -- т.е. если вдруг в описаной в моем первом посте сложной функции возникает проблема, и ты точно не знаешь какой из return'ов вернул код ошибки, то нада расставлять спам перед каждым ... %)

Status::Code
doSomethingComplicated(const NoThrow&)
{
    try
    {
        CHECK_STATUS(doSomething(NoThrow()));
        ...
        CHECK_STATUS(doSomething2(NoThrow()));
        return Status::Ok;
    }
    catch (const Status::Error &ex)
    {
        LOG_ERROR("Status::Error caught at: %s(%d): code=%d, thrown from %s(%d)\n", 
            __FILE__, __LINE__, ex.getCode(), ex.getSrc().fileName, ex.getSrc().lno);
        return ex.getCode();
    }
    catch (...)
    {    // тут что-нибудь ужасное писать в лог
    }
    return Status::GenericError;
}

void DoSomething();

DoSomething();
if (GetLastError() != NO_ERROR)
{  // чего-то делать
}

допустим у меня нет выбора и нужно пользоваться кодами возврата, а не исключениями.

Далеко ходить не надо — Win API SetLastError/GetLastError. Делаете себе тикие-же функции с хранением кода в thread storage. И функции ничего не возвращают и код возврата сохраняется на поток.