C++ STL模板与类成员指针

 在C++模板里面把类的成员作为指针变量， mem_ref(Member Class::*m) 这里类似 uint32_t ChokeManager::a做为参数 传入.

 我用下面的例子做了验证

 

// 
// fun.h
//
#include "stdafx.h"
#include <iostream>  
#include <utility>
#ifndef RAK_FUNCTIONAL_H
#define RAK_FUNCTIONAL_H

#include <cstddef>
#include <functional>

namespace rak {
	
template <typename Type, typename Ftor>
struct less_t {
  typedef bool result_type;

  less_t(Type t, Ftor f) : m_t(t), m_f(f) {}

  template <typename Arg>
  bool operator () (Arg& a) {
	//cout << "operator less_t" << endl;
    return m_t < m_f(a);
  }

  Type m_t;
  Ftor m_f;
};

template <typename Type, typename Ftor>
inline less_t<Type, Ftor>
less(Type t, Ftor f) {
  return less_t<Type, Ftor>(t, f);
}

template <typename FtorA, typename FtorB>
struct less2_t : public std::binary_function<typename FtorA::argument_type, typename FtorB::argument_type, bool> {
  less2_t(FtorA f_a, FtorB f_b) : m_f_a(f_a), m_f_b(f_b) {}

  bool operator () (typename FtorA::argument_type a, typename FtorB::argument_type b) {
    return m_f_a(a) < m_f_b(b);
  }

  FtorA m_f_a;
  FtorB m_f_b;
};

template <typename FtorA, typename FtorB>
inline less2_t<FtorA, FtorB>
less2(FtorA f_a, FtorB f_b) {
  return less2_t<FtorA,FtorB>(f_a,f_b);
}

template <typename Class, typename Member>
struct mem_ref_t : public std::unary_function<Class&, Member&> {
  mem_ref_t(Member Class::*m) : m_member(m) {
 	//  cout << "mem_ref_t operator 0" << endl;
  }

  Member& operator () (Class& c) {
	 // cout << "mem_ref_t operato1r:" << c.*m_member << endl;
	  return c.*m_member;
  }

  Member Class::*m_member;
};

template <typename Class, typename Member>
struct const_mem_ref_t : public std::unary_function<const Class&, const Member&> {
  const_mem_ref_t(const Member Class::*m) : m_member(m) {}

  const Member& operator () (const Class& c) {
	//cout << "const_mem_ref_t operato001" << endl;
    return c.*m_member;
  }

  const Member Class::*m_member;
};

template <typename Class, typename Member>
inline mem_ref_t<Class, Member>
mem_ref(Member Class::*m) {
 // cout << "mem_ref0" << endl;
  return mem_ref_t<Class, Member>(m);
}

template <typename Class, typename Member>
inline const_mem_ref_t<Class, Member>
const_mem_ref(const Member Class::*m) {
	 // cout << "const_mem_ref" << endl;
	return const_mem_ref_t<Class, Member>(m);
}

}


#endif

//
//main.cpp
//
#include <string>  
#include "fun.h"
#include <vector>
#include <iterator>
#include <algorithm>
using namespace std;  

typedef  unsigned int uint32_t;

class PeerConnectionBase 
{
public:
	uint32_t x;
};

class ChokeManager {
public:
	  std::vector<std::pair<PeerConnectionBase*, uint32_t> > container_type1;
	  typedef std::vector<std::pair<PeerConnectionBase*, uint32_t> > container_type;
	  typedef container_type::value_type                             value_type;
	 
	  bool less(uint32_t priority);	 
	  ChokeManager(uint32_t x):a(x){}

	  uint32_t a;
};

bool ChokeManager::less(uint32_t priority)
{
	bool res = false;

	res = rak::less(priority, rak::mem_ref(&ChokeManager::a))(*this);
	return res;
}


int _tmain(int argc, _TCHAR* argv[])
{
	bool res = false;
	ChokeManager cls1(8);
	
	res = cls1.less(7);
	cout << "res0:" <<res << endl; 

	res = cls1.less(9);
	cout << "res1:" <<res << endl; 

	system ( "pause" ); 
	return 0;

}