C++ class changing what "*this" refers to - c++

Question

I have a class "foo" which contains a member vector which holds elements of type "foo". This class has a method called "make", which creates "foo" objects and appends them to the vector. I also provide a method for navigating the "foo" object and it's "foo" vector elements called "get".
I would like to re-assign what "this" refers to on any "foo" object to point to a foo object within it's vector. I would like to give the code this functionality as a way to more efficiently navigate and keep track of foo objects without having to bind references to specific "foo" members. I am attempting to do this through a method called "setAsNode" which reassigns what "*this" is.
Here's some example code I mocked up which I believe gets my point across:
struct foo{
foo(const std::string &r):s(r){}
foo& make(const std::string &r){children.push_back(test(r)); children.back().originalNode = originalNode; return children.back();}
foo& setAsNode(){*originalNode = *this; return *originalNode;}
foo& get(int i){return children.at(i);}
private:
std::vector<foo> children;
std::string s = "someData";
foo *originalNode = this;
};
and a practical example of how this would function:
foo f1("test1");
f1.make("test2").make("test3");//pushes a new foo element back to the vector in f1 and pushes a new foo element back to it's vector
f1.get(0).get(0);//refers to the deepest nested object we just made above, cumbersome to type especially if the nesting is deep
f1.get(0).get(0).setAsNode();//this is where the error occurs, the desired effect is to make f1 the same object as denoted by f1.get(0).get(0);
foo& f2 = f1.get(0).get(0);//f2 would be equivalent to what I want the above code to reset f1 to be (or at least how I'd like it to act)
I realize I'm probably implementing some very bad programming practices such as using references instead of pointers for returning "foo" objects, but I honestly do not know how to correctly structure a program such as this, or how a best practice version of this program would look/work. Bonus points for whoever can show me the "right" way of doing things.
Back to the real question though: how would I make something like this, specifically the "setAsNode" method, actually work? Also, why doesn't the code in my example work? Note, it compiles fine, just crashes upon running.

Answer 1

The c++ way (and arguably only correct way) is to separate concerns.
A foo is not (or should not be) a foo-finder. It should do foo-things, not foo-navigation things.
Make a new class to act as the cursor or iterator of your foo.
Here is a slightly expanded version, in which the foo_cursor remembers its journey through the foo stack. Probably overkill for your problem but it demonstrates the principle of separating foo-navigation logic from foo-implementation logic.
The more you do this, the easier your programs will be to write, debug and maintain.
#include <utility>
#include <string>
#include <vector>
#include <stack>
#include <stdexcept>
#include <iostream>
struct foo{
foo(const std::string &r)
: children()
, s(r)
{}
foo& make(const std::string &r)
{
children.emplace_back(r);
return children.back();
}
foo& get(int i)
{
return children.at(i);
}
void print() const {
std::cout << s << std::endl;
}
private:
std::vector<foo> children;
std::string s = "someData";
};
struct foo_cursor
{
foo_cursor(foo& f)
: current_(std::addressof(f))
{}
foo_cursor& down(int i)
{
history_.push(current_);
current_ = std::addressof(current_->get(i));
return *this;
}
foo_cursor& up() {
if (history_.empty()) {
throw std::logic_error("went up too far");
}
else {
current_ = history_.top();
history_.pop();
}
return *this;
}
foo* operator->() const {
return current_;
}
private:
foo* current_;
std::stack<foo*> history_;
};
int main()
{
foo f("a");
f.make("b").make("c");
auto fc = foo_cursor(f);
fc.down(0).down(0)->print();
fc.up()->print();
fc.up()->print();
}
expected output:
c
b
a

Answer 2

In your example, the call to foo.get(0).get(0).setAsNode() will attempt to copy the value of foo.get(0).get(0) to foo. In the process, foo.children will be assigned a new value, causing the vector to clear it's previous elements leading to the destruction of foo.get(0).get(0). This means that this has been destroyed and that the pointer can't be used. However, this is happening during an assignment operation which us currently using this. To solve this, you must insure that the value being copied persists long enough to be copied. The intuitive solution might be to copy the value to assign before assigning it.
foo& setAsNode() {
auto this_copy = *this;
*originalNode = std::move(this_copy);
return *originalNode;
}
This will work, you still have to be careful never to use this after the assignment to *originalNode. Another solution would be to take control of originalNode's children vector before preforming the assignment. In this version this remains valid until the method returns but if the following assignment throws an exception your tree will be left in an invalid state.
foo& setAsNode() {
auto original_vect = std::move(originalNode->children);
*originalNode = *this;
return *originalNode;
}
All in all, I would be wary of a design that calls for objects to commit suicide. It implies object controls their own ownership or that ownership responsibilities are otherwise cyclical.