@0x00004 You can in theory prevent expensive calls / assignment on temporaries, but I think returning a const value ruins move semantics on chained calls
@0x00004 In certain languages, like C++, it makes sense to have functions return consts, with the idea being that sometime in the future you might change the value that it returns, and when re-compiling the program, the function is optimised anyway by the compiler.
They can work like `const` variables, except you should use each where it makes more sense. For example if you want to return the screen's width (for example) and you forced your game to only have 300px width and nothing else, you could `return 300;`, but your code would still call `getGameWidth();` to get that value.
So in the future, if you decide your game can support an arbitrary width, you can change the function to return that instead, and the code of your game doesn't have to change at all.
user92578
@TomTsagk But this is 100% an example where returning a const value doesn't make any sense
user92578
It should be int getGameWidth(), not const int getGameWidth()
user92578
I couldn't find any case where it would be useful to do that, since with const std::vector<int> MakeIntVector() and DoStuff(MakeIntVector()), where DoStuff has two overloads, void DoStuff(std::vector<int>&& v) and void DoStuff(const std::vector<int> v), the compiler has to choose the one that makes a copy instead of being able to move the temporary
You can still treat the function as a "variable", so the same way you would make a `const` variable, you can do a function instead, but its purpose is to calculate its value based on other const variables.
If you needed more than 1 statement to calculate the value of a const, or for readability, const functions have their uses, but I do agree, they are not used often
user92578
What do you mean with "const functions have their uses"?
user92578
I literally can't think of any reasonable reason to return a const value from a function
Can you think of a reason to use a `const` variable? What if calculating that variable needed 10 different `if` statements, all of them based on other `const` variables? Wouldn't it be more readable to have a function? (keep in mind the compiler optimises all of that away, so it makes no difference for the end user)
@Vaillancourt I assume people meant const int func(), as in, return a constant integer value from a function
I'm pretty sure int f() and const int f() are the the exact same thing. See this.
It does make a difference for non-builtins though and there are very rare cases when returning a const T is useful. It was something with regards to std::min where you have issues with unnecessary copies and returning references to temporaries.
@TomTsagk yes, and I don't think this makes sense either, if the call site wants to have it const, they can do const int funcRes = func();, forcing the call site to make the variable const is a bit annoying in this case ..
@Tyyppi_77 Well, I've made plenty of low-level programs that use even inline functions, I did mention functions returning a const is not something you see every day, but I can see a point in them, if you don't like them just don't use them, other people find them interesting
So many people jumped in that we don't know anymore what we are talking about. So far we have established that int foo() and const int foo() are the same thing and that std::string foo() and const std::string foo() are different things. And that making const std::string foo() useful and intended is difficult.
I remember a cppcon talk where they presented an example where returning a const T is useful and good, but even then it was rather questionable. But I can't remember the talk or the context enough to find a reference.
I'm fairly sure though it was related to std::min. You want to be able to do both int x{}; int y{}; int &m = std::min(x, y); and int m = std::min(x, -1); and implementing that without allowing int &m = std::min(x, -1); where m is an invalid reference is tricky.
And if you ever needed a reason why C++ is awesome: Only in C++ do people debate for week on how to implement a function that simply returns the minimum of 2 values.
user92578
Yeah I think only confusion that's left seems to be why @TomTsagk finds returning const int or something useful
user92578
@nwp Oh yeah that seems like a case where it would make sense, since you can't return a reference to a temporary or something, so you want to force min to choose an overload that doesn't take an rvalue reference
