pointer

If you try to cast a pointer into your function type, you'll get a runtime error, not a compile time one.

Container element types are almost never declared const unless their values are truly immutable (in this case the pointer is mutable, but the underlying memory is not, which is kind of strange).

They're useful anywhere you have a data that is sometimes small enough to fit within a single pointer-sized chunk, and sometimes isn't.

Unfortunately this isn't an option in Objective-C because the compiler can't make any assumptions about the tagged pointer implementation, and that means objc_msgSend has to start fresh at each invocation.

For pointers, however, the final keyword in Java limits the ability to change the variable holding the pointer, not to what it references.

The potential trouble is if the function pointer goes through a void* wormhole.

For instance, you won't get it on accessing the function pointer with dlopen/dlsym.

Whether it's worth the cost depends on how expensive memory allocation is, how expensive pointer indirection is, how many objects are able to fit within a tagged pointer, and how expensive the tag check is.

You can convert between pointers of different object types, and you can convert between pointers of different function types, but you're not allowed to convert between a pointer of object type and pointer of function type (c.f.

But on DSPs, it's common for data and code memory to be distinct address spaces, and the two pointer types aren't necessarily the same size.

That was the perfect place to hide the pointer for a linked list I wanted to create in an intermediate step.

Or if you to, say, move a reference all the way down into a pointer (or vice versa) to interop with C or other legacy code.

Java (the language) does not possess the semantics to express "the pointer given to a method cannot allow changes to what it points."

They don't have a "this" pointer with associated fields to manipulate.

I expect the string "née" would become a tagged pointer string, for example.

The equivalent in C++ would be: SomeClass * const foo = &instanceOfSomeClass; Here, the pointer "foo" could not change, but operations changing foo would be allowed.