I see functions/methods with a void return in the signature that have a return statement at the end of the function. What is the reason for this, and does this apply to other languages?
For all I know, I can use return if I want to exit anywhere else but the end of the function.
A C example:
void funtion(void)
{
int x = 1 + 2;
return; // what do we need this for, if at all?
}
As you mention yourself, you only need the return statement if you want to exit the function before the last statement. In the given example the return statement serves no purpose whatsoever.
My guess it is because function used to return some value and a programmer probably thought that it will again.
It is indeed pointless... at least to the compiler, but stylistic, much like many things in C++. An example:
int main ()
{
DoSomething ();
return 0;
}
In C++ the return 0 is entirely pointless as far as a conforming compiler is concerned. Yet sometimes people prefer to include redundant or meaningless statements just to be explicit. I'd be hesitant to chalk these kinds of things up to programmer ignorance. It's just stylistic, feel free to get rid of it if you feel like it.
This seems pointless here. But my guess is that this kind of thing can be used to put a breakpoint in IDEs which don't support putting a breakpoint at the closing brace and by putting a breakpoint here, some values can be checked in the watch window etc.
It's useless in C/C++ and just reduces readability.
One real language example where this is needed is assembler. But in assembler the return statement is not a part of language. Instead you have to invoke a special instruction (ret in x86) which causes return of control. Unless you do it execution just continues and what will happen next depends on may factors, luck and moonphase included.
Someone took a 'a function must have a single return' coding guideline too literally.
I always include a return statement at the end of my functions, even when they don't return anything. My original reasons for it were that I was being explicit, there was no ambiguity about where the function ended, I always got irked by functions that "walked off the end". Afterwards, it was simply a habit, hard to break (if I wanted to).
For a function that returns void, it doesn't matter, since "falling off the end" of a void function simply returns as you would expect.
However some people like to do this to aid future maintenance. For example, if someone later decides to change the return type of the function to say int, you should get a compiler error if you forget to change that final return statement to make it return an int value. If you failed to have a return statement at all, the return value is undefined, and many older compilers wouldn't warn you about this (it's true - I've seen it!). This isn't much of a issue these days, as most modern compilers will warn about these things.
Some compilers can optimize code based on return statements.
"Use the Return statement whenever your logic permits it. For more information, see Return Statement. The compiler can optimize the code better than if you use Exit Function, Exit Property, or Exit Sub, or allow the End Function, End Get, End Set, or End Sub statement to generate a return"