Свершилось! Форсирование проверки возвращаемого значения в компайл-тайм возможно!

bool f();

int main()
{
  if (!f()) // Хорошо! Проверили возвращаемое значение
    exit(1);

  f(); // Плохо! Не проверили возвращаемое значение
}

Решение

bool fff(int param)
{
    return 0 == param;
}

template<int id>
checked_result<id> fff_wrap(int param, RESULT_CHECK_PARAM)
{
    return 0 == param;
}

int main()
{
    bool b1 = fff(1, ID); // Компилируется
    ignore_result(fff(2, ID)); // Компилируется
    if (fff(2, ID)); // Компилируется
    fff(1, ID); // НЕ Компилируется! error C2027: use of undefined type 'boost::STATIC_ASSERTION_FAILURE<x>'
}

// Стратегии сообщения об ошибке (куда сейчас без стратегий? :) )
// На выбор - ошибка компиляции, варнинг, ошибка без использования boost (специально для нелюбителей boost'а :) )

struct error_report_policy
{
    template<typename> static void report()
    {
        BOOST_STATIC_ASSERT(false);
    }
};

struct error_report_no_boost_policy
{
    template<typename> static void report()
    {
        typedef char error[-1];
    }
};

struct warning_report_policy
{
    template<typename> static void report()
    {
        BOOST_STATIC_WARNING(false);
    }
};

namespace
{
    // Вспомогательный класс - ниже будет видно зачем
    template<int id>
    struct result_check_helper
    {
        static void fake() {}
    };
}

// Собственно класс для возвращаемого значения
// id - вспомогательный параметр
// type - тип возвращаемого значения - bool, int, HRESULT и т.д.
// report_policy - одна из вышеприведённых стратегий информирования об ошибке
template<int id, typename type = bool, typename report_policy = error_report_policy>
class checked_result
{
public:
    checked_result(type value)
        : value_(value)
    {}

    operator type ()
    {
        // Обращаемся к классу result_check_helper<id>
        // ниже будет видно зачем
        result_check_helper<id>::fake();
        return value_;
    }

    ~checked_result()
    {
        // ЗДЕСЬ!
        // Определяем есть ли класс result_check_helper<id>,
        // что фактически равнозначно тому, вызывается operator type () или нет!
        __if_not_exists (result_check_helper<id>)
        {
            report_policy::report<void>();
        }
    }

private:
    type value_;
};

// Вспомогательный класс для передачи уникальных идентификаторов вызова
template<int id> struct long_and_inconvenient_name {static const int id = id;};

// Вспомотельный макрос для генерации уникальных идентификаторов вызова
// В реальности надо какое-то более длинное имя, чем ID, но здесь для простоты так
#define ID long_and_inconvenient_name<__COUNTER__>()

// Вспомогательный макрос
#define RESULT_CHECK_PARAM long_and_inconvenient_name<id>

// Функции для явного игнорирования возвращаемого значения
inline void ignore_result(bool) {}
inline void ignore_result(int) {}
//...

fff(1, ID /* - фээ некрасиво */ );

struct ignore_result_t {};

#    define ignore_result ( ignore_result_t() )

class checked_result
{
  ...
    void operator () ( ignore_result_t )
    {
        result_check_helper<id>::fake();
    }
  ...
}


int main()
{
    fff(2, ID) ignore_result; // Компилируется
}

Microsoft specific

R>template<int id>
R>checked_result<id> fff_wrap(int param, RESULT_CHECK_PARAM)
R>{
R>    return 0 == param;
R>}
R>

R>int main()
R>{
R>    bool b1 = fff(1, ID); // Компилируется
R>    ignore_result(fff(2, ID)); // Компилируется
R>    if (fff(2, ID)); // Компилируется
R>    fff(1, ID); // НЕ Компилируется! error C2027: use of undefined type 'boost::STATIC_ASSERTION_FAILURE<x>'
R>}
R>

   [cut]

R>

IRO>fff(1, ID /* - фээ некрасиво */ ); 
IRO>

IRO>

func_with_very_important_result(1);

IRO>Могу еще предложить вот такой забавный трюк

fff(2, ID) ignore_result;

ignore_result(fff(2, ID));}

some_func_with_long_name(/*много параметров*/, ID) /* за границей экрана*/ ignore_result;

J>Я может дальше и читать бы не стал

В gcc для этих целей есть __attribute__((warn_unused_result)). Но что делать пользователям msvc?

J>

R>>

CopyFile(lpExistingFileName, lpNewFileName, FALSE);

R>fff(2, ID) ignore_result; 
R>

R>ignore_result(fff(2, ID));}
R>

Могу еще предложить вот такой _забавный_ трюк

template<int id> checked_result<id> fff_wrap(int param, RESULT_CHECK_PARAM)
{
    static bool first_call(true);

    if(first_call)
    {
        first_call    = false;
        std::cout << "first call " << __FUNCTION__ << std::endl;
    }
    else
    {
        std::cout << "second call " << __FUNCTION__ << std::endl;
    }
    return 0 == param;
}

int _tmain(int argc, _TCHAR* argv[])
{
    //bool b1 = fff_wrap(1, ID); // Компилируется
    
    if (fff_wrap(2, ID)); // Компилируется
    if (fff_wrap(2, ID)); // Компилируется
    std::cout << std::endl;

    for(int i = 0; i < 2; ++i)
    {
        if (fff_wrap(2, ID)); // Компилируется
    }
    _getch();
    return 0;
}

template<int id> checked_result<id> fff_wrap(int param, RESULT_CHECK_PARAM)
{
  return fff(param);
}

if( foo( 1, 2 ) );