deREferencing | IDA Pro plugin that implements more user-friendly register | Plugin library

The compiler can decide to implement references as pointers, or inlining or any other method it chooses to use. In terms of performance, it's irrelevant. The compiler can and will do whatever it wants to when it comes to optimization. The compiler can implement your reference as a pass-by-value if it wants to (and if it's valid to do so in the specific situation). Caching the result won't help because the compiler will do that anyways. If you want to explicitly tell the compiler that the value might change (because of another thread that has access to the same pointer), you need to use the keyword volatile (or std::atomic if you're not already using a std::mutex).
Edit: The keyword "volatile" is never required for multithreading. std::mutex is enough.
If you don't use the keyword volatile, the compiler will almost certainly cache the result for you (if appropriate). There are, however, at least 2 actual differences in the rules between pointers and references.

1. Taking the address (pointer) of a temporary value (rvalue) is undefined behavior in C++.
2. References are immutable, sometimes need to be wrapped in std::ref.

Here I'll provide examples for both differences.

This code using references is valid:

When you write printf("%.*s", len1, str1), where len1 is zero and str1 is a null pointer, you are using a s specifier and setting the precision to 0. I looked through the relevant parts of section 7.21.6 of N1570. When documenting the s specifier, it says:

the argument shall be a pointer to the initial element of an array of character type. Characters from the array are written up to (but not including) the terminating null character. If the precision is specified, no more than that many bytes are written.

So, technically, just looking at the first part of that quote, you do need to provide a pointer to an array instead of providing a null pointer. So your code is not following that part of the standard.

However, you set your precision to 0, so the second part of the quote tells us that the printf function is not actually going to write any characters from that array to the output. This implies to me that it won't try to read any characters either: reading past the end of the array is unsafe so printf implementations should not do that. So your code will probably work in practice and it's hard to imagine a case where it would fail. The biggest problem I can think of in practice is that static analyzers or validators might complain about your code.

First, for your second line

It is possible in non-standard standard C, thanks to typeof. typeof is also a further proposed feature for C23, so it may become possible in standard C23. One of the solutions below makes some sacrifices which allow C99 compliance.

Let's look at how the approach using union works first:

When you apply filtering using Where, you eliminate all null values, but this doesn't change the type of values.
All you need is to cast the results after filtering to the proper type:

Why do we use ptr without dereferencing it with (*ptr).

We're passing scanf the pointer to memory on which to write the int that it gets from the keyboard. To dereference is to follow that pointer ourselves, which doesn't help scanf know where to write the value.

When we use scanf we type in a value (int or double or float) and not an address so why's that ptr without * ?

The & in &N is the address-of operator, meaning "make me a pointer to N". You could write int *N_ptr = &N; then scanf("%d", N_ptr); if that makes it clearer.

One other thing: passing arguments/parameters in C is done by copy. Meaning:

This can be done by reimplementing the operator so that its internal data holds just the bool value, instead of the floating point value from which the bool value is derived only when the iterator gets dereferenced.

In other words, the dereferencing iterator should simply be:

Problem #1: potentially_mutate is incorrectly marked as a safe function while it can cause undefined behavior (e.g. what if I pass in an invalid pointer?). So we need to mark it unsafe and document our assumptions for safe usage:

From The Rust Programming Language:

Deref coercion is a convenience that Rust performs on arguments to functions and methods. Deref coercion works only on types that implement the Deref trait. Deref coercion converts such a type into a reference to another type. For example, deref coercion can convert &String to &str because String implements the Deref trait such that it returns &str. Deref coercion happens automatically when we pass a reference to a particular type’s value as an argument to a function or method that doesn’t match the parameter type in the function or method definition. A sequence of calls to the deref method converts the type we provided into the type the parameter needs.

Deref coercion converts references into references. It will auto-deref &value to &*value, &**value, &***value, etc., in order to convert one reference type into another that fits a parameter signature. The starting and ending types are always references.

Notably, it doesn't put the deref on the front. It doesn't do &value to *&value to **&value, which is why it won't convert &String to String or String to &str.

• Turning &String into String would turn it into a move. If I wrote func(&s) and func takes a String it would be confusing if that compiled and actually moved s.

• Similarly, turning String into &str would turn a move into a pass-by-reference. If I wrote func(s) I'd expect s to be moved, with ownership transferred to func. It should not compile if func takes a &str and I pass a String.