For beginners, a crash course introduction to programming for several CPU cores
https://johnysswlab.com/crash-course-introduction-to-parallelism-multithreading/

https://redd.it/u0nwnl
@r_cpp

Declarative GPU Pipelines in C++20
https://celtera.github.io/avendish/gpu/draw.html

https://redd.it/u0kqbr
@r_cpp

The C++Now 2022 session schedule is online

C++Now 2022 and the Boost Foundation are happy to announce that the 2022 conference schedule is now online at https://cppnow.org/schedule/. 

There are still some spots left, so register now!

https://redd.it/u0pv53
@r_cpp

limitations of using Flutter for the UI instead of a native C++ GUI library

in terms of

1. integration difficulty and possibly limitations

2. Development workflow / speed / efficiency

how would you compare between a framework like Flutter ( or any external GUI framework ) to a native C++ GUI library ?

https://redd.it/u0ut2a
@r_cpp

Type Punning Arrays

I have a question and hopefully, you guys can clarify what my google searches can't. I have heard type punning in C++ was UB even though it works in C and in my program. My simple question is: can I type pune an array class of the same type with a larger size to a smaller size?

Here's an example code:

t#include <iostream>
#include <assert.h>

template<class T, size_t _SIZE>
class Array {
public:

T array_data[_SIZE];

T& operator[](const size_t& index) {
assert(index < _SIZE);
return array_data[index];
}

const T& operator[](const size_t& index) const {
assert(index < _SIZE);
return array_data[index];
}

const size_t size() const {
return _SIZE;
}
};

int main() {
Array<int, 4> original_array = { 1, 2, 3, 4 };

Array<int, 2>& type_puned_array = *((Array<int, 2>*)&original_array);

type_puned_array[1] += 3;

std::cout << "type_puned_array:\n";
for (size_t i = 0; i < type_puned_array.size(); ++i) {
std::cout << type_puned_array[i] << "\n";
}
std::cout << "original_array:\n";
for (size_t i = 0; i < original_array.size(); ++i) {
std::cout << original_array[i] << "\n";
}

return 0;
}

