References in vector lose their value - c++

Question

first I want to say that using references to Value in this example is a must.
So,I have a tree (for simplicity, this is tree with nodes that can only have one child, this code is not my original assignment, but the problem is the same) and I want to store values in it.
To export the values, i have to use vector of std::pairs, with key and reference to value.
I'm trying to do that in a recursive function 'col', to push_back the values one after another.
My problem is, the final values are different. When i switched references to pointers, it worked properly. But as I said, it has to be references.
I don't understand, whats the difference between those two in this case? They both should point to a memory on a heap and that address should stay the same, right?
Here is the code:
#include <memory>
#include <vector>
#include <iostream>
template <typename Value>
class Tree {
public:
class Node {
std::unique_ptr<Value> value;
std::unique_ptr<Node> child;
public:
friend Tree;
Node(const Value i) : value(std::make_unique<Value>(i)) {}
Value* getvalue() { return value.get();}
Node* getchild() { return child.get();}
};
const std::vector<std::pair<std::string,const Value&>> collect() {
std::vector<std::pair<std::string,const Value&>> list;
col(list, root.get());
return list;
}
void col(std::vector<std::pair<std::string,const Value&>>& list, Node* node) {
list.push_back(std::make_pair("k", *node->getvalue()));
if (node->getchild() != nullptr) {
col(list, node->getchild());
}
}
void addNode(const Value i) {
add(root.get(), i);
}
Node* getroot() { return root.get();}
private:
std::unique_ptr<Node> root = std::make_unique<Node>(0);
void add(Node* node, const Value& i) {
if (node->getchild() == nullptr) {
node->child = std::make_unique<Node>(i);
} else {
add(node->getchild(), i);
}
}
};
int main() {
Tree <int>t;
t.addNode(1);
t.addNode(2);
t.addNode(3);
auto a = t.collect();
for (auto p : a) {
std::cout << p.first << " " << p.second << "\n";
}
}
The output is:
k 0
k -424282688
k -424282688
k 0
(and is different after each call)

Answer 1

list.push_back(std::make_pair("k", *node->getvalue()));
std::make_pair deduces the template arguments for std::pair from its function arguments, and never uses reference types for them (note the std::decay part on the linked page). So the return type of make_pair is std::pair<const char*, Value>, instantiated as std::pair<const char*, int>. The int second; member of this pair is a copy of *node->getvalue().
vector<T>::push_back(T&&) requires an argument of the actual element type, which here is T = std::pair<std::string, const int&>. There's an implicit conversion from std::pair<const char*, int> to std::pair<std::string, const int&>: the std::string first; member is constructed from the raw string pointer, and the const int& second; member is bound to the member of the input pair.
But the std::pair<const char*, int> was a temporary, so as soon as the statement ends, the lifetime of the copied and referenced value is over. Next time you try to use the reference, bang.
Instead of using make_pair, specify the exact type you need:
list.push_back(std::pair<std::string, const Value&>("k", *node->getvalue()));
or
list.push_back(decltype(list)::value_type("k", *node->getvalue()));
or put a using OutPairType = std::pair<std::string, const Value&>; in the class definition and use that instead of typing it out elsewhere.
Also note that when a std::pair has reference members, like the default behavior of any struct with reference members, the operator= copy and move assignment operators will copy or move the referenced objects. They will not (and cannot) change the reference member to refer to the same object as the right hand side's member, like a pointer assignment would. And std::vector sometimes uses operator= of its value_type (though not in push_back). You might want to consider using std::pair<std::string,std::reference_wrapper<const Value>> instead.