wg21 | WG21 : C Standards Committee Papers | Blockchain library

The "Template non-type arguments" paragraph of the article „Template parameters and template arguments“ states:

The only exceptions are that non-type template parameters of reference or pointer type and non-static data members of reference or pointer type in a non-type template parameter of class type and its subobjects (since C++20) cannot refer to/be the address of

• a temporary object (including one created during reference initialization);
• a string literal;
• the result of typeid;
• the predefined variable __func__;
• or a subobject (including non-static class member, base subobject, or array element) of one of the above (since C++20).

Emphasis is mine.

And below there is an example

My coworker wants to send some data represented by a type T over a network. He does this The traditional way™ by casting the T to char* and sending it using a write(2) call with a socket:

Violating strict-aliasing rules yields undefined behavior, e.g. when sending a struct over the network into a char buffer, and then that char pointer is C-style/std::reinterpret_cast() casted to a struct pointer.

The C++ std::bit_cast() function looks like it could be used to cast such pointers in an (implementation?) defined way, i.e. without violating strict-aliasing rules.

Example:

Below is from an authoritative C++ proposal:

So I have been quite looking forward to metaclasses. I then heard that it won't be in c++23, as they think we first need reflection and reification in the language before we should add metaclasses.

Looking over c++23 reflection, there appears to be reification capabilties. Are they sufficient to solve what metaclasses would do; ie, are metaclasses just syntactic sugar?

Using the current proposal, can we replicate someone writing a type like:

Here is an example from temp.deduct.partial.

On my application, I receive two signed 32-bit int and I have to store them. I have to create a sort of counter and I don't know when it will be reset, but I'll receive big values and frequently. Beacause of that, in order to store these values, I decided to use two unsigned 64-bit int.

The following could be a simple version of the counter.

I have an std::function object that many threads access. Threads can can change the function it points to (through its copy constructor) and can call the function it points to.

So, my question is, that in what ways is the std::function object itself thread safe? I'm not talking about the function it points to/calls, I'm talking about the std::function object itself.

There are surprisingly only a few sites on the internet that talk about this, and all of them (what I encountered) talk about the function it points to, not the object itself.

These are the main sites I've read:

Does std::function lock a mutex when calling an internal mutable lambda?

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4348.html

If you read them, you can see that none of them talk about the safety of the std::function object itself.

According to the second answer on this page, the STL library is thread safe in these cases:

• simultaneous reads of the same object are OK

• simultaneous read/writes of different objects are OK

Based on this, when I'm setting the function the std::function object points to, for this use case the std::function object is not thread safe. But I'm asking just in case it is, because according to this question's answer, it has some kind of internal mutex.

So, what way can I make it thread safe? One option would be using mutexes, but that won't fully work due to the example demonstrated below:

Suppose I have an std::function object func and std::mutex m to protect func. I lock m and call the function (to protect other threads from setting func while the function it points to is being called) and will unlock m when the function exits. Lets say this function call will take very long. This way, when one thread wants to set func, it will attempt to lock the mutex, but will be blocking until the latter function call exits. What can I do in this case?

I thought of using a pointer that will point to an std::function object. This way, I will use the mutex to protect this pointer and when I will make a function call, I lock the mutex just for getting retrieving the function object from the pointer.

Now that GCC 11, which supports the new calendar and time zone features is released, I am trying to use these in my code.

With the following minimal example: