I don't think we should use a library facility in the core language section unless necessary to show the issue.

I suspect one could come up with an example static_assert that is illustrative, idiomatic, and does not use the stdlib

Please make a concrete suggestion.

Fair enough, here are some ideas:

static_assert(__cplusplus >= 201703, "This library requires C++17 or newer.");

static_assert(sizeof(void*) == 8, "This library requires a 64 bit address space.");

static_assert(CHAR_BIT == 8, "This library requires 8-bit bytes.");

static_assert(__STDC_­HOSTED__, "This library requires a hosted implementation.");

What I find most offensive about the status quo is that it suggests that it's somehow OK to depend on the signedness of char. The standard should be neither tutorial nor encouragement of bad practices.

@Eelis:

static_assert(sizeof(void*) == 8, "This library requires a 64 bit address space.");

This is not a good check, since size(void*) = sizeof(char) = 1 would be possible on a 64-bit machine.

static_assert(CHAR_BIT == 8, "This library requires 8-bit bytes.");

That requires a #include.

@tkoeppe: It's as "OK" to depend on the signedness of "char" as it is to depend on sizeof(void*) == 8 or CHAR_BIT == 8. Sometimes, you want to check for it because your algorithm breaks down otherwise, and getting a clean error message is much preferable over a wrong answer at run-time.

@jensmaurer I see you responded to 2 of my 4 suggestions. How do you feel about the other 2?

@jensmaurer: Hm, I think all of those would be in equally poor taste. Something more innocuous would be static_assert(alignof(T) > N) or some such, provided that T and N are some parameters in scope.

@Eelis: I'm not fully convinced by the suggestions; and I remember CWG having trouble coming up with a plausible example, too.
@tkoeppe: "alignof" is very platform-dependent, so that seems somewhat strange, too.
(Don't get me wrong; I think all the examples presented will appear in real code (maybe even more so than the status quo), but they still all feel awkward.)

Coming up with something that's obviously better is certainly a harder challenge than I expected! :)

I also tried finding examples with github code search, but couldn't find anything that meets all the criteria.

I guess if this has already been tried without success before, and we're ready to give up, then this can be closed.

@jensmaurer I think platform-dependant assumptions are exactly what you would use static_assert for, outside of type/value-dependent contexts in templates.

@AlisdairM: I agree, so what's wrong with the status quo:
static_assert(char(-1) < 0, "this library requires plain 'char' to be signed");
It's an obviously platform-dependent assumption.

@jensmaurer: I've actually seen this exact thing in real code twice recently, and it was never appropriate :-(

Checks for sizes and alignments are fairly plausible, say, if you want to build a buffer to hold arbitrary elements that get placement-constructed in it later, where the purpose of the static assertion is more to prevent misuse than to constrain the platform.

@tkoeppe: Fine, but
static_assert(sizeof(int) == 4, "requires 32-bit integers"))
is a bad check, too. (Think char = 9 bits and int = 36 bits, or sizeof(short) == 1, yet sizeof(int) == 4.)
So, it seems checking CHAR_BIT is the only reasonable thing so far, except that it's a library macro :-(

255 == (unsigned char)-1 ?

@jwakely: That one has the same issue as the status quo, namely that it would be more idiomatically expressed using a library facility.

sizeof(int) == sizeof(void*)?
Lots of legacy code likes to make this (frequently bad) assumption, that could at least be checked and errored?

Yeah, let's try that.

Awesome, thanks guys!