This code runs and compiles (I'm using C++20) printing the desired result, so I do not see the issue. However, I do see a problem if the puned array size is greater than its original as well as the difference in types. I think, using a function that can return a safe, type puned array that follows these rules would be a way better option rather than simply casting a pointer and dereferencing it.

However the case, I look forward to seeing your answers, and thank you for your time.

Edit: fixed typo.

https://redd.it/u0mmwo
@r_cpp

Initializing coroutine arguments by reference

Hi Y'all,

If I understand the current state of c++20 coroutines...

\- The type of an argument (as stored in the coro frame) comes directly from the parameter list.

\- Therefore, I need to _not_ use anything pointer-like (e.g. no rrefs) in the argument list of a long-lived coro because I'll end up with unsafe dangling pointers instead of the copy I want and

\- Therefore the signature of the "constructor" of my coro is going to be pass-by-value.

This is a small thing, but it seems like I have to eat an extra move operation because I can't specify that I want reference-based calling conventions to my coro constructor but value-type storage in the frame - the syntax just isn't expressive enough.

So for example:

template<typename F>
task<void> makecoro(F f) {
f();
coreturn;
}
...
auto mytask = makecoro(some_obj{ / / });

I'm capturing some obj by value into a lambda that's going to end up in a coroutine frame, and the call to make_coro takes the lambda, so at a minimum I need a copy constructor (of some_obj to a temporary lambda) and a move (of the lambda, with the object in it) to the heap allocated coroutine frame (assuming my_task escapes, let's assume it does).

But when I step through this in some test code with tracing on the various object constructors/destructors, I found that the copy of my object (captured in the lambda) appears to be moved twice:

1. The captured copy on the stack is then moved into what I think is argument space for make_coro's constructor and then
2. The arg space from make coro's constructor is then moved (as expected) into the heap-based coro frame.

Did I miss something or screw something up, or is this a lost optimization (to perfectly forward references) through to coroutine frames?

https://redd.it/txoi6t
@r_cpp

Three Benchmarks of C++20 Ranges vs Standard Algorithms
https://www.cppstories.com/2022/ranges-perf/

https://redd.it/u192jr
@r_cpp

AES api question.

Hi All,

Is there an existing api to do AES encryption where the api mimics the regular file I/O functions.

Kind of:

int fd = aes_open("/path/to/encrypted/file", ...AES pararmeters...);
int stat = aes_read(fd, buf, 1024);
int offset = aes_lseek(fd, offset, whence);
int stat = aes_write(fd, buf, 1024);
int stat = aes_close(fd);


Internally is would handle all the encryption/decriptions, handling of 16 byte boundaries, padding, etc.

https://redd.it/u1b2yl
@r_cpp

C++20 library for modern dynamic polymorphism (virutal functions / std::any / std::proxy / and some std::variant current use cases replacement). AMA about it
https://github.com/kelbon/AnyAny

https://redd.it/u1e8nh
@r_cpp

Qt 6.3 released
https://www.qt.io/blog/qt-6.3-released

https://redd.it/u1uov6
@r_cpp

Memory-Size Literals
https://wunkolo.github.io/post/2022/02/memory-size-literals/

https://redd.it/u2gkkz
@r_cpp

C++20 modern library for Reactive Functional programming (Sender/Receiver) https://github.com/victimsnino/ReactivePlusPlus

Hi everyone, currently RPP is under heavy development, but want to share current status and obtain some possible feedback

&#x200B;

https://github.com/victimsnino/ReactivePlusPlus

https://redd.it/u2loew
@r_cpp

Boost v1.79.0 released
https://www.boost.org/users/history/version_1_79_0.html

https://redd.it/u2sq99
@r_cpp

Java Swing inspired C++ UI component library

I developed a very minimal Java Swing inspired GUI library for C++, project aims to make it easy to convert minimal Java Swing projects to native Windows application.

&#x200B;

https://github.com/yusufhanoglu/HComponentLibrary

https://redd.it/u2utns
@r_cpp

Pure Virtual C++ 2022 Conference Schedule Available
https://devblogs.microsoft.com/cppblog/pure-virtual-cpp-2022-schedule-available/

https://redd.it/u2utov
@r_cpp

Is there a replacement/alternative to Sourcetrail?

I just got introduced to Sourcetrail by a coworker, which is a tool to visually inspect a big project. It can show things like "Where is this class used?... Which class implements this interface?" and so on at a glance.

However he told me, that the tool was discontinued. Do you use any replacement tools in its place? If so, which ones?

https://redd.it/u2rani
@r_cpp

HikoGUI-0.6 A C++20 retained-mode desktop application GUI library
https://github.com/hikogui/hikogui

https://redd.it/u2axvy
@r_cpp

Getting started with Boost in 2022

As an intermediate c++ dev looking to "level up", I have the luxury of working on my own repo and being in charge of the architecture this year. This year I have started to actively use more features from cpp14 ->.

I. E. widespread use of smart pointers, variants, lambdas, templates, and diving into patterns/best practices such as factories, and usage of const.

Many times I see boost referenced, followed by an update that Std has implemented it. So I wonder, what am I missing out on not using Boost? Should I spend the time to dive into it?

A bonus add-on if you have time, are there some worthwhile resources or functions to read on to help me get to advanced level? Or is it just learn cpp Std library?

For reference, I am working on a ROS based, modular controller for an automated mechatronics system. Very briefly, an RQT gui sits atop a backend that implements communications protocols over UART, i2c etc..

https://redd.it/u3al4j
@r_cpp

Old rand() method faster than new alternatives?

I am doing a simple Monte Carlo simulation, and I have a loop that runs millions if not billions of times (depending on input) that has to generate a new random int and a random float each time.

I tried using the mt19937 engine at first by implementing something like this:

std::randomdevice rd;
std::uniformintdistribution<int> distint(0, bignumber);
std::uniformrealdistribution<float> distfloat(0.0, 1.0);
std::mt19937 engine{rd()};

for(huge loop)
{
...
auto randomint = distint(engine);
auto randomfloat = distfloat(engine);
...
}

Full disclosure, I'm not even sure my implementation is correct. If I've messed something up, please point it out.

After running it, I realized my Fortran code doing the same thing was much faster, which was odd because I had also made some other optimizations that should have made it better. Soon I realized that what was taking most of the time was running the random number generators, and the basic fortran rand() was much faster. So I switched to the basic C rand() even though I know it is supposed to not be the best:

srand(time(nullptr));

for(huge loop)
{
// bignumber is power of 2 so used bitwise AND for modulo:
int randomint = rand() & (bignumber-1);
float randomfloat = (float)rand()/RANDMAX;
}

Indeed, it was significantly faster. I thought hey, maybe mt19937 is not the fastest engine, but after trying out a couple other standard ones, they were even slower. I was a bit disappointed and resorted to rand().

I don't know what is taking all that time. Is it the uniform\int_distribution? Is it the engines themselves? Did I implement something badly? Also, I looked through the internet, and I found a bunch of threads discussing alternative random engines like xorshift128+ etc that are supposedly faster, but nothing about standard library engines, and also I didn't really understand how to implement them in this specific example. If anyone could help it would be very appreciated.

https://redd.it/u3cnkk
@r_cpp

rvscript: Fast RISC-V-based scripting backend for game engines
https://github.com/fwsGonzo/rvscript

https://redd.it/u3dvoe
@r_cpp