Vector of shared pointers updates existing elements on push_back - c++

Question

Basically, I have a vector of shared_ptr as member data to a class.
This vector is populated by calling a member function from another class function.
Problem new elements added to the vector updates values of existing elements.
The setup is as follows:
class A
/*
* Class A has a header with class declarations and a distinct implementation.
* For the sake of brevity, the relevant information is shown in this snippet.
*/
class A {
public:
A(std::string name) : m_name(name);
std::string& get_name();
private:
std::string m_name;
}
typedef std::shared_ptr<A> A_ptr;
class B
/*
* Class B has a header with class declarations and a distinct implementation.
* For the sake of brevity, the relevant information is shown in this snippet.
*/
class B {
public:
void add_element(A_ptr& element) {
/*
this is where the problem is:
i DO get the proper element (i can verify this by calling the get_name() method on `element`).
Assume we got in succession:
- ONE
- TWO
- THREE
...
*/
std::cout << element -> get_name << std::endl;
m_elements.push_back(element);
/*
...
fast forward here, when I print the content of the vector held in this class,
the old elements added have been updated somehow and I get this:
- when we get ONE, the vector contains: [ONE]
- when we get TWO on the next call to this function, the vector contains: [TWO, TWO]. I expect [ONE,TWO]
- when we get THREE on the next call to this function, the vector contains: [THREE, THREE, THREE]. I expect [ONE, TWO, THREE]
-> WHAT ON EARTH IS GOING ON HERE?
*/
for (auto it = m_elements.begin(); it != m_elements.end(); ++it)
std::cout << (* it) -> get_name() << std::endl;
}
private:
std::vector<A_ptr> m_elements;
}
typedef std::shared_ptr<B> B_ptr;
class B is the problem class. In the add_element() function, I am getting the proper elements to add (namely ONE, TWO and THREE).
But, after the push_back(), not only the new element is added, the existing elements all have their values updated to the new element that got added.
So say I add elements with names ONE then TWO, instead of getting a vector with elements as [ONE, TWO], I get [TWO, TWO].
class C
/*
* Class C has a header with class declarations and a distinct implementation.
* For the sake of brevity, the relevant information is shown in this snippet.
*/
class C {
public:
void do_something() {
std::string name = name_obtained_dynamically();
B_ptr manager(new B());
do {
A_ptr element_one(nullptr);
A_ptr element_two(nullptr);
if (we_are_good) {
element_one.reset(new A(name));
}
else {
element_two.reset(new A(name));
}
if (element_one !=nullptr)
manager -> add_element(element_one);
else
manager -> add_element(element_two);
} while(condition_is_true);
}
}
class C calls add_element() from class B and keeps adding elements to said vector.
So far as I can tell, the problem probably lies with my use of shared pointers inside that loop.
But what exactly I am doing wrong, I cannot tell.