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

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) {}
//...

// C++
#include <codeanalysis\sourceannotations.h>
using namespace vc_attributes;
[returnvalue:Post(MustCheck=Yes)] int fff();

EvalVariantQuality( ... );
CloseAllActiveConnections( ... )
CopyFiles( ... );

class CFilesCopyist {
public:
    CFilesCopyist();
    CFilesCopyist( const char* Src, const char* Dst, DWORD mode );
    ~CFilesCopyist();

    //   Установка дополнительных параметров
    void SetSrcPath( const char* );
    void SetDstPath( const char* );
    void SetWildcard( const char* );

    void SetCopyMode( DWORD mode );
    bool IsParamsCorrect();

    void CopyFiles();

    int GetCopiedFilesCount() const;
};

R>

Write code instead of comments where possible.

(Herb Sutter, Andrei Alexandrescu. C++ Coding Standards: 101 Rules, Guidelines, and Best Practices)

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; // Компилируется
}

R>>

CopyFile(lpExistingFileName, lpNewFileName, FALSE);

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

if( foo( 1, 2 ) );

result r = foo( ... );

r.check_result(); // для подтверждения того что я оттестил. тогда я хоть по ctrl + F смогу отыскать все такие места, и поправить если что забыл..

E>>Называй функции понятнои с простой и ясной семантикой, избегая при этом всяких синтаксических трюков и неявно генерирующегося и вызываемого кода -- и будет тебе счастье

R>CopyFile(lpExistingFileName, lpNewFileName, FALSE);
R>

E>>EvalVariantQuality( ... );
E>>CloseAllActiveConnections( ... )
E>>CopyFiles( ... );
E>>

E>>Вообще искоренит проблему на корню

while(cmd.CanFetch() ) {
    cmd.Fetc();
}

cmd.Fetch();    //     Эта запись всегда есть. Ну просто зуб даю!!!

if( !cmd.CanFetch() ) {
    //   тут какая-то хитрая обработка, отличная от просто ошибки в Fetch
} else {
    cmd.Fetch();
}

while( cmd.FetchIfCan() ) {
    //  тут чего-то, что надо
}

cmd.Fetch();    //     Эта запись всегда есть. Ну просто зуб даю!!!

if( !cmd.FetchIfCan() ) {
    //   тут какая-то хитрая обработка, отличная от просто ошибки в Fetch
}

I'm very happy with this solution. Of course, it still doesn't prevent
perverse programmers from saying:

(bool) Fun();

but I ignore perversity. I care only about carelesness.

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>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);
}

R>// C++
R>#include <codeanalysis\sourceannotations.h>
R>using namespace vc_attributes;
R>[returnvalue:Post(MustCheck=Yes)] int fff();
R>

Compiling...
cl : Command line warning D9040 : ignoring option '/analyze'; Code Analysis warnings are not available in this edition of the compiler

R>ХЗ, у меня TeamSuite , а в MSDN не написано про то в каких эдишнах это работает.

/analyze is only available in Enterprise (team development) versions for x86 compilers.

E>Называй функции понятнои с простой и ясной семантикой, избегая при этом всяких синтаксических трюков и неявно генерирующегося и вызываемого кода -- и будет тебе счастье

CopyFile(lpExistingFileName, lpNewFileName, FALSE);

E>EvalVariantQuality( ... );
E>CloseAllActiveConnections( ... )
E>CopyFiles( ... );
E>

E>Скажем функция CopyFiles( ... ) ничего не возвращает, а GetCopiedFilesCount() -- возвращает

E>class CFilesCopyist {
E>public:
E>    CFilesCopyist();
E>    CFilesCopyist( const char* Src, const char* Dst, DWORD mode );
E>    ~CFilesCopyist();

E>    //   Установка дополнительных параметров
E>    void SetSrcPath( const char* );
E>    void SetDstPath( const char* );
E>    void SetWildcard( const char* );

E>    void SetCopyMode( DWORD mode );
E>    bool IsParamsCorrect();

E>    void CopyFiles();

E>    int GetCopiedFilesCount() const;
E>};

E>Вообще искоренит проблему на корню

class DBCmd
{
...
   bool Fetch();
...
};

DBCmd cmd;
...
while (cmd.Fetch())
{
  ...
}

DBCmd cmd;
...
if (!cmd.Fetch())
  обработка_ошибки

DBCmd cmd;
...
cmd.Fetch();

R>>

E>Да не вопрос!