Відео

I know ranges are cool and offer many more functionalities (constexpr, potential random access, and so on). But it is such *much* easier to actually author generators than either traditional iterators or ranges.

What is the _s: prefixing a string literal at 1min25sec, as the argument of puts(), at line 4? Is it c++?

How do you avoid pointer arithmetic when attempting to parse network packets?

This one I feel like could have gone more in depth.

I have implemented function and it is very interesting.

just use a struct or tuple or pair for the min/max

Hey man, I was really enjoying this series and am just wondering if it will be continuing or not? If not, all good - just curious!

std::generator allocates. The lambda function in the previous video returns a very weird type, since it is auto. Is there a way to have the best of both: a generator class/template, to which I tell to use a certain amount of memory to work with on the stack. kind of like the new flatmaps with arrays. e.g. std::generator<int&, int, std::array<char,512>> ?

instead of using std::move you should just move away from c++

The mess that C++ is or has become...

If you didn't have the operations being performed in the various constructors, would the compilers be able to optimize those operations away?

Or you could write a for loop and reduce the generated assembly from 338 lines of unreadable asm to 30 lines of pretty readable asm. Probably faster too, though quick-bench doesn't support GCC 14.1+ so I wasn't able to verify. 1. Copy to godbolt 2. Flip #if 1 to #if 0 3. See the assembly reduce by 90% ``` #if 1 #include <generator> #include <iostream> #include <utility> // std::exchange #include <ranges> std::generator<int> fib() { int i = 0; int j = 1; while (true) { co_yield i = std::exchange(j, i + j); } } int main() { for (const auto i: fib() | std::views::take(20)) { std::cout << i << ' '; } } #else #include <iostream> #include <utility> // std::exchange int main() { int i = 0; int j = 1; for (int index = 0; index < 20; ++index) { i = std::exchange(j, i + j); std::cout << i << ' '; } } #endif ```

The difference in assembly output is quite large. I imagine the optimization maniacs have not had their fun yet with std generator

Very nice to see generators landing but I’m not convinced that std::exchange is contributing to the transparency or readability of this code

Going to have to get out of the habit of reaching for std::cout and use std::println instead. Its also interesting how much code hello world with std::println produces with -O(2/3), maybe an episode on why that is the case would be interesting. At compile time it should be known I'm printing a basic string and not using any formatting and remove all the formatting boilerplate etc.

I would make some observation, code like `for (auto i : foo() | bar())` was tricky in older C++ as value returned from `foo()` could be destroyed as lifetime was bound only to `foo() | bar()` expression, but recent C++ fix it and make that temps in range `for` live as long this `for` is in scope.

I'm going to go out on a limb here and say that the lambda produces much, much better code than the generator. Godbolt short link: 5G3j54x8r

The infinite loop is UB, isn’t it?

-Fanalyzer does not like std::generator one bit. Also, here's a version of fib() with no UB that stops after the addition overflows: constexpr int wrapping_add(int a, int b) noexcept { return static_cast<unsigned>(a) + static_cast<unsigned>(b); } std::generator<int> fib() { int i = 0; int j = 1; while (true) { co_yield (i = std::exchange(j, wrapping_add(i, j))); if (j < i) { break; } } }

Awesome, I hope other compilers will implement it soon as well so that people can start adapting it

I'm a C++ beginner/intermediate (~3 years experience, 2 of which on the job (take from that what you will)), and it's my only language so far. I gotta say, it seems like the perfect time to be getting deeper into it: in the back of my mind, I've had "I must sometime learn about coroutines" - now I have the fancy new features to do it! I am starting to take learning this language more seriously and I feel like your videos are gonna help me learn fast.

also compile with just released gcc 14.1

What are the good use cases of coroutines? Where can I learn more about them? Maybe .pdf book or something

Imagine this combined with the upcoming networking library! I don't even know what exactly is possible.

