Return a large struct object by value or pointer to dynamic allocation on C++ [duplicate]

Question

Here is my problem. I have a function that takes struct as input, allocates a new struct and then returns it. The struct has the following contents

struct Data {
std::vector<custom_type> vector_vars;
std::string key;
std::map<std::string, Data*> index;
};

vector_vars is of size 500-1000. custom_type if relevant is this class. The index helps me access different Data struct by key. This is the function.

Data func(Data inputData) {

 Data outputData;
//compare values with inputData
//change some values in Data struct
 return outputData
}

1. Do I use stack allocation and return it so that it is copied to RHS. Is this advisable since copying may create a lot of overhead?

2. Can I return a reference/pointer to struct allocated on the stack within a function?

3. Is it advisable to use dynamic allocation instead here (may be with std::shared_ptr) for efficiency?

Answer 1

1. Return the object by value. Copy elision is an optimization that the standard allows compilers to make that removes unnecessary copies. In C++03, the copy will almost certainly be elided by the compiler. In C++11, the copy will first be considered as a move (which will in turn move its contents) and even that may be elided.

   in a return statement in a function with a class return type, when the expression is the name of a non-volatile automatic object (other than a function or catch-clause parameter) with the same cv-unqualified type as the function return type, the copy/move operation can be omitted by constructing the automatic object directly into the function’s return value

   Specifically, when this criteria results in copy elision, it is commonly known as named return value optimization, a form of return value optimization.

   So the most idiomatic and performance-friendly option here is to return by value. Of course, if you measure that even under optimization returning by value is a problem, then sure, you may consider dynamically allocating (see point 3).

2. No, you should not return a reference or pointer to a local variable. The object with automatic storage duration (what you refer to as allocating on the stack) will not exist any more. The reference or pointer will be left dangling. Using it in any meaningful way will result in undefined behaviour.

3. No, as mentioned above, it is advisable to return by value. However, if you really, really need to, you may dynamically allocate your Data and return it by smart pointer. The preferred smart pointer here would be a std::unique_ptr as your function is passing ownership to the calling function (not sharing ownership).