#include <iostream>

#define INVOKEFUN_C(COND, CLASS, FUNC, ...) if (COND) CLASS::FUNC(__VA_ARGS__);
#define INVOKEFUN_O(COND, OBJ, FUNC, ...) if (COND) OBJ.FUNC(__VA_ARGS__);


class A {
public:
  static void sf(int x, int y){
    std::cout << "sf(" << x << ", " << y << ")" << std::endl;
  }
  
  void f(int x, int y){
    std::cout << "f(" << x << ", " << y << ")" << std::endl;
  }
};

int main(void){
  INVOKEFUN_C(true, A, sf, 1, 2);
  A a;
  INVOKEFUN_O(true, a, f, 3, 4);  
  getchar();
  return 0;
}

 bool func(arg1,arg2....argN)
{
 if(isValid(arg1) && isValid(arg2) && ..........)
 {
   if(andNobodyWantsToThrowSomeShit(member1,memer2,member3))
   {
      if(bullShitCondition1(..))
      {
         if(bullShitCondition2(...))
         {
            if(!bullShitConditionN(...))
            {
               throw wowIfuckedYourGuidelinesException;
            }
            else
            {
               return arg1 != arg2
            }
         }
      }
   }
   return false;
 }

struct ProxyCall
{
   template<typename CallerClass, typename CallerFunc, typename agr1.....typename argN>
   ProxyCall(CallerFunc, CallerClass* caller):
   m_caller(caller)
   {
      
   }
   bool operator()(arg1,arg2...argN)
   {
      if(isValid(m_caller) && m_caller->testMyArgs(arg1....argN))
      {
       return SAFE_CALL(CallerFunc,CallerClass,arg1,arg2,argN);
      }
      return false;
   }
};

D> bool func(arg1,arg2....argN)
D>{
D> if(isValid(arg1) && isValid(arg2) && ..........)
D> {
D>   if(andNobodyWantsToThrowSomeShit(member1,memer2,member3))
D>   {
D>      if(bullShitCondition1(..))
D>      {
D>         if(bullShitCondition2(...))
D>         {
D>            if(!bullShitConditionN(...))
D>            {
D>               throw wowIfuckedYourGuidelinesException;
D>            }
D>            else
D>            {
D>               return arg1 != arg2
D>            }
D>         }
D>      }
D>   }
D>   return false;
D> }
D>

struct trap
{
  // любой правоассоциативный оператор с низким приоритетом
  template<class Exception> trap& operator <<= (Exception const& e)
  {
    handle_the_exception(e); // пишет в лог, взводит флаг, утилизирует объект (если надо)
    return *this;
  }

  // для возвращения
  template<class Return> operator Return() const { return Return(); }
};

#ifdef пожалеем_раздолбая
#define throw  trap() <<= /*исключение*/
#else
#define throw !!! по голове себе постучи !!!
#endif

template<class F>
typename boost::result_type<F>::type
safecall(F f)
{
  try
  {
    return f();
  }
  catch(...)
  {
    rethrow_handle_and_absorb();
    return default_value();
  }
}

// обработчик исключений, вынесенный за пределы вызова проблемного кода
void rethrow_handle_and_absorb
{
  try { throw; } // переизлучаем... но мы должны быть уверены, что вызвали эту функцию из catch(...)
  catch(aaa) { .... }
  catch(bbb) { .... }
  catch(ccc) { .... }
  catch(...) { .... }
}

// универсальный результат - приводится ко всем типам на свете
struct default_value
{
  template<class T> operator T() const { return T(); }
};

// вызываем
.... safecall(boost::bind(foo,1,2,3,4,5)) .....

// карринг параметров шаблона: возвращаемый тип R отдельно,
template<class R> struct safecaller
{
  typedef R result_type;
  // а принимаемый F - отдельно
  template<class F> R operator()(F f) const { return safecall(f); }
};

// используем...
bar( .....
     bind(
       safecaller<bool>(), // тип объекта и тип result_type для bind нужны сразу (он их замучается выводить)
       protect( // изолируем внутренний бинд от внешнего
         bind(foo,1,2,3,4,5)
       ) // то есть, внутрь safecall<bool>()(_) приедет не результат вызова foo(1,2,3,4,5), а сам бинд
     )
     .....
    );

void bar(...., F f, .....) // F изоморфен bool(), т.е., например, function<void()> или параметр шаблона
{ ..... f(); ..... } // здесь f() тождественно предыдущей форме safecall(bind(foo,1,2,3,4,5))