so true

現(xiàn)在越來越懶了，雖然積累的知識越來越多，但寫出來的東西越來越少。
趁還有點心情，把剛看的關于safe bool的東西寫到這里：

相關url： http://www.artima.com/cppsource/safeboolP.html

這頁面上的code有問題，經過調試，并借鑒了一部分http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Safe_bool里面提到的東西，整理了一份可以編譯的code：

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <set>

using namespace std;

  class safe_bool_base {
  protected:
    void this_type_does_not_support_comparisons() const {}
    typedef void (safe_bool_base::*bool_type)() const;

    safe_bool_base() {}
    safe_bool_base(const safe_bool_base&) {}
    safe_bool_base& operator=(const safe_bool_base&) {return *this;}
    ~safe_bool_base() {}
  };

  template <typename T=void> class safe_bool : private safe_bool_base {
  public:
    operator bool_type() const {
      return (static_cast<const T*>(this))->boolean_test() ? &safe_bool<T>::this_type_does_not_support_comparisons : 0;
    }
  protected:
    ~safe_bool() {}
  };

  template<> class safe_bool<void> : private safe_bool_base {
  public:
    operator bool_type() const {
      return boolean_test()==true ? &safe_bool<void>::this_type_does_not_support_comparisons : 0;
    }
  protected:
    virtual bool boolean_test() const=0;
    virtual ~safe_bool() {}
  };

  template <typename T>
   bool operator==(const safe_bool<T>& lhs, bool b) {
      return (lhs) ? b : !b;
  }

  template <typename T>
   bool operator==(bool b, const safe_bool<T>& rhs) {
      return (rhs) ? b : !b;
  }

  template <typename T, typename U>
    void operator==(const safe_bool<T>& lhs,const safe_bool<U>& rhs) {
      lhs.this_type_does_not_support_comparisons();
      return false;
  }

  template <typename T,typename U>
  void operator!=(const safe_bool<T>& lhs,const safe_bool<U>& rhs) {
    lhs.this_type_does_not_support_comparisons();
    return false;  
  }

  class Testable_with_virtual : public safe_bool<> {
  protected:
    bool boolean_test() const {
      // Perform Boolean logic here
      return true;
    }
  };

#if (1)
  class Testable_without_virtual :
    public safe_bool <Testable_without_virtual> {
  public:
    bool boolean_test() const {
      // Perform Boolean logic here
      return true;
    }
  };
#else
  class Testable_without_virtual :
    private safe_bool <Testable_without_virtual> {
    template <typename T> friend class safe_bool;
  public:
    using safe_bool<Testable_without_virtual>::operator bool_type;

    bool boolean_test() const {
      return true; // Logic goes here!
    }
  };
#endif

int main(int argc, char* argv[])
{
    Testable_without_virtual t;
    if (t) {
        cout << "OK" << endl;
    } else {
        cout << "FAIL" << endl;
    }

    Testable_with_virtual t2;
    if (t2 == true && true == t2) {
        cout << "OK" << endl;
    } else {
        cout << "FAIL" << endl;
    }

    return 0;
}

當然，上面的代碼里有很多技巧，不光是safe bool idiom，對于平日里寫代碼時，值得借鑒的是：
class A {
    typedef void* A::*unspecified_bool_type;
public:
    /* //別再寫這這樣的conversion了，用下面的那個
    operator bool() const {
        return _pointer ? true : false;
    }
    */
    operator unspecified_bool_type() const {
        return _pointer ? &A::_pointer : NULL;
    }

private:
    void* _pointer;
};