Yay for coroutines! I've exploited to death `std::generator` in ways that works surprisingly through the years, it's very interesting what you can do with that as soon as you understand how to manipulate manually the iterator from `begin()`

I always avoid static in function scope and it is also forbidden at my work because it introduces a mutex lock. Is there a guarantee that 'static constexpr' will never initialize at runtime and hence no mutex? Otherwise it's quite useless IMO. Best would be if there was a way to make static in function scope initialize at the same time as global scope so there was no need for it.

It bothers me that coroutine-based generators couldn't be made malloc-free when this is possible...

I know this behavior long time ago. So i always dare to return stack created object, since it is still fast enough. Handling rvalue reference sometimes hurt productivity.

Oh man. I like Jason's talks on CppCon. So was eager to check this channel out. Not quite what I was expecting. I have seen the gist of this topic explained in at least a dozen stackoverflow threads. So why the constant bombardments of on-site training? It's such a clear topic to explain through code example.

Hello, Jason. I like your explanations. I’d be happy if you made a video about “how undefined behaviours is useful for optimizations”.

so yeah, you can use patterns from networking server/client model for instance in #include <boost/asio.hpp> which I did, and then a thread-safe message std::deque. Throw in some templates, job basically done. btw, these messages can also transverse the ol' internet.

With this method you also don't have to worry about the moved-from stack variables l1 or l2 being, in a practical sense, invalid after the point of the move.

If there a way to reuse that lambda?

I would argue that if you are encountering these race conditions or thinking about how they work, then you could use refactoring instead.

When I write performant cutting edge code, I use "OOP" less than I use "DOD". Fundamentally different hemispheres of code concepts.

all of this seems outdated by instead using concepts of BOOST/STL/algorithms/lambdas/std::function/views. I don't know, I think this methodology that you use may be outdated.

padding issues are solved largely by Structures of Arrays programming method, speed increase even more dramatic than worrying about complicated structure concepts.

first of all, I'd more than likely be using items like std::uint16_t or std::uint32_t, and then std::size_t. Your code appears depreciated.

Hello, fellow C++ enthusiast, please learn to do this instead: struct LifetimeWriter { int value{ 0 }; LifetimeWriter( int value) :value(value) { std::cout << "constructor" << std::endl; } ~LifetimeWriter() { std::cout << "destructor" << std::endl; } LifetimeWriter(const LifetimeWriter& other) { std::cout << "copy constructor" << std::endl; } LifetimeWriter(LifetimeWriter&& other) { std::cout << "move constructor" << std::endl; } LifetimeWriter& operator=(const LifetimeWriter& other) { std::cout << "copy assignment" << std::endl; return *this; } LifetimeWriter& operator=(LifetimeWriter&& other) { std::cout << "move assignment" << std::endl; return *this; } }; std::array<LifetimeWriter, 2 > arr = { LifetimeWriter{5}, {7} };

Can’t you use std::views::repeat instead of iota?

how do you type so fast??

Is it just me or this code is unreadable? A lambda wrapped in a generator function that uses 2 stl functions to pipe the values the result of the lambda around so we avoid compilation errors...

Jason, you need to either put something on your mic, play with eq and gates, or practice some speech exercises, as you are suffering from the common "wet mouth noises" in your audio, which tend to drive some people batshit. Just wanted to let you know in case you weren't aware.

The typical use case would be to have a custom generator. Here that is essentially provided by iota

You could check if the invocable is callable with the iota output and if not wrap the callable in another lambda

Damnnn this is high level c++

This is an interesting method, but requires too much boilerplate for my liking. I also don't think I'll ever like `views` or any of the functional programming constructs that they've added to C++.

This shit is much less readable than a normal c++ code. What is its purpose?

Nice exampleI think it would be worth to benchmark this with coroutine version!

It looks like only infinite generators can be done this way. Python uses GeneratorExit exception to dynamically end the generator, but exceptions shouldn't be used like that in C++