Today's episode of “something I didn't know about C++”:

class whynot { friend void; };

Today's episode of "something I didn't know about C99":

int derp(int arr[static const restrict volatile 5]);

I knew `static 5` meant non-NULL, at least 5 elements.

Didn't know:
∙ const: always called with same array
∙ restrict: arrays don't alias
∙ volatile: NOTHING

Today's episode of "something I didn't know about C99":

error: parameter name omitted
int main(int, char**) {
^

All function parameters must be named

Today's episode of "something I didn't know about C++":
you can have a declaration in a for-loop's *condition*

void use(unique_ptr<int>);
void drain(vector<unique_ptr<int>> v) {
for (int i = 0; auto el = move(v[i]); ++i)
use(move(el));
} // https://godbolt.org/z/ug2827 

Today's episode of "something I didn't know about C++":
template<class ...Ts>
void ellipsis(Ts......);

Template parameter pack, followed by C-style varargs that doesn't use the (optional!!!) comma.

Today's second episode of "something I didn't know about C++":

operator auto()

It's a thing. It has (inadvertent) meaning. h/t @AlisdairMered

Today's episode of "something I didn't know about C":

union U { int : 0; };

Unions can contain bit-fields, including zero-sized anonymous bit-fields (which in a class makes the next bit-field start at an allocation unit's boundary, in a union… nothing).

Today's episode of "something I didn't know about C and C++":

int size() {
struct empty {};
return sizeof(struct empty);
}

This code returns 0 in C and 1 in C++, because empty structs have different size in both languages.

Today's episode of "something I never imagined that I would see in real C++ code":

#pragma clang diagnostic error "-Weverything"

Today's episode of "something I didn't know about C++": falling off the end of a function try block does an implicit rethrow for constructors and destructors, but falls off the end of the function otherwise (which only main turns to an implicit `return 0;`).
h/t @MalwareMinigun

Today's episode of "something I thought only browsers did and surely C++ compilers didn't": clang's __VERSION__ emulates GCC's and prints out as:

"4.2.1 Compatible Clang 9.0.0 (trunk 355887)"

Just like browser User-Agent string!

Today's episode of "something I didn't know about C (but not C++!)": you can define a type in offsetof and in casts!

int o = offsetof(struct S { int a; }, a);

Macro expands to:

((size_t)&(((struct S { int a; } *)0)->a))

Watch those commas though! Likely fixed in C2x.

Today's episode of "something from C99 making its way into a weird C++ extension":

using abominable = void() const const const const const const const volatile volatile volatile volatile volatile &&; https://twitter.com/jfbastien/status/1113560327583453186

Today's episode of "something that endlessly amuses me about the C++ Standard":

"Stable names" for sections of the Standard include [over.ass] and [expr.ass].
Hehe, ISO-standard ass.
/cc @xexd
http://eel.is/c++draft/over.ass
http://eel.is/c++draft/expr.ass

Today's episode of "something I didn't know about C++ constexpr": case labels can be constant expressions.
Unfortunately, they can't be recursive
https://godbolt.org/z/Ye5Tid 

Most interesting question: what's the order of evaluation of constexpr case labels?

Today's episode of "GCC tries to pull heroics in constexpr statement expressions".
Can you guess which value gets picked?
https://godbolt.org/z/NtlPkm 

Today's episode of "something I didn't know about C++ type traits":
is_­constructible<T, Args...> is true if the type is constructible... as well as destructible! It's not true if the type is constructible but not destructible.

Today's episode of "fun clang extension to C++": duplicate qualifiers without typedefs.

const const const
const int const
const const const CONSTANT_FORTRESS = 0;

Today's episode of "something I didn't know about C++"

You can:
⁃ delete operator new
⁃ delete operator delete

*Cannot* new operator new.

struct S {
void* operator new(size_t) = delete;
void operator delete(void *) = delete;
void* operator new(size_t) = new; // No!
};

Today's episode of "something I didn't know about GNU C extensions":

There's a feature called "GNU case range extension"

enum enumeration { A, B, C, D, BORING };
int amazing(enumeration amaze) {
switch (amaze) {
case A ... D: return 42;
case BORING: return 0;
}
}

Today's episode of "something I didn't know about C++ until C++17 took it away":

You've all heard of "POD" types?

There used to be "Plain Old Function" (POF!) which defined what was callable from a signal handler.

Removed from C++17 by https://wg21.link/P0270 

Today's episode of "something C++ used to disallow":

switch on floating-point values!

https://godbolt.org/z/mk2Q8e 
@stephentyrone

Today's episode of "fun C / C++ extension":

asm labels!

Specify the name to be used in assembler code for a function or variable: write asm keyword after the declarator. Don't like C++ mangling? No problem!

Unfortunately doesn't work with NTTPs

https://godbolt.org/z/nAFvoP 

Today's episode of "fun things allowed by C++'s odd Unicode support":

using ಠ_ಠ = void;

Valid in major compilers: https://godbolt.org/z/uHTF3m 

http://Seewg21.link/1949  for a cleanup!

h/t CSS for being more liberal: https://twitter.com/tabatkins/status/1099050056760487936

Today's episode of "over-qualified for C++":

clang supports more than the usual "const" and "volatile" qualifiers.

It supports const, volatile, restrict, __unaligned, _Atomic, as well as 256 distinct address space.

Over-qualified indeed! https://twitter.com/jfbastien/status/1017819242815631360

Today's "fun extension to C to make it look like C++": overloading! Who needs _Generic?

float __attribute__((overloadable)) tgsin(float x) { return sinf(x); }
double __attribute__((overloadable)) tgsin(double x) { return sin(x); }

https://clang.llvm.org/docs/AttributeReference.html#overloadable