While looking at the GCC's warning options, I came across -Waggregate-return.
-Waggregate-return
Warn if any functions that return structures or unions are defined or called. (In languages where you can return an array, this also elicits a warning.)
small example that elicits the warning:
class foo{};
foo f(void){return foo{};}
int main(){}
$ g++ -std=c++0x -Waggregate-return -o main main.cpp
main.cpp: In function ‘foo f()’:
main.cpp:2:5: warning: function returns an aggregate [-Waggregate-return]
another small example that does not elicit the warning:
#include <string>
std::string f(void){return "test";}
int main(){}
What is the benefit gained from using -Waggregate-return?
Why would someone want to be warned about this?
Also, isn't std::string a class?- why arn't I warned about the 'returned aggregate' in the second example?
Following the comments made by @AlokSave, here is a later edit of the answer:
Since the documentation about this compiler flag is scarce, it is somewhat unclear what its original meaning is, but there are, mainly, two possible explanations:
Warning the user about returning an aggregate object makes them aware that the stack could overflow if the aggregate object (which is allocated on the stack) is returned.
Apparently, some old C compilers did not support returning aggregates (you had to return a pointer).
Which of the two is the best one, it is hard for me to judge. However, more relevant information about this flag may be found at the following links:
http://bytes.com/topic/c/answers/644271-aggregate-return-warnings
https://lists.gnu.org/archive/html/bug-gnulib/2012-09/msg00006.html
Quoting from the latter link:
In the GNU apps I'm familiar with (Emacs, coreutils, ...) we simply disable -Waggregate-return. It a completely anachronistic warning, since its motivation was to support backwards compatibility with C compilers that did not allow returning structures. Those compilers are long dead and are no longer of practical concern.