Inside std::function, part 1: The basic idea
source link: https://devblogs.microsoft.com/oldnewthing/20200513-00/?p=103745
Go to the source link to view the article. You can view the picture content, updated content and better typesetting reading experience. If the link is broken, please click the button below to view the snapshot at that time.
Inside std::function
, part 1: The basic idea
Raymond
May 13th, 2020
The C++ language standard library comes with a std::function
template type which represents a “thing you can invoke”. It can hold any callable, such as
operator()
The way this is done is with the assistance of a polymorphic helper object that understands the specific callable it is wrapping.
Here’s a sketch. For concreteness, let’s say we’re implementing std::function<bool(int, char*)>
. For readability, I’ve de-uglified¹ the identifiers.
struct callable_base { callable_base() = default; virtual ~callable_base() { } virtual bool invoke(int, char*) = 0; virtual unique_ptr<callable_base> clone() = 0; }; template<typename T> struct callable : callable_base { T m_t; callable(T const& t) : m_t(t) {} callable(T&& t) : m_t(move(t)) {} bool invoke(int a, char* b) override { return m_t(a, b); } unique_ptr<callable_base> clone() override { return make_unique<callable>(m_t); } }; struct function { std::unique_ptr<callable_base> m_callable; template<typename T> function(T&& t) : m_callable(new callable<decay_t<T>> (forward<T>(t))) { } function(const function& other) : m_callable(other.m_callable ? other.m_callable->clone() : nullptr) { } function(function&& other) = default; bool operator()(int a, char* b) { // TODO: bad_function_call exception return m_callable->invoke(a, b); } };
The idea is that each function
has a callable_base
, which is an interface that allows us to perform basic operations on callable objects: Create a copy, invoke it, and destroy it. Invoking the function
forwards the invoke to the callable_base
. Copying the function
requires a special clone
method on the callable_base
, because unique_ptr
is not copyable.
Constructing the function
is a matter of creating a custom callable
for the specific functor. It’s conceptually simple, but the C++ language makes us write out a bunch of stuff to get it to work. We just want a callable that wraps the thing that was passed to the constructor.
The std::function
in the standard library is basically like this, but with additional optimizations to avoid an allocation in the case of a small callable
. Said optimizations are in fact mandatory by the standard if the callable is a plain function pointer or a reference_wrapper
.
We’ll look at that optimization next time, because it gives us some insight into how we can do similar things with our own types.
¹ Uglification is the process of taking readable names and transforming them into names that are reserved for the implemenmtation. Different libraries have different uglification conventions. For the Microsoft Visual C++ implementation of the standard library, the uglifications tend to be
_My _Ty _Fn _P _
Recommend
About Joyk
Aggregate valuable and interesting links.
Joyk means Joy of geeK