Take the following example. I create a function pointer named s, set it to f and call it. This compiles fine of course:
void f() {}
int main() {
void (*s)();
s = f;
s();
}
But take this next example, where I declare s now as a “function reference” (if it’s so called) and set to f inline. This compiles fine as well:
void f() {}
int main() {
void (&s)() = f;
s();
}
What are the differences between these two ways to create and initialize a function-pointer? Note that when I use the reference syntax I am required to initialize it “in-line” to f whereas with the “pointer” syntax I had the ability to do it both ways. Can you explain that as well? And with that, can you explain what their differences are in terms of usability, and when must I use one form over the other?
Fundamentally the calling side has no distinct difference. But the decl side definitely does. As you have pointed out, references must be initialized to reference something. This makes them “safer”, but even then there is no guarantee of “safety”.
The function pointer need NOT point to a function at all. It could be NULL, or even uninitialized (pointing to garbage). Not that it matters, because you can always change it later (something you can NOT do with references).
or
and later
You can do none of those with a reference. The reference must be initialized to something and preferabley something valid:
However, even here a function reference is not guaranteed to be safe, just safer. You can certainly do this:
You may get a compiler warning out of this (I do, “s used before being initialized”) but in the end
fstill is now a reference to a “function” that isn’t a function at all; just the random stack garbage in thespointer. Worse, since references cannot be reassigned. this thing will always point at garbage.