Video

I think I would have use the capacity has the common field instead of the size because if for example you modify the length of your string a lot between let say 12 and 20 characters your solution force you to allocate deallocate each time you cross the 16 byte boundary. Whereas the capacity can stay at ~20 while your size can move around as it want. To use capacity instead we can say that size() = capacity when capacity < 16 else size and capacity() = max(16,capacity)

I compared aarch64 binaries with x86 abidiff, it just empty.

awesome one!

(++i)++;

honestly I'd rather if small string was a different type, maybe something like: small_string<10> str;

Isn’t std::size_t in <cstddef> not <cstdint>?

It is a shame that we had to wait 26-11=15 years for this feature

To pack this object into something even smaller in space you could use a bit field for the m_size, and while you can't allocate a string that is unsigned int64, you can allocate a unsigned int63. And use a bit at either end to indicate whether the space was allocated on the heap or using your m_small field of your other union. There of course is a minimal overhead of looking at those bit fields vs a bool or the int, but this is a thing that maps doing red/black do.

Is std::launder necessary for unions? I know the answer is no when the data members are active only once in the lifetime of the union, but this is not the case here.

A good exercise is implementing small object optimised vector<bool>

Or just (ab)use std::basic_string<> for arrays with small object size optimizations.

I would have made `is_small_storage()` a function which returns either `m_size < ` an arbitrary constant or the result of `m_size < sizeof(small_storage)` (so no additional storage needed for the bool). In several functions we would then need to re-evaluate this but I think it's worth it as it takes less space.

Would love to see a std::variant version

btw, offtopic question: since you really shouldn't store a function address in a void pointer, it's recommended to use a dummy function pointer type instead. The question is: can you reliably store a method pointer into this dummy function pointer type? Or what can you use instead of a void pointer to store a method pointer? 🤔

constexpr is essentially a compile-time UB sanitizer😮

Why Boolean needed to check if it is a small object? Size is present. Max size of small object also is known. I doubt that checking Boolean is much faster then checking if some value is less then a constant…

I've just googled this topic today! PS: one could pack the small string even tighter, there's a way to use single byte for a size, but you'd store the max_small_string_capacity minus size instead. When the small string size equals the max capacity, the capacity minus size becomes zero and acts as a null terminator. 🤯

I think this has to be one of the coolest examples on how and why to use constexpr.

Are there any books on c++26 yet?

Instead of hiring Jason Turner for onsite training, you could also buy the book on move semantics by Nicolai Josuttis (probably spelled the name wrong). It covers all dark corners of move semantics in detail and I guess it is considerably cheaper. The usecase of std::move is that if the member data of Lifetime is not an int, but a pointer to dynamically allocated memory, std::move(l1) will cause the move constructor to be called instead of the copy constructor. The copy constructor will do a dynamic allocation and copy the data, the move constructor will simply copy the pointer. You will still have 2 objects (one moved from, one moved to) but not an allocation and not a memcpy. That is the benefit of std::move. In the case he demonstrated here, you don't want move semantics, because that won't help you here. Here you want in-place construction, emplace() and the like. The lambda creates an object, elides the copy of the return value and so avoids the construction of a temporary. It's effectively an emplace.

This is great because it has the potential to decrease compile times significantly.

With expected is even worse! I'm using a static std::expected<Class, Err> to construct my object, and having a private constructor, but this blocks me from passing std::in_place + Args, as the constructor is private... How can I apply rvo in this case? will "return std::expected<Class, Err>(Class(args)); " work? I tried this and it called the move ctor...

C++ will never die, because we all love it so much!

Can we thank circle for this?

Careful tho, this implementation technically returns you an input_range, not a forwarding one, since the sequence is technically single pass only. The resulting view doesn't reflect that tho, algorithms you pass this into might break

❤

On that note You can also do Param...[2] To get the type at index 2

Can you also index into the types of the parameter pack and make some compile time checks there? E.g. std::is_same_v<int, Param...[3]> ?

This is really cool, but i dont see it being very useful in well designed code.

I would guess that most people, even if they want to use that, they will not be moving their codebase to C++26 until C++29 or later are released, because companies don't usually make this type of jump as freely...

FINALLY!

Одна из главных вещей, которые я ожидаю в c++26

What happens if the parameter pack has only two elements and you try to access the 3rd elelement? Is it a no-op? Is it a compiler error? Can you test for at compile time so you enable a different code path in the template body?

I think you can also unpack into a tuple and then use get<n>(tuple) to access it yeah?

Amazing innovation, now I write it with my hands and cunning overload operators.

very cool

Does C++26 have ranges parameter pack support?

that params...[index] syntax is ugly. C++ honestly needs a new fresh coat of paint with better defaults, it's a beautiful and powerful language. just a bit ugly

Considering that variadic templates came at C++14 (I think, haven't checked), one would assume this should have been added years ago.

C++26 will be great. I wonder how long it takes for it to be deployed.

Very very nice... Is there a way of checking if the third parameter exists, though? What would happen if the third parameter doesn't exist? Compile time error, warning, UB??

Good, Now we need p1061 and P3115 and maybe P2994 and then maybe, just maybe, my hair will thank me for stopping puling it.

yeah!..... for the longest time..

It feels like the input of a matlab function, but with the zero abstraction cost of c++. Awesome.

Hey look, something with compile time bounds checking :D

Well, another way would be to write this as ``` template<typename... Param> void func(Param... param) { std::get<2>(std::tie(param...)) = 42; } ```

One of the other ways you could do it prior to C++26 is by using std::tie to get references to the parameters and then using std::get<i>(tuple).

at 8:00 wouldn't return std::string(b?"Hello":"World"); also work? and it would be easier to read/write I think.

to avoid padded warnings you can introduce "char padding" members in your struct, to fill the gaps. this also allow for more easy knowing of were you can put new members in this struct wo breaking the alignment

Thanks for the heads up...problem solved