DEV Community: Lesley Lai

What is std::function in C++, and why we need them?

Lesley Lai — Tue, 19 Jan 2021 11:31:39 +0000

Yesterday, someone in the #include discord server asked the following question:

how std::function works with lambda captures and functions handling I still don't understand

Below was my answer to the question, with some typo-fixes and expansions:

Invocables can have different types even if their parameter and return type are the same

Lambda expressions can be considered syntactic sugar over classes with operator() defined. For example:

int x = 3;
auto lambda = [x](int y) { return x + y; };

is roughly equivalent to

struct __Lambda {
  int x;

  int operator()(int y) const {
    return x + y;
  }
};

int x = 3;
auto lambda = __Lambda { .x = x };

One consequence is that every lambda expression has a distinct type. For example, in the below snippet,

int x, z;

auto lambda = [x](int y) { return x + y; };
auto lambda2 = [x, z](int y) { return x + y + z; };

lambda and lambda2 have different types, even though they both take an int and return an int.

C++ also have functions, which are distinct from classes with operator().

The motivation for `std::function`

Then, how do we store such an invocable object that takes an int and returns an int disregard of its types?

We need std::function to accomplish such a task. For example:

struct S {
  std::function<int(int)> func;
};

A canonical use case for storing an invocable in this fashion is a task system, where you probably want to store callbacks in a container to execute later:

struct TaskQueue {
  std::queue<std::function<void()>> queue;
  std::mutex mutex;
  std::condition_variable ready;

  // member functions
  ...
};

Type Erasure

To make func accepts both lambda and lambda2,
std::function needs to have constructors that take any function object or plain function that satisfies its signature.
And we need to perform type erasure to achieve this behavior.

There are various techniques to implement type erasure in C++,
and it is not a topic I can fit into this post. But the high-level idea is that std::function needs some function pointer that can invoke the lambda and some storage space to store lambda captures.
The data need to be allocated on the heap since lambda expressions (or invocable classes) can have arbitrary sized capture. However, all major std::function implementations also perform small buffer optimization if your lambda is small enough to fit into a predefined capacity. In that case, all data can be allocated directly inside the std::function object itself, and no additional heap allocation is performed.

Resources that help you to delve into C++

Lesley Lai — Sat, 16 Jan 2021 18:24:06 +0000

During the years, a lot of people ask me for help in learning C++. I am no C++ expert, but as a person who is doing C++ for years, I want to share a bunch of beginner-friendly C++ resources that are known to be of high quality.

When anyone asks me for guidance about getting into C++, I always ask first about their existing experiences. Some people just start to learn programming and decide to learn C++ as their first language, some people have learned a limited amount of C++ and want to learn more, and some of them are already programming veterans in other languages. Depend on your experiences, you probably want to start with different materials, and I try to cater to each of those backgrounds in this post.

One thing I want to mention, though, is that reading books or watching videos all the time is not the best strategy to learn. Whatever stage you are in, it is much easier to learn when you apply ideas into code, so spending time on coding projects helps.

What if I just start learning to program and choose C++ as my first language?

For books, I recommend Bjarne Stroustrup (the creator of C++) 's "Programming: Principles and Practice Using C++ 2nd edition" as a starting point.
The book is thick, so don't feel guilty if you cannot finish the whole book.

If you are more inclined toward tutorial videos,
look at Kate Gregory's Learn to Program with C++. If you join the #include discord server, You can also message her there to get a trial code.

What if I already learned some C++ before and want to delve in deeper?

What if you have some limited C++ experience before? Maybe you already learned some C++ from your university data structure course, or perhaps you followed some online tutorials that use C++. From my personal experiences and what I heard, most university programming courses or those online tutorials teach problematic practices, and the instructors often do not have a good grasp of the language. Thus, "learn from the best materials" is especially important for you to offset prior misconceptions on C++.

For books, I will still recommend either Bjarne Stroustrup's "Programming: Principles and Practice Using C++ 2nd edition". And for video tutorials, you can try Kate Gregory's C++ Fundamentals Including C++ 17.

What if I am a veteran in another language and want to delve into C++?

If you are already a proficient programmer in some other languages and want to delve into C++, you will have a faster pace journey than other learners.

