Open-Source C++ Programming Certification | OSC++.033 | C++17 Standard Library | Topic: std::invoke.

Elementary Overview

C++ can call a regular function, a lambda, or a function object with familiar parentheses. Pointers to class member functions, however, need special syntax. std::invoke, available since C++17 in the <functional> header, provides one consistent way to invoke these different kinds of callable targets.

This lesson follows OSC++.032 on std::function and callable objects. The difference is important: std::function is a type-erased wrapper that stores a compatible callable; std::invoke is a function template that calls a supplied target. You do not need to construct a std::function to use std::invoke.

Learning Objectives

• Recognize free functions, lambdas, and member pointers as targets that can be used with std::invoke.
• Call a member function through an object using the correct argument order.
• Distinguish a pointer to member data from a pointer to member function.
• Use std::is_invocable_v to check a callable signature at compile time.
• Identify where std::invoke is useful without claiming that it makes code faster.

One Interface for Different Callables

The usual form is std::invoke(target, arguments...). For a regular function pointer or lambda, this behaves much like a normal function call. For a member function pointer, the first argument after the target identifies the object on which the function will operate; subsequent arguments go to that member function.

For example, std::invoke(&Miner::bring_online, rig, 4) invokes the bring_online member function on rig and passes 4 to it. This is an introduction to callable invocation, not another tutorial on storing callbacks in std::function.

Complete C++17 Example

The small example below represents a mining-facility status counter. It intentionally uses ordinary integers rather than actual control equipment. The final line checks a type signature with the standard type-traits library.

#include <functional>
#include <iostream>
#include <type_traits>

struct Miner {
    int online = 2;
    int bring_online(int count) { online += count; return online; }
};

int double_it(int value) { return value * 2; }

int main() {
    Miner rig;
    auto add_one = [](int value) { return value + 1; };

    std::cout << std::invoke(double_it, 3) << '\n';
    std::cout << std::invoke(add_one, 6) << '\n';
    std::cout << std::invoke(&Miner::bring_online, rig, 4) << '\n';
    std::cout << std::invoke(&Miner::online, rig) << '\n';
    std::cout << std::boolalpha
              << std::is_invocable_v<decltype(&Miner::bring_online), Miner&, int>
              << '\n';
}

Compile with a C++17-capable compiler, for example g++ -std=c++17 invoke.cpp -o invoke && ./invoke. The expected console output is 6, 7, 6, 6, and true, each on its own line. The code was compiled and executed with g++ -std=c++17 -Wall -Wextra -pedantic during lesson preparation, producing exactly those results.

Why the Two Member-Pointer Calls Differ

&Miner::bring_online points to a member function that accepts an integer and returns an integer. &Miner::online points to a member data field. With std::invoke, the latter accesses the field rather than calling a function. This distinction is a common source of confusion when programmers first learn the C++ standard’s definition of a callable.

A pointer to member function is not the same as a normal function pointer. The invocation machinery needs to know which object supplies this. The standard rules also permit suitable object pointers and std::reference_wrapper arguments. Those are useful later when designing generic algorithms and libraries.

Community discussion: programmers examine why the C++ definition of a callable includes member pointers. The linked discussion is a learning prompt; for the exact language and standard-library rules, rely on the references below.

Checking Whether a Call Is Valid

std::is_invocable_v<F, Args...> is a C++17 compile-time boolean that asks whether a callable of type F could be invoked with the specified argument types. In the example, the member-function pointer, a Miner& object, and an int argument form a valid combination, so the result is true. This check does not execute the target.

Where std::invoke Fits in a Larger Program

Generic code often receives a callable as a template parameter without knowing whether the caller supplied a function, lambda, functor, or member pointer. std::invoke helps that generic code use one invocation expression. For a beginner, its most visible benefit is clearer handling of member pointers, not a promise of performance gains.

Related lessons include OSC++.023 on perfect forwarding, OSC++.031 on std::any, and OSC++.030 on std::variant. They cover adjacent but distinct parts of C++ generic programming.

Common Mistakes

• Forgetting the object: a pointer to an instance member function needs an object or suitable object-like argument.
• Confusing the facilities: std::invoke calls a target; std::function can own a callable behind a particular signature.
• Using the wrong language mode: std::invoke requires C++17 or later.
• Assuming every target is a function: a data-member pointer can be invoked under the standard’s INVOKE rules to access a member.
• Inferring speed: there is no blanket guarantee that one spelling performs better than another.

Knowledge Check

• 1. Which standard introduced std::invoke? C++17.
• 2. Which header declares it? <functional>.
• 3. What additional argument does a member-function pointer need? The object on which it operates.
• 4. Does std::is_invocable_v call the function? No. It checks call validity at compile time.

Key Takeaways

• std::invoke unifies calls to ordinary functions, lambdas, function objects, and class-member pointers.
• Member-function pointers need an object argument; member-data pointers access a field.
• std::invoke and std::function solve different problems.
• Use the C++17 language mode and compile examples to verify behavior.

References

• cppreference — std::invoke and std::invoke_r.
• cppreference — Callable Named Requirements.
• KDAB — Implementing std::invoke in C++14 (historical discussion of implementing comparable behavior before C++17).

BitcoinVersus.Tech Editor’s Note: We volunteer daily to ensure the credibility of the information on this platform is Verifiably True. If you would like to support to help further secure the integrity of our research initiatives, please donate using the QR code provided

For best QR-code scanning results, please scan this donation code from a desktop or larger screen. Mobile screens may prevent camera recognition.