What is safe? returning a structure or the pointer from a function

Question

#include <iostream>

struct person_t{
        int age;
};

person_t get_person1(){
        person_t person;
        person.age = 10;
        return person;
}

person_t * get_person2(){
        person_t *person = new person_t;
        person->age = 20;
        return person;
}

int main(){
        person_t person1 = get_person1();
        person_t *person2 = get_person2();
        std::cout << person1.age << std::endl;
        std::cout << person2->age << std::endl;
        delete person2;
        return 0;
}

I want to know what is the safest way to return a structure from a function.

As in the answers to the questions in here and here, it is said that when you create a object as in get_person1(), that object will be destroyed after when it goes out of scope.

But when I search for "How to return a struct from function c++", it suggest me method one (with get_person1()) (Example here). But I think that method will destroy the object after the function was called and I think method 2 is the safest.

Am I wrong here..? Or any opinion regarding this topic..?

Thank you!!

Answer 1

Use return by value for 3 reasons:

• It makes your code readable
• Your struct here is small (one int) so it is like returning an int. You can do that in C++, it is efficient
• In C++17 (and most compiler before that) the cost of the intermediate copy of the object will be avoided. It is known as RVO. You need to put only one return in your get_person function.

Answer 2

it is said that when you create a object as in get_person1(), that object will be destroyed after when it goes out of scope.

What is destroyed is the local object (i.e.: person inside get_persion1()). What is returned is a copy of that object: a struct person_t is copied (it may be moved as well). So, it is safe.

---

get_person2() is also safe, but consider using smart pointers instead of raw pointers :

std::unique_ptr<person_t> get_person2(){
        auto person = std::make_unique<person_t>();
        // For pre-C++14
        // std::unique_ptr<person_t> person(new person_t);
        person->age = 20;
        return person;
}

That way, the caller to get_person2() doesn't have to call delete (it may forget to do so).