c++ The compile error : unresolved overloaded funciton type

//收获总结：(1)使用sort(RMiterator,RMiterator,comp)进行排序时，comp不应为某个类的非静态成员函数，因为类的成员函数有一默认形参this指针。参数个数可能与sort
//函数中comp实际所需形参个数不同。编译时会出现"unresolved overloaded function type",因此应该将comp定义为非成员函数或静态的成员函数。
//(2)将字符串中的数据//依次读入到不同类型的变量当中，采用stringtream,现将字符串写到stringtream类型的变量当中，然后在从stringtream变量当中读数据到不同类
//型的变量当中。
//(3)排列组合编程技巧：可以将一切排列组合问题转换为阶乘的形式，而阶乘可以采用递归编程，然后调用递归小程序进行排列组合计算。
//(4)采用long double（扩展精度浮点型），可以解决大多数类似于"floating point exception".


//This is a feasible solutin for "1_SRM_144DIV1_Lottery" on topCoder.
class Lottery  
{ 
 public:  
        vector <string> sortByOdds(vector<string> rules) {
                vector<pair<string,long double> >vec;
                for(vector<string>::iterator ite = rules.begin(); ite != rules.end(); ++ite){
                        pair<string,long double> ret = calc(*ite);
                        vec.push_back(ret);
                }
                sort(vec.begin(),vec.end(),myComp);
                vector<string> vec_ret;
                for(vector<pair<string,long double> >::iterator ite = vec.begin(); ite != vec.end(); ++ite){
                        vec_ret.push_back((*ite).first);
                }
                return vec_ret;
            }
    
 private:
	//总结（1）实例
       static bool myComp(const pair<string,long double>& p1,const pair<string,long double>& p2){
                        return p1.second < p2.second;
        }
 //总结（2）（4）实例 
        long double jiech(size_t n){ 
              if(n == 1 || n == 0)
                     return 1;
              else 
                    return n * jiech(n - 1); }
	//组合问题
        long double  TT(size_t n,size_t m){ 
                return jiech(n) / (jiech(n - m) * jiech(m));
        }
        long double  TF(size_t n,size_t m){
                long double sum = 0;
                for(int i = 0; i < m; ++i){
                        sum += TT(m - 1,i) * TT(n,i + 1);
                }
                return sum;
        }
        long double FT(size_t n,size_t m){
                return jiech(n) / jiech(n - m);
        }

        long double FF(size_t n,size_t m){
                return pow(n,m);
        }
        pair<string,long double> calc(const string& str){//str中存储格式类似于"PICK TWO LIMITED: 10 2 T T"
                string::size_type pos = str.find(':');
                string name(str.begin() + 1,str.begin() + pos);
                string left = str.substr(pos + 1);
		//总结（2）实例
                stringstream ss(left);
                size_t choices;
                size_t blanks;
                char sorted;
                char unique;
                ss >> choices;
                ss >> blanks;
                ss >> sorted;
                ss >> unique;
                long double count;
                if(sorted == 'T' && unique == 'T') count = TT(choices,blanks);
                if(sorted == 'T' && unique == 'F') count = TF(choices,blanks);
                if(sorted == 'F' && unique == 'T') count = FT(choices,blanks);
                if(sorted == 'F' && unique == 'F') count = FF(choices,blanks);
                return make_pair(name,count);
        }
}