macros | A collection of commonly used C MACROS | Awesome List library

Today I myself faced such a problem. The problem lies in styled-components itself. Macro in styled does not work since version 5.2.2, and it is not known when it will be fixed. Simplest solution:

compile time-enabled solution.

Consider whether this is useful requirement in the first place. The program isn't going to be communicating with another system at compile time. What is the case where you would need to use the serialised integer in a compile time constant context?

1. Starting at what C++ standard is there a portable standard-compliant way of performing host to network byte order conversion?

It's possible to write such function in standard C++ since C++98. That said, later standards bring tasty template goodies that make this nicer.

There isn't such function in the standard library as of the latest standard.

1. Should such a pure-c++ solution be preferred to OS specific functions such as, e.g., POSIX-htonl? (I think yes)

Advantage of POSIX is that it's less important to write tests to make sure that it works correctly.

Advantage of pure C++ function is that you don't need platform specific alternatives to those that don't conform to POSIX.

Also, the POSIX htonX are only for 16 bit and 32 bit integers. You could instead use htobeXX functions instead that are in some *BSD and in Linux (glibc).

Here is what I have been using since C+17. Some notes beforehand:

• Since endianness conversion is always¹ for purposes of serialisation, I write the result directly into a buffer. When converting to host endianness, I read from a buffer.

• I don't use CHAR_BIT because network doesn't know my byte size anyway. Network byte is an octet, and if your CPU is different, then these functions won't work. Correct handling of non-octet byte is possible but unnecessary work unless you need to support network communication on such system. Adding an assert might be a good idea.

• I prefer to call it big endian rather than "network" endian. There's a chance that a reader isn't aware of the convention that de-facto endianness of network is big.

• Instead of checking "if native endianness is X, do Y else do Z", I prefer to write a function that works with all native endianness. This can be done with bit shifts.

• Yeah, it's constexpr. Not because it needs to be, but just because it can be. I haven't been able to produce an example where dropping constexpr would produce worse code.

In my opinion, both

#[main] is an old, unstable attribute that was mostly removed from the language in 1.53.0. However, the removal missed one line, with the result you see: the attribute had no effect, but it could be used on stable Rust without an error, and conflicted with imported attributes named main. This was a bug, not intended behaviour. It has been fixed as of nightly-2022-02-10 and 1.59.0-beta.8. Your example with use tokio::main; and #[main] can now run without error.

Before it was removed, the unstable #[main] was used to specify the entry point of a program. Alex Crichton described the behaviour of it and related attributes in a 2016 comment on GitHub:

Ah yes, we've got three entry points. I.. think this is how they work:

• First, #[start], the receiver of int argc and char **argv. This is literally the symbol main (or what is called by that symbol generated in the compiler).
• Next, there's #[lang = "start"]. If no #[start] exists in the crate graph then the compiler generates a main function that calls this. This functions receives argc/argv along with a third argument that is a function pointer to the #[main] function (defined below). Importantly, #[lang = "start"] can be located in a library. For example it's located in the standard library (libstd).
• Finally, #[main], the main function for an executable. This is passed no arguments and is called by #[lang = "start"] (if it decides to). The standard library uses this to initialize itself and then call the Rust program. This, if not specified, defaults to fn main at the top.

So to answer your question, this isn't the same as #[start]. To answer your other (possibly not yet asked) question, yes we have too many entry points.

GHC versions consist of a major version, minor version, first patchlevel, and optional second patchlevel. So GHC 9.2.1 has major 9, minor 2, first patchlevel 1, and no second patch level.

There's a bug in GHC, possibly in existence since the macro MIN_VERSION_GLASGOW_HASKELL was introduced, where that macro depends on a macro variable __GLASGOW_HASKELL_PATCHLEVEL2__ which is not defined when, as is usual for release versions, the GHC version has only one patch level (like 9.2.1).

This usually doesn't matter, except if the -Wcpp-undef flag is in force AND the test is performed on a version that matches on the major, minor, and first patch level. Then, the check on the second patch level will generate a compiler warning message. (Despite the fact that it looks like an "error" rather than a warning, the compilation appears to complete.)

You can work around this by:

• ignoring it -- despite appearances, it looks like it's only a warning, not an error, and compilation should complete

• shutting off -Wcpp-undef by either removing the flag or, if feasible, adding a -Wno-cpp-undef flag;

• adding some code to define the missing patchlevel before calling the macro:

You could use std::tuples. Especially std::tuple_cat is nice for this.

Example:

Since functions can implement traits, the solution is to define a trait that represents "can serve as callback function" and then manually implement it for every function arity up to some large number of arguments. In actix, this is done by having .to(f) take something implementing the Handler trait:

For number 2 you can try to check out my pod_reflection library:

Are there significant performance penalties I may suffer as a result of writing code this way?

Probably:

• Heap allocation is expensive, and - today - usually not optimized away even when that is theoretically possible.
• Dereferencing a pointer for member access is expensive; although this might get optimized away with link-time-optimization... if you're lucky.

i.e. is there a simpler way to do this

Well, you could use a slack array of the same size as your private fields, and then you wouldn't need to go through pointers all the time: