ATL / WTL / STL

template <typename T> 
class CSelfDeleteWindow : public CWindowImpl<CSelfDeleteWindow, T> {
   typedef CSelfDeleteWindow<T> ThisClass;
  
public:
   DECLARE_WND_SUPERCLASS(NULL, T::GetWndClassName())
 
   BEGIN_MSG_MAP(ThisClass)
   END_MSG_MAP()
 
   CSelfDeleteWindow(T& wnd) {
      ATLVERIFY(SubclassWindow(wnd));
      wnd.Detach();
   }
 
   void OnFinalMessage(HWND hWnd) {
      delete this;
   }
};

CButton btn;
btn.Create(*this,  CRect(0, 0, 100, 100), _T("Yo yo"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON);
new CSelfDeleteWindow<CButton>(btn);

<br />
typedef CFrameWindowImpl<NoteWindow, ATL::CWindow, CMyWindowTraits> CMyFrameWindow;<br />
<br />
class NoteWindow : public CMyFrameWindow, <br />
                   publicCUpdateUI<NoteWindow>,<br />
	           public CMessageFilter, <br />
                   public CIdleHandler 

template<typename T> size_t Sizeof()
{
T* p1 = (T*) 100, *p2 = p1+1;
 
  return (BYTE*) p2 - (BYTE*) p1;
}
 
size_t n = Sizeof<int>();

template <typename T> size_t Sizeof() {
    return sizeof T;
}

template <typename T> struct size_of : public std::generator<size_t> {
   size_t operator()() {
      return sizeof T;
   }
};

template <typename T> struct size_of : public std::unary_function<size_t, T> {
   size_t operator()(const T& v) {
      return sizeof v;
   }
};

void closer(const std::pair<string,ofstream*>& toClose)
{
    toClose.second->close();
}

for_each(outputFiles.begin(), outputFiles.end(), closer);

template <typename TPair>
struct select_second : public std::unary_function<TPair, typename TPair::second_type> {
      result_type operator()(argument_type p) const {
      return p.second;
   }
};

// It takes 2 functors, f and g, and compose them into f o g, i.e., f(g(x))
template <typename F, typename G>
struct composed_fn : public std::unary_function<typename G::argument_type, typename F::result_type> {
   const G& g;
   const F& f;
   composed_fn(const F& f_, const G& g_) : g(g_), f(f_) { }
 
   result_type operator()(argument_type x) const {
      return f(g(x));
   }
};
 
template <typename F, typename G>
composed_fn<F, G> compose(const F& f, const G& g) {
   return composed_fn<F, G>(f, g);
}

for_each(outputFiles.begin(), outputFiles.end(), compose(std::mem_fun(&std::ofstream::close), select_second<FileMap::value_type>()));