//  пусть где-то в хедере библиотеки объявлено:
//  void LibFunc( T1 arg1, T2 arg2, T3 arg3, LIB_RESULT& funcRes );
//  Дальше пишем в своём хедере так:
    extern LIB_RESULT libResult;
    void LibFunc( T1 arg1, T2 arg2, T3 arg3, LIB_RESULT& funcRes = libResult );
void

    inline LIB_RESULT LibFunc( T1 arg1, T2 arg2, T3 arg3 )
    {
        LIB_RESULT funcRes = 0;
        LibFunc( arg1, arg2, arg3, funcRes );
        return funcRes;
    }

typedef bool (*ShouldThrowIt_t)( const std::exception* e );
extern ShouldThrowIt_t ShouldThrowItCallback; // = 0;

template<typename T>
void throwIfShould( const T& e ) 
{
    if( ShouldThrowItCallback == 0 || ShouldThrowItCallback( &e ) ) {
        throw e;
    }
}

int func(int param, std::error_code& ec = throws())

//  Интерфейс для скармливания исключений принимающей стороне.
class IExceptionsTransmitter {
public:
    struct IExceptionHolder {
        virtual ~IExceptionHolder() {}
        virtual std::exception& Get() = 0; 
        virtual void ThrowIt() = 0;
        virtual IExceptionHolder* Clone() const = 0;
    };
    
    template<typename TException>
    void operator = ( const TException& e ) const
    {
        TransmitException( exceptionHolder<TException>( e ) );
    }

protected:
    virtual void TransmitException( const IExceptionHolder& holder ) const = 0;

private:
    template<typename TException> struct exceptionHolder : IExceptionHolder {
        TException Data;
        virtual TException& Get() { return Data; }
        virtual void ThrowIt() { throw Data; }
        virtual IExceptionHolder* Clone() const { return new IExceptionHolder( *this ); }
    };
};

class ExceptionsTransmitter : public IExceptionsTransmitter {
public:
    mutable std::vector<shared_ptr<IExceptionHolder> > TransmittedExceptions;
protected:
    virtual void TransmitException( const IExceptionHolder& holder ) const 
        { TransmittedExceptions.push_back( holder.Clone() ); }
};

class ExceptionsThrower : public IExceptionsTransmitter {
protected:
    virtual void TransmitException( const IExceptionHolder& holder ) const { holder.ThrowIt(); }
};

inline ExceptionsThrower throws() { return ExceptionsThrower(); }

int func(int param, const IExceptionsTransmitter& et = throws())
{
  if(param == invalid_param_value){
    et = std::invalid_argument("param");
    return EINVAL;
  }
    // ... do the work
}

/// \pre x > 10, p != NULL
void f(int x, int* p)
{
  assert(x > 10);
  assert(p);

  if(x > 10)
   throw std::invalid_argument("f::x"); // В клинических случаях добавляется запись в лог, etc.
                                        // Тип исключения в принципе не так важен, но это по  
                                        // сути логическая ошибка (std::logic_error).
                                        // Иногда можно увидеть std::runtime_error - но это уже похоже на саботаж

  if(!p)
   throw std::invalid_argument("f::p");

  //...
}

/// \pre arg > 0
void f(int arg);

/// \pre arg none
void my_main(int arg)
{
  // Я хочу вызвать функцию 'f'...

  if(arg <= 0) // <- Несоответстиве(*) предусловий для my_main#arg и f#arg - сигнал о необходимости проверки.
  {
    // Вот тут доступен весь контекст. Нужно в лог - пишем в лог...
    // + Не нужно протаскивать никакие данные через исключения.
    log_error(arg);
    return;
  }

  // Я обеспечил выполнение предусловий - выполнил свою сторону контракта.
  f(arg); 
}

// * Буквальное несоответстиве не всегда приводит к проверке

/// \pre x > 10, p != NULL
ЮЖ>void f(int x, int* p)
ЮЖ>{
ЮЖ>  assert(x > 10);
ЮЖ>  assert(p);

ЮЖ>  if(x > 10)
ЮЖ>   throw std::invalid_argument("f::x"); // В клинических случаях добавляется запись в лог, etc.
ЮЖ>                                        // Тип исключения в принципе не так важен, но это по  
ЮЖ>                                        // сути логическая ошибка (std::logic_error).
ЮЖ>                                        // Иногда можно увидеть std::runtime_error - но это уже похоже на саботаж

ЮЖ>  if(!p)
ЮЖ>   throw std::invalid_argument("f::p");

ЮЖ>  //...
ЮЖ>}

namespace Impl
{
    void throw_precondition_error(
        char const *string_literal_condition,
        char const *string_literal_file,
        long line);
}

#define CHECK_PRECONDITION(expr) \
    (assert(expr), (expr) ? void() : Impl::throw_precondition_error(#expr, __FILE__, __LINE__))
    
class PreconditionError : public std::exception
{
public:
    virtual char const *what() const throw()
        { return "Precondition error detected"; }
    char const *condition() const
        { return m_condition; }
    char const *file() const
        { return m_file; }
    long line() const
        { return m_line; }
    ~PreconditionError() throw() {}
private:
    PreconditionError(char const *condition, char const *file, long line) :
        m_condition(condition),
        m_file(file),
        m_line(line)
    {}

    char const *m_condition;
    char const *m_file;
    long m_line;
    
    friend void Impl::throw_precondition_error(
        char const *string_literal_condition,
        char const *string_literal_file,
        long line);
};

namespace Impl
{
    void throw_precondition_error(
        char const *string_literal_condition,
        char const *string_literal_file,
        long line)
    {
        throw PreconditionError(string_literal_condition, string_literal_file, line);
    }
}

/// \pre x > 10, p != NULL
void f(int x, int* p)
{
  CHECK_PRECONDITION(x > 10);
  CHECK_PRECONDITION(p);
  //...
}