Variable being deallocated after function call - c++

Question

I'm a beginner in C++ and ran into a problem. Please see my code below. The issue is described in the inline comments.
#include<iostream>
#include<tuple>
#include<vector>
// #include "test.hpp"
using namespace std;
vector<string*> test();
int main() {
vector<string*> ret = test();
cout << ret.back() << endl; //Outputs: Memory of String str
cout << *ret.back() << endl; //Outputs: random undefined behavior
//I want this to output "s"
}
vector<string*> test() {
vector<string*> ret;
string str = "t";
ret.push_back(&str);
cout << ret.back() << endl; //Outputs: Memory of String str
cout << *ret.back() << endl; //Outputs: "t"
str[0] = 's';
cout << ret.back() << endl; //Outputs: Memory of String str
cout << *ret.back() << endl; //Outputs: "s"
return ret;
}
Basically I want to have it so that I can declare an object in a function body, add it to a vector, and be able to modify the object again later in the function (any time in the future) and be able to see these changes anywhere I have this vector. This can be easily done in Java, but I'm having trouble doing it in C++.

Answer 1

Objects declared with automatic lifetime always cease to exist when the scope in which they were created is left.
If you want an object to survive beyond the scope in which it was created you must create the object with dynamic lifetime, using (directly or indirectly) the new keyword. Remember though, C++ has no garbage collector, so for every use of new you must delete the created object when you're done with it. The best way to do that is to use some form of smart pointer, like std::unique_ptr or std::shared_ptr (which to use depends on your exact situation):
std::vector<std::unique_ptr<std::string>> test() {
std::vector<std::unique_ptr<std::string>> ret;
std::unique_ptr<std::string> str = std::make_unique<std::string>("t");
ret.push_back(std::move(str));
//...
return ret;
}
(std::make_unique uses new to create a new object and returns a std::unique_ptr to it)
In this particular case there's really no advantage to storing pointers to strings in your vector though. A std::string object is essentially a smart pointer to an array of characters, so you can just store the objects directly:
std::vector<std::string> test() {
std::vector<std::string> ret;
ret.push_back("t");
//...
return ret;
}

Answer 2

Stop using pointers. They have their place in C++ but not in the code you've posted.
The specific problem is this:
string str = "t";
ret.push_back(&str);
You are storing a pointer to a function-local std::string object. At the end of the function the std::string goes out of scope and is destroyed, leaving you with a dangling pointer and undefined behavior.
Change vector<string*> ret; to vector<string> ret;. Store objects instead of pointers, value semantics are easier to reason about. Standard library containers and strings are designed to do the right thing and make all of this simple.

Answer 3

You want to change this:
string str = "t";
ret.push_back(&str);
To this:
string* str = new string("t");
ret.push_back(str);
The problem is that in your original example your string gets destroyed when you exit test(), meaning that its memory address now points at nothing. To avoid this, you want to allocate str on the heap by using a pointer so that the memory isn't cleaned up after you exit test().
Just remember that whenever you manually allocate memory in C++, you must deallocate it to avoid memory leaks:
for (string* i : ret) {
delete i;
}

Answer 4

You are pushing back the address of a local variable. When the variable goes out of scope, that memory address is freed.
You can use unique_ptr or shared_ptr instead, something like this:
#include<iostream>
#include<tuple>
#include<vector>
#include<memory>
// #include "test.hpp"
using namespace std;
vector<std::shared_ptr<string>> test();
int main() {
vector<std::shared_ptr<string>> ret = test();
cout << ret.back() << endl; //Outputs: Memory of String str
cout << *(ret.back()) << endl; //Outputs: "t"
}
vector<std::shared_ptr<string>> test() {
vector<std::shared_ptr<string>> ret;
const auto str = std::make_shared<string>("t");
ret.push_back(str);
cout << ret.back() << endl; //Outputs: Memory of String str
cout << *(ret.back()) << endl; //Outputs: "t"
return ret;
}