As for book recommendations, Bjarne Stroustrup's "The C++ Programming Language (4th Edition)" was one of the best-written books I ever read, though do notice that this book was written with C++11 and misses some of the later developments. The book is also very thick, so if you want a shorter introduction, try "A Tour of C++ (Second edition)".

I think that I have a decent grasp of C++. What's next?

So you spend months with the above materials and feel that you have a decent grasp of basic C++ concepts.

A sanity check to make sure about your understanding of C++ is whether you are familiar with the following topics, to name a few:

how to use const
templates
references and pointers
usage of the standard library, in particular, iterator and algorithms
RAII
copy and move constructor and assignment
move semantics
operator overloading
lambda expressions and function objects
undefined behaviors

Now it is time to put C++ into practical usage. C++ is used for diverse purposes, and using C++ in specific areas is probably more critical than the C++ language itself. It is perhaps also a good time to spend some time on the broader C++ ecosystems, like unit test libraries such as Catch2, build system generators such as CMake, and package managers such as Conan.

Another thing to consider is to start learning another programming language, especially for folks who only know C++ at this point. Good next languages to pick are those very different from C++, for example, dynamically-typed languages such as Javascript, Python, or a Lisp dialect.

That being said, there is still a lot to learn about the C++ language itself. And I will try to list some resources that are still relative up-to-date and I enjoyed:

Books

If you haven't read "The C++ Programming Language (4th Edition)", I would still recommend it. And here is a bunch of other books I would like to recommend:

"Effective Modern C++" by Scott Mayer
"C++ Best Practices" by Jason Turner
"C++17 - The Complete Guide" by Nicolai M. Josuttis

Some books focus on specific areas of the language, such as:

"C++ Templates - The Complete Guide, 2nd Edition" by David Vandevoorde, Nicolai M. Josuttis, and Douglas Gregor
"Mastering the C++17 STL" by Arthur O'Dwyer
"Functional Programming in C++" by Ivan Čukić
"C++ Concurrency in Action, 2nd edition" by Anthony Williams

Conference Videos

Conference videos are also an excellent resource to learn more about C++. They focus on a diversity of topics; many of them are hard to find in books. And they also require low commitment (just spend an hour lunchtime watching some videos)

Here are some of my favorites that are also beginner-friendly:

Communities

Many people in the C++ community and I, am always willing to answer direct messaging questions. However, I, or most people you can contact online, have limited experiences.

To utilize the best wisdom of people, you need to join programming communities, and then you can ask questions in public and get a response from multiple people. ¹

Being active in programming communities also has numerous other benefits, including getting job information and having more social support.

#include

#include is a wonderful community to join. Its mission includes providing conference scholarship to people in need, but for most people,
you can join its discord server to hang out and talk about C++.

Local Meetups

Joining North Denver Metro C++ Meetup was one of the best decisions for me during my college years. I understand that it is a hard time to pop into meetups at the time of writing since most of them are currently held online. Nevertheless, I urge you to try to attend some meetups if you have time. Online meetings also provide some advantages compare to physical ones. For example, they require low commitment, and you can choose from all of those meetups worldwide.

Attending Conferences

If you are serious about C++, then conferences are great places to meet like-minded people. Same as meetups, one difficulty at the time of writing is that most C++ conferences are hosted online, but they are still worthwhile to consider. Here are some of the recurring C++ conferences I am aware of:

CppCon
C++Now (tuned toward a more advanced audience)
ACCU
Meeting C++
Pacific++
C++ on Sea
Core C++

There is a list of conferences on the ISO C++ website.

Listening to Podcasts

There are a bunch of C++ podcasts, including a few new ones appeared in 2020:

Following Blogs

I use RSS to keep track of the tech blogs, and I highly recommend you try out RSS too.

I follow hundreds of blogs, including C++ and various other topics. Here are some of the best C++ ones that pops into my head:

Do notice that blogs sometimes can talk about very advanced topics.

Twitter

It is your personal preference on whether to join Twitter or not. On the one hand, Twitter is a great platform to directly communicate with the programming communities and know what other people are up to. And personally, Twitter is the platform that I know so many exciting developers worldwide. On the other hand, Twitter has its downside with all the procrastinating and doomscrolling. Some tweets you see can also make you upset. My suggestion is to try Twitter out at least, and you can quit if it doesn't work for you.

