Does the swapping an array of object around affects the pointers that pointing at it

Question

When swapping or moving an array of objects, what happens if lets say there were pointers pointing to random objects in the array. Does the pointer follow the objects element as they move or not? If they don't, is there a way to make them do so?

Answer 1

Objects don't move. The value held in an object can be moved (or swapped or copied) into a different object.

Pointers point to objects. If the value of those objects is changed, the pointer points to the changed value. If the object's lifetime ends, the pointer dangles.

Answer 2

When swapping or moving an array of objects , what happens if lets say there were pointers pointing to randomn objects in the array. Does the pointer follow the objects element as they move or not?

The pointer will be pointing to the same memory address as before. If you change the values in the array, that has no effect on the pointer.

If they don't, is there a way to make them do so?

Yes there is a way, you just have to make them point to wherever you want them to point to.

Example:

int array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};


int *ptr = &array[5]; // pointing to array[5]
printf("%d\n", *ptr); // prints 6

array[5] = 20;        // changing the value if array[5]
printf("%d\n", *ptr); // still pointing to array[5], prints 20

ptr = &array[2];      // now pointing to array[2]
printf("%d\n", *ptr); // prints 3

This, of course, will have to be applied to the swap method you speak of, of which you show no code and I therefore can't make an example out of.

Answer 3

There are ways to get a pointer to follow an object as it is moved about in an array. The simplest method is to simply modify the pointer as the object is moved within the array.

T arr[5];
T* ptr = &arr[3]; //point to the third element
std::swap(arr[1], arr[3]); //swap array element 1 with 3
ptr = &arr[1]; //update the pointer to point to element 1

What I think you are asking for is to move/swap the object without modifying the pointer to point to the objects new location. The simplest way, and the one that you see the most, is to have an array of pointers to objects allocated on the heap (here achieved using std::shared_ptr).

std::shared_ptr<T> arr[5]; //array of 5 shared_ptr<T>
arr[0] = new T();
arr[1] = new T();
arr[2] = new T();
arr[3] = new T();
arr[4] = new T();
T* ptr = &*arr[3]; //point to the third element
std::swap(arr[1], arr[3]); //swap array element 1 with 3
//no need to update the pointer

This is because shared_ptr allocates T on the heap (hear shown with new operator), so swapping arr[1] and arr[3] means that ptr still points to the same T. NOTE code not compiled or tested.

NOTE this counts for any modifiable contiguous or non contiguous data store such as std::vector<T> instead of an array, for example.