可调用对象是可以像函数一样调用的对象，语法为object()或object(args);即函数指针或重载operator()的类类型的对象。
类中operator()的重载使其可调用。

这里有两个步骤。在C++标准中，“函数对象”是可以出现在带括号的参数列表左侧的对象，即指向函数的指针或类型具有一个或多个operator()的对象。术语“可调用对象”更广泛：它还包括指向成员的指针（不能用普通函数调用语法调用）。可调用对象是可以传递给std::bind等的对象。参见20.8.1 [func.def]和20.8[function.objects]/1。

可调用对象是operator()重载的类的对象示例：

struct Functor {
    ret_t operator()();
    // ...
}

Functor func;  // func is a callable object

或一个被取消引用的函数指针：

ret_t func() {
   // ...
}

func;  // func converts to a callable object

一个至少有一个重载operator()的对象是一个可调用对象，并且这个操作符加上它的对象可以像调用函数一样被调用：

CallableClass obj;
obj();

在C++11中，可调用元素可以是：

• 函数指针，
• 成员函数指针，（与上一个不同，检查here）
• 一个函子类的对象（一个实现了其operator（）的类），
• 匿名函数（λ），
• 或者 Package 在std::function对象中的上述任何元素。

这意味着你可以使用上面提到的每一个可调用元素来启动一个std：：thread。

std::vector<int> v{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };

int func()
{
   return std::accumulate(v.begin(), v.end(), 1, std::multiplies<int>());
}

class A
{
public:
   int mem_func() 
   { 
      return std::accumulate(v.begin(), v.end(), 1, std::multiplies<int>());
   }
};

class B
{
public:
   int operator()()
   {
      return std::accumulate(v.begin(), v.end(), 1, std::multiplies<int>());
   }
};

auto lambda = []() { return std::accumulate(v.begin(), v.end(), 1, std::multiplies<int>()); };

void main()
{
   A a;
   B b;

   std::function<int()> f1 = &func;
   std::function<int()> f2 = std::bind(&A::mem_func, &a);
   std::function<int()> f3 = std::bind(&B::operator(), &b);
   std::function<int()> f4 = lambda;

   std::thread t1 = std::thread(func);
   std::thread t2 = std::thread(&A::mem_func, a);
   std::thread t3 = std::thread(&B::operator(), b);
   std::thread t4 = std::thread(lambda);

   std::thread t5 = std::thread(f1);
   std::thread t6 = std::thread(f2);
   std::thread t7 = std::thread(f3);
   std::thread t8 = std::thread(f4);

   t1.join();
   t2.join();
   t3.join();
   t4.join();
   t5.join();
   t6.join();
   t7.join();
   t8.join();
}

从C++17开始，Callable对象由标准定义;有关详细信息，请参见https://en.cppreference.com/w/cpp/named_req/Callable。

函数对象添加成员函数指针产生了可调用对象。当我们在c++ 98/03中使用类重写操作符时（）作为函数。一般我们称之为类函数。它具有存储函数状态的优点，而其他函数不能。因此它是最重要的概念。而边界，我们称这种风格的类函数和其他的c风格函数以及指向c风格函数的指针为“函数对象”。2可调用对象就是“可调用”对象。3它包括函数对象和成员函数指针。