Overloading = operator paradox - c++

Question

So say I have
Class Person{
private:
Person* _friends[10];
public:
//All methods listed below. Except for the main one, that is.
}
Person::Person()
{
for(int i=0; i < 10; i++)
_friends[10] = 0;
}
Person* Person::getFriends()
{
return _friends;
}
void Person::addFriend(Person* buddy) //Assume it's fully functional.
{
//code for adding a friend.
}
void Person::operator=(Person& p)
{
for(int i = 0; i < 10; i++)
_friends[i] = p.getFriends()[i];
}
int main()
{
int user1size = 10;
int user2size = 30;
Person* user1 = new Person[10];
Person* user2 = new Person[10];
//assume these 4 next lines will be repeated with different values a few more times, in more intricate ways, by the magic of for/while loops.
user1[0] = new Person();
user2[9] = new Person();
user1[0].addFriend(user[9]);
user1[9].addFriend(user[0]);
for(int i = 0; i < user1size; i++)
{
user2[i] = user1[i]; //Here is where the paradox starts.
}
delete [] user1;
return 0;
}
So well, my question is where does it stop? I mean, my intent is to only copy the reference to the Person objects inside the _friends array, but I understand that might be little to no possible, so the solution is to keep "copying" these Person objects too, who in turn also have a list of friends, and these friends also have friends and so on. I know it has to stop somewhere, but I don't really want it to go all the way through and not to even mention I don't want some Person objects to be over-copied or catch in an infinite loop.
so how to solve this paradox?
P.S. : Please understand if my code has a lot of mistakes or is crappy. I made it in the go and all I intend with it is to make you all catch the general idea.
P.S.2: I cannot use any other library other than <ostream>, yup sucks for me.
P.S.3: Any website/article you could provide me to read about this would make me so happy! Thank you beforehand.

Answer 1

Well, first of all, what you probably want to do is to just copy the pointers as they are.
Why? Because if person "A" has a friend "F", and person "B" has the friend "F" as well, they will probably refer to the same person "F" object. If you make a deep-copy as you suggested, and you copy A to A2 and B to B2, you will have a total of three distinct person "F" objects -- the original, referenced from A and B, a copy referenced from A2, and another copy referenced from B2.
Of course, this might be what you want; I can't know that. But in many cases it's not.
The whole pointer setup will work just fine, although you have to be careful with memory management: you can easily end up with pointers to persons that no longer exist
If you do want to do a deep copy (a "deep copy" is a copy where referenced objects are copied too) you'll have to find cycles yourself, for example by tracking which objects you have copied already. I won't be trying to sketch something like this now, as it can get somewhat complicated and I don't think you actually want to deep copy your "person" objects.

Answer 2

There is no paradox because you are not doing a deep copy. Check out this declaration:
Person* _friends[10];
This says _friends is an array of pointers to Person objects. Correctly copying in operator=() this array will not call operator=() on each Person in the array.
However, the following function will not compile:
Person* Person::getFriends()
{
return _friends;
}
The return type and the type of _friends does not match. This is why it is important to post code that compiles and exactly reproduces the problem you have encountered.

Answer 3

IIUC, you want to know how to handle copies of graphs of objects, and you want to maintain their connections in the graph. Let's say Joe has a friend Bill and Bill has a friend Joe, and you copy Joe (lets name the copy Joe'), you want Joe' also have a friend who has (reflexively) Joe' as a friend. This problem typically comes up when programming compilers.
The easiest way to actually do this is never do any copies. Let the objects reside in their memory locations, use references/pointers to them all the time and modify them destructively.
However, it is sometimes needed to copy the objects, possibly modifying the graph (in the compiler scenario, that might mean eg. inlining a function). In that case, you employ a simple graph traversing algorithm, the DFS, roughly like this:
// o will be the object to copy
// m will be a map (old object -> new object)
copy(object* o, map& m) {
if(m.contains(o))
return m[o];
object* n = allocate new object;
m[o] = n; // set the map beforehand, in case we have some back edges from this subtree
n.subobject = copy(o.subobject, m); // for each subobject, or relation. In your case, friend
return n;
}
If you want just to move some object to a new location, you can just traverse the whole graph and overwrite the pointers. This is much easier if you have back edges in your graph, too (ie. not only "friends", but also "people whose friend I am"). Still, the best option is to avoid it; that means not creating arrays of Persons that might grow and make arrays of Person*s, so that the real Person still stay in the same memory location.