Misc resources

Here are some misc resources that are also worth mentioning.
Some of those are great online tools, while others are video series.

cppreference should be your go-to site for C++ language and standard library reference, and it is usually a lot more accurate and up-to-date than its alternatives.
Compiler Explorer is an online coding environment that supports C++ and a dozen other languages. It can show the compiled assembly of your program and run your program. Unlike most online C++ coding environments, which often ship with an outdated compiler, there are many compilers to choose from in compiler explorer, including the most cutting-edge ones.
Quick C++ benchmark is an online tool to perform quick benchmarks on C++.
C++ Tips of the week
Kate Gregory's STL Algorithms course is a great resource to learn more about and appreciate C++ standard algorithms.
C++ Weekly is a Youtube channel on various C++ topics, posted weekly.

References and further reading

"SG20 Education And Recommended Videos For Teaching C++". Christopher Di Bella, 2021, https://www.cjdb.com.au/sg20-and-videos. Accessed 15 Jan 2021.
"References And Links". #Include ＜C++＞, 2021, https://www.includecpp.org/resources/references/. Accessed 16 Jan 2021.
Yaghmour, Shafik. "Where To Get Started Learing C++ And What Resources To Use". Shafik Yaghmour's Blog, 2019, https://shafik.github.io/c++/learning/2019/09/05/getting_started_learning_cpp.html. Accessed 16 Jan 2021.

Asking questions online is an art, and a poorly phrased question makes people don't know how to respond. Further, people are often too polite to point out that a question is poorly phrased. Kate Gregory's How to ask for C++ coding help is an excellent read on how to ask for help online. ↩

C++ Lambda Tutorial

Lesley Lai — Mon, 13 Jan 2020 00:16:34 +0000

C++ lambda expressions are a construct added to C++ back in C++11, and it continues to evolve in each version of the C++ standard. A core part of the language nowadays, lambda expressions enable programmers of writing anonymous functions in C++. This post describes what a lambda is, provides some basic usages, and outlines their benefits.

Basic Usage

Passing functions as a parameter to customize the behavior of functions is a common task in programming. For example, since the conception of standard algorithms library, a lot of the algorithms in the <algorithm> can take an invokable entity as a callback. However, before C++11, the only kinds of invokable entities in C++ are function pointers and function objects. Both of them require quite a bit of boilerplate, and this cumbersomeness even impedes the adaption of the standard algorithm library in practice.

On the meantime, lots of programming languages support features of anonymous functions. Before C++11, such features are achieved by metaprogramming. For example, the Boost C++ library provided its boost.lambda library. Those metaprogramming hacks are slow to compile and not performant; moreover, they require more boilerplate then one want. Thus, in C++11, lambda expressions are added as a language extension. The ISO C++ Standard shows usage of a lambda expression as a comparator of the sort algorithm. ¹

#include <algorithm>
#include <cmath>

void abssort(float* x, unsigned n) {
    std::sort(x, x + n,
        [](double a, double b) {
            return (std::abs(a) < std::abs(b));
        });
}

Inside the function abssort, we passed lambda into std::sort as a comparator. We can write a normal function to achieve the same purpose:

#include <algorithm>
#include <cmath>

bool abs_less(double a, double b) {
    return (std::abs(a) < std::abs(b));
}

void abssort(float* x, unsigned n) {
    std::sort(x, x + n, abs_less);
}

We still do not know what the strange [] syntax is for, and that is our topic next.

Captures

The above example shows the basic usage of Lambdas, but Lambdas can do more. The main difference between a lambda and a regular function is that it can "capture" state, and then we can use the captured value inside the lambda body. For example, the below function gets a new vector with the element above a certain number in the old vector.

// Get a new vector<int> with element above a certain number in the old vector
std::vector<int> filter_above(const std::vector<int>& v, int threshold) {
    std::vector<int> result;
    std::copy_if(
      std::begin(v), std::end(v),
      std::back_insert_iterator(result),
      [threshold](int x){return x > threshold;});
    return result;
}

// filter_above(std::vector<int>{0, 1, 2, 4, 8, 16, 32}, 5) == std::vector<int>{8, 16, 32}

