Aprenda std::function Introduction | Functional Foundations in C++

Understanding how to store and invoke different types of callable entities is central to writing expressive and flexible C++ code. std::function is a powerful utility that allows you to store any callable object—such as regular functions, lambda expressions, or function objects—in a uniform way. This flexibility is particularly useful when you want to pass functions as arguments, return them from other functions, or keep them in containers. The main advantage of std::function is that it abstracts away the specific type of the callable, letting you treat all callables with the same signature as the same type.

main.cpp


              12345678910111213141516171819202122
            
#include <iostream>
#include <functional>

// A regular function
void greet() {
    std::cout << "Hello from a function!" << std::endl;
}

int main() {
    // Assign a lambda to std::function
    std::function<void()> sayHello = []() {
        std::cout << "Hello from a lambda!" << std::endl;
    };
    sayHello(); // Calls the lambda

    // Assign a function pointer to std::function
    std::function<void()> greetFunc = greet;
    greetFunc(); // Calls the regular function

    return 0;
}

The underlying mechanism that enables std::function to store any callable with a matching signature is known as type erasure. Type erasure allows you to work with different types of callables without knowing their exact types at compile time. When you assign a lambda, function pointer, or function object to a std::function, the details of the callable's type are hidden, and you interact with all of them through a consistent interface.

You should use std::function when you need to store or pass around callable entities with a common signature, especially in cases where the exact type of the callable may vary. This is common in callback mechanisms, event systems, and generic programming patterns where flexibility and decoupling are desired. However, keep in mind that std::function introduces a small runtime overhead due to type erasure, so if performance is critical and the callable type is known, prefer alternatives like function pointers or templates.

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 1. Capítulo 3

Pergunte à IA

Pergunte o que quiser ou experimente uma das perguntas sugeridas para iniciar nosso bate-papo

Deslize para mostrar o menu

main.cpp


              12345678910111213141516171819202122
            
#include <iostream>
#include <functional>

// A regular function
void greet() {
    std::cout << "Hello from a function!" << std::endl;
}

int main() {
    // Assign a lambda to std::function
    std::function<void()> sayHello = []() {
        std::cout << "Hello from a lambda!" << std::endl;
    };
    sayHello(); // Calls the lambda

    // Assign a function pointer to std::function
    std::function<void()> greetFunc = greet;
    greetFunc(); // Calls the regular function

    return 0;
}

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 1. Capítulo 3