People want random numbers at compile time that stay the same if they
hit "Rebuild" but which are still sufficiently random. Even though not
every C++ implementation is guaranteed to have a 128-Bit integer type,
I'm still going to go with 128-Bit random numbers, which I refer to
loosely as a "UUID" because there is absolutely no merit in monkeying
about with the so-called "different versions" of UUID. Nobody cares
about the current time or your network card's MAC address. We just
want a random number, so I use the term UUID to mean a 128-Bit random
number.

So there's two ways of doing this:

(Method No. 1) A preprocessor macro something like "_UUID", which we
would use as follows:

    constexpr uint128_t myuuid = _UUID;

which the preprocessor would turn into:

    constexpr uint128_t myuuid = 11223344556677881122334455667788u;

(Method No. 2) A constexpr function in the "std" namespace which you
would use as follows:

    constexpr uint128_t myuuid = std::uuid();

Now here's the next thing to address: How do we get the preprocessor /
compiler to generate the same UUID every time? Well I think the random
number could be generated from six items of data which we can use for
this:

    Datum No. 1: The name of the current source file
    Datum No. 2: The name of the current header file (if applicable)
    Datum No. 3: The contents of the current source file
    Datum No. 4: The contents of the current header file (if applicable)
    Datum No. 5: The count of how many times _UUID has already been
used in the current source file
    Datum No. 6: The count of how many times _UUID has already been
used in the current header file (if applicable)

All six data can be piped into something like the MD5 hash function to
give a 128-Bit digest.

Plus we would have to discuss what exactly is supposed to happen in a
scenario such as the following. Let's say we have a header file as
follows:

    [beginning of header file]
    constexpr uint128_t myuuid = std::uuid();
    [end of header file]

A const (or constexpr) global variable has internal linkage by
default. So if we were to include the above header file in say, 26
different source files, then should all 26 source files see the same
128-Bit number? What if we're building on MS-Windows and one file is
"myheader.hpp" but gets seen as "MYHEADER.HPP"?