Hi,
What's is the best practice for values return in a function in C/C++ for Game Engines??
In C/C++ I can return one value with the sentence return.
Texture = LoadTexture(path);
or I can return the value on second via
LoadTexure(path, &Texture);
The latter convention is commonly used when you want to return an error code that tells you exactly what went wrong, the former convention is used when you're happy enough with just knowing if there was an error or not (e.g. return NULL if you couldn't load the texture). Note that in this case you can still make a separate function to retrieve the exact cause if you need.
So it really depends on how you want to handle errors, pretty much.
Almost every function in my engine is of the form:
error = function_name (arg1, arg2, arg3...);
The return value is always an error number. However, if all the function needs to return is a positive integer, you can return that in the return value.
Almost every function call is followed by:
if (error < 0) { return (error); }
... or sometimes some other code or function call might be tried before or instead-of the return(error); portion.
Overall, the following is common (though some elements are not required in many cases).
error = value = function_name (arg1, arg2...); // skip "value =" portion if only error values are returned
if (error < 0) {
free_resources (arg1, arg2, arg3...);
return (error);
}
// continue on with valid positive value
The above approach has proved the most convenient for me over many applications and libraries, after trying all sorts of alternatives. One equally viable approach, and possibly better because it is more consistent, is to never return anything but error values from functions, and remove all values in arguments. I didn't do that, but now and then think that's a better approach (because absolutely uniform in layout).
I'm a natural advocate of Stroppy's solution which corresponds better the the equivalent in pseudo code. errors can be handled via exceptions for better messages/codes.
especially now that there is std::move.
I agree with Stroppy and Lightness - returning the value that is expected result of a function (instead of some error) is the way to go. Returning error codes is one of most counterintuitive ways for dealing with things.
Of course it all depends on the case - in your case you just want to return Texture so go with your first suggestion, like:
std::shared_ptr<Texture> texture = textureCache.GetTexture("...");
I can hardly think of situation that would justify what was suggested above about using return value only for error code (and returning objects by assigning to reference). First of all, its quite hard to determine quickly what happens because you may have references that have different meaning: in, out, in/out. There is no special syntax to indicate it so you have to write a description. If you really need several error codes (which is IMO very rare and if you write code that requires it very often, something is wrong.. - there are cases where such coding is probably only way to achieve something, but I doubt that your case belongs there).
If you REALLY need to use this approach, at least:
int LoadTexture(const string& name, const Type& type, Texture& texture)
{
if (load_from_file(name, type))
{
texture = <loaded texture>
return SUCCESS;
}
return FAILURE;
}
Here references that are only for reading are marked const, while your return reference is not - its easier to know whats going to happen that way.
I generally stick with.
int DoSomething(); // return a single value
void DoSomething(int* const result); // multiple value
If you've never seen const in that specific position (between the pointer and name), it means you can change the data but not the pointer (barring any goofy tricks).
Hi,
What's is the best practice for values return in a function in C/C++ for Game Engines??
In C/C++ I can return one value with the sentence return.
Texture = LoadTexture(path);
or I can return the value on second via
LoadTexure(path, &Texture);
In both examples the variable Texture is get by the function LoadTexture.What's is the better??Thanks
When you return by reference, the value is directly written to the variable and you effectively avoid creating a temporary object that will be copied to your variable. The cost of creating that temporary object and the cost of the copy could be potentially be a performance hit. So to answer your question, it is good practice to return by reference wherever possible.
