Что такое вызываемый объект в C++?

Вызываемый объект — это то, что можно вызвать как функцию с синтаксисом 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++17 объект Callable фактически определяется стандартом; см. https://en.cppreference.com/w/cpp/named_req/Callable подробности.

Объект функции добавляет указатели на функции-члены, что дает то, что известно как вызываемые объекты. Когда мы в С++ 98/03, мы используем класс, переопределяющий оператор () как функцию. В общем, мы называем эту функцию класса. Преимущество заключается в сохранении состояния функции, а другая функция не может. самая важная концепция. И граница, мы называем эту функцию класса стиля и другую функцию стиля c и указатель на функцию стиля c «объект функции». Вызываемый объект - это просто "вызываемый" объект. Он включает в себя объект функции и указатели функций-членов.

В C++11 вызываемый элемент может быть:

• Указатель функции,
• Указатель функции-члена (он отличается от предыдущего, проверьте здесь)
• Объект класса функтора (класс, в котором реализован его оператор()),
• Анонимные функции (лямбды),
• Или любой из упомянутых элементов, заключенный в объект 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();
}