i have the class
class Circle : public isCircle{
private :
int x;
int y;
vector<Circle*> _neighbors;
}
where isCircle is just an interface (with virtual methods), and the Circles which _neighbors contains pointers to weren't allocated by this instance.
my question is if in this case the default copy and assignment operator would basically do a deep copy ?
The default copy constructor for a C++ type works by invoking the copy constructor on each field in the instance with the corresponding field in the object the copy is being created from. In your example it roughly translates to
Circle(const Circle& other) :
x(other.x),
y(other.y),
_neighobrs(other._neighbors) {
}
Whether or not the copy is deep is an implementation detail of each fields' copy constructor. In this case the copy constructor of vector<T> is a bit of a mix. It will deeply copy the underlying storage such that each vector<T> has it's own independent array. However it will copy the elements using the copy constructor. In this case it's a pointer type hence they are copied in a shallow fashion
Default generated copy constructors and assignment operators do shallow copies.
If you're sharing pointers between instances of these class, I suggest that instead of having a vector of pointers, you have a vector of smart pointers.
_aand__ais that the second is reserved for any use, so you should never see it in user code (and can legitimately complain about it if you do). The first is only reserved as a name in the global namespace, so it's purely a matter of taste whether to use it in other contexts.