coliru | JavaScript library for Coliru online compiler | Frontend Framework library

Both std::map and std::set use the same strict weak ordering for ordering its contents.

You can take advantage of this. You know that if you iterate over the map you will get the keys in the same order as they are in the set, therefore all it takes is a little bit of clever logic, something like:

Static initialization in C++ is a nightmare... Draft n4659 for C++17 says in 6.6.3 Dynamic initialization of non-local variables[basic.start.dynamic] §1

Dynamic initialization of a non-local variable with static storage duration is unordered if the variable is an implicitly or explicitly instantiated specialization, is partially-ordered if the variable is an inline variable that is not an implicitly or explicitly instantiated specialization, and otherwise is ordered.

When the Static class is not templated, you have a partially-ordered intialization to guarantee the initialization of Static::s_a to happen before the initialization of s_user. But when you use templates, the initialization becomes unordered and the implementation can choose what it wants. In my tests, gcc 10 gives same results as what you have got (s_users initialized before Static::s_a), but clang 12 gives the opposite order...

You are lucky to have used gcc and seen the problem. Had you used Clang, you would have proceed at dev time and problem could have happened later. The worse here, is that I am not sure whether explicit instanciation really guarantees the initialization order. If I have correctly understood the standard, I would say no and anyway, I would never rely on that for production code.

You should just handle the expectation failure:

In standard C++, the smallest possible size of a struct is 1 char (which is at least 8 bits). So even an extension like __attribute__((packed)) is forced to yield a struct of size 1.

Furthermore, almost everything about the layout of bit-fields is implementation-defined.

In this example it seems GCC simply picks the alignment of the largest specified member type (int) for the bit-field alignment.

If you change int to short, then sizeof(child_t) will yield 2:

The compiler is giving up because you are creating a template with too many parameters. The representation of a Hana string is hana::string<'<', '?', 'x', 'm',...> where each character is a non-type template parameter. This is generated by some tricks inside the BOOST_HANA_STRING macro.

I suggest looking at the following presentation for some insight on how to deal with large compile-time strings: Constexpr All the Things - Jason Turner, Ben Deane

Aside from that, here is a basic example of one possible approach that you could possibly put in your own macro depending on how you are using these.

I admit, I do not understand the error message. The reason the second version compiles but not the first is that template parameters cannot be deduced from default arguments but from function parameters. Consider this simpler example:

You can pass boost::hana::string to combined() instead in order to invoke image() at compile-time with std::string_view:

This is frequently requested, sad thing is due to the concepts there is no way to piggy-back meta data in geometry entities (specifically, points).

Points are default constructible, and are assigned coordinates using the accessor functions.

This is important for the generic case: if the output geometry has an entirely different types. Yes, specially for union_ you might expect some input points to be copy-constructed, but alas.

I've previosly explained this in some more detail here:

• Losing data in custom point type after boost buffer call