The above code captures threshold by value. The [] construct is called a capture clause. There are two kinds of captures, capture by value or capture by reference ([&]). For example, [x, &y] - capture x by value and y by a reference explicitly. You can also have a default capture clause, for example, [=] captures everything in the current environment by value and [&] captures everything by reference.

A function that store an environment is called a closure; almost all modern programming languages support closures. However, in all languages that I know except C++, the capture list is implicit. In those languages, a closure captures all the bindings from the current environment.

We can mimic the behaviors in those languages by capturing everything by reference ([&]), and it captures all the variables in the environment that are used in the lambda. However, default capture can be dangerous in C++; it leads to potential dangling problems if the lambda lives longer than the captured object. For example, we can pass a callback to asynchronous functions:

auto greeter() {
    std::string name{"Lesley"};

    return std::async([&](){
        std::cout << "Hello " << name << '\n';
    });
}

The above code is undefined behavior since name may be destroyed when we execute the asynchronous operation. The rule of thumb is only to use default capture by reference when the lambda is short-lived. For example, when passing a lambda to STL algorithms.

The implicit capture strategy works in garbage-collected languages. Rust gets away with implicit capture because of its borrow checker. On the contrary, by requiring the programmer to be explicit about ownership, the C++ approach provides more flexibility than the counterparts in other programming languages.

What is Lambda

We discussed quite a lot of usage of Lambda so far. However, curious readers may start to wonder, what exactly is a C++ Lambda? Is it a primitive language construct like closures in functional languages? However, before I talk about the internal of Lambda, I will first talk about a construct date back to C++98 era, function objects.

Function Object

Function objects are normal objects that are able to be invoked. They are implemented by overloading a class' operator() operator. Below is our abs_less example as a function object:

#include <algorithm>
#include <cmath>
class abs_less {
  bool operator()(double a, double b) {
    return (std::abs(a) < std::abs(b));
  }
};

void abssort(float* x, unsigned n) {
    std::sort(x, x + n, abs_less{});
}

Function objects are more flexible than regular functions because they can store data like ordinary objects. Let us implement the previous filter_above example with function object:

template <typename T>
class GreaterThan {
public:
  GreaterThan(T threshold): threshold_{threshold} {
  }

  bool operator()(const T& other) noexcept {
    return other > threshold_;
  }

private:
  T threshold_;
};

std::vector<int> filter_above(const std::vector<int>& v, int threshold) {
    std::vector<int> result;
    std::copy_if(std::begin(v), std::end(v), std::back_insert_iterator(result), GreaterThan{threshold});
    return result;
}

I am using Class template argument deduction (CTAD) in this snippet. CTAD is a C++17 feature. In the previous versions, we need to write GreaterThan<int>{threshold} with the template parameter int specified.

Going back to lambda

Lambdas in C++ are syntactic sugars of function objects. In other word, the compilers translate lambda expressions into function objects. Through the amazing C++ Insights website, we can see a desugared version of our abssort example:

#include <algorithm>
#include <cmath>

void abssort(float * x, unsigned int n)
{

  class __lambda_6_9
  {
    public: inline /*constexpr */ bool operator()(float a, float b) const
    {
      return (std::abs(a) < std::abs(b));
    }

    ...
  };

  std::sort(x, x + n, __lambda_6_9{});
}

Lambda is merely a default constructed object of a local class. Thus, C++ Lambda can do a lot of stuff anonymous functions in other languages may not allow to do. For example, you can inherit from lambda and have mutable states from lambda. Though I haven't found too much use for either of them.

The compilers generate the types of Lambdas; however, there is no way to use such types by their name through any standard means in a program. Nonetheless, type inferences and template works just normal for those types. Also, we can use those types explicitly by decltype. Below is an example from the cppreference:

auto f = [](int a, int b) -> int
    {
        return a * b;
    };

decltype(f) g = f;

Such anonymous types are called "Voldemort's types" in the world of C++ and the D programming language because they cannot be directly named, but codes can still use this type.

Capture with an initializer

Now you understand a Lambda is a function object; you may expect Lambdas to store arbitrary values, not just to capture the values from their local scope. Fortunately, in C++14, lambdas can introduce new variables in its body by the mean of capturing with an initializer².

[x = 1]{ return x; // 1 }

Move capture

Rust lambdas can take ownership of the values in the environment. C++ lambdas do not have special support for such move capture, but the generalized capture in the C++14 covers such use case:

// a unique_ptr is move-only
auto u = make_unique<some_type>(
  some, parameters
);
// move the unique_ptr into the lambda
go.run( [u=move(u)] {
  do_something_with(u);
});

Immediately Invoked Lambda

You can invoke lambda at the same place where we construct them.

[]() { std::puts("Hello world!"); }(); // Same as what is inside the curly braces

In the world of Javascript, immediately invoked function expressions are all over the place. JavaScript programmers use them to introduce scopes. C++ does not need this kind of trickery. As a result, C++ programmers are more reluctant to use immediately invoked lambda. For example, in her talk during CppCon 2018, Kate Gregory concerns about the readability of the immediately invoked lambda for people not familiar with this idiom.

Nevertheless, if you follow the best practice of declaring as more const values as possible, immediately invoked lambda does provide an advantage. Some objects require complex construction beyond the constructor's capability. Mutations will only happen during the construction of objects. Once the construction is completed, the objects will never be modified again. If such construction is reusable, then writing builder classes or factory functions is a sane choice. However, if such construction only happens once in the codebase, a lot of the people will drop the const qualifier instead. For example, consider that if you want to read several lines from stdin into a vector:

std::vector<std::string> lines;
for (std::string line;
     std::getline(std::cin, line);) {
    lines.push_back(line);
}

It seems no way to make lines constant since we need to modify it in the loop. Immediately invoked lambda solves this dilemma. With it, you can have both const and no boilerplates:

const auto lines = []{
    std::vector<std::string> lines;
    for (std::string line;
         std::getline(std::cin, line);) {
        lines.push_back(line);
    }
    return lines;
}();

This post is first published on Lesley Lai's Blog.

See [expr.prim.lambda] ↩
C++14 Language Extensions: Generalized lambda captures ↩

Const Correctness Issue of std::function

Lesley Lai — Mon, 30 Dec 2019 09:39:50 +0000

The const type qualifier is one of the jewels of the C++ language design. Surrounding by this feature, we devise the "const correctness" practice to prevent const objects from getting mutated. The const correctness rule is straight-forward to follow for implementation of the most classes, but it is harder to heed for classes with type erasure. Unfortunately, the standard library type std::function is implemented by type erasure; and due to short-sightedness, it becomes one of the ill-behaved citizens that doesn't follow the const-correctness rule.

The Problem

std::function has one const member operator(), yet it can mutate the underlying function. For example,

const std::function<int()> f {[x=0]() mutable { return ++x; }};
f(); // returns 1
f(); // returns 2

The Document N4348¹ first formalized this concern. It states that

This violates not only basic tenets of const-correctness, but also the data race avoidance guarantees in [res.on.data.races]/p3, which states that "A C++ standard library function shall not directly or indirectly modify objects accessible by threads other than the current thread unless the objects are accessed directly or indirectly via the function's non-const arguments, including this".

The Fix

Implementations of a function-like class should have separate specializations for const and non-const.

template<class Sig> class function; // not defined

template<class R, class... Args>
  class function<R(Args...)>;

template<class R, class... Args>
  class function<R(Args...) const>;

operator() of the const specialization should be annotated as const, but the constructor of the const specialization would not accept mutable function objects.

function<int() const> f1 {[x=0]() { return x; }};
f1() // ok;

function<int() const> f2 {[x=0]() mutable { return ++x; }}; // Does not compile

On the other hand, operator() of the non-const specialization would not have const type signature, so you cannot invoke the const version of such functions at all:

function<int()> f1 {[x=0]() mutable { return ++x; }};
f1(); // ok

const function<int()> f2 {[x=0]() mutable { return ++x; }};
f2(); // Does not compile

The Future

I don't expect std::function itself to have any change that breaks backward-compatibility. As of the time of this writing (December 2019), my bet is on the proposed std::unique_function ², which is a drop-in replacement of std::function that fixes the const-correctness bug among other features. Once we have an alternative in standard, std::function can be deprecated just like std::auto_function. In the meantime, we can always implement unique_ptr on our own, and I have a small library to implement that on Github.

This post is first published on Lesley Lai's Blog.