A teeny tiny example about Function Objects

using std::cin; using std::cout; using std::endl;

template <typename Object, typename Comparator>

const Object &findMax(const std::vector<Object> &arr, Comparator cmp)
{
	int maxIndex = 0;

	for(int i = 1; i < arr.size(); ++i)
		if(cmp(arr[ maxIndex ], arr[ i ]))
			maxIndex = i;
	return arr[ maxIndex ];
}

class ShorterString 
{
public:
	ShorterString()
	{
		cout << "Constructed!" << endl;
	}
	bool operator()(const std::string &s1, const std::string &s2) const
	{ 
		return s1.size() < s2.size(); 
	} 
};

int main()
{
	std::vector<std::string> vec = {"ZEBRA", "alligator", "crocodile"};
	auto f = [](const std::string &lhs, const std::string &rhs){return lhs < rhs;};
	cout << findMax(vec, f);
	// cout << findMax(vec, ShorterString()); cout << findMax(vec, ShorterString{});
	cout << endl;
	return 0;
}

Lambda is a function object. 

What I am trying to say is, when it comes to

priority_queue<string, vector<string>, ShorterString>, we can supply ShorterString here, but not Lambda, for Lambda is not a type.

Another example:

template <class T>
class myLess
{
public:
    bool operator()(T a, T b)
    {
        return a < b;
    }
};

template <class T, class comparator>
class myTest
{
private:
    T d1;
    T d2;
public:
    myTest():d1(0), d2(0){}
    myTest(T x, T y):d1(x),d2(y){}
    T getData() const {return d1;}
    bool lessThan(const myTest &other)
    {
        return comparator{}(this->getData(), other.getData());
    }
};

int main()
{
    myTest<int, myLess<int>> A(99,100), B(100,101);
    if(A.lessThan(B))
        cout << "True" << endl;
    else
        cout << "False" << endl;
    return 0;
}