An instance variable, which is a pointer to an array item, doesn't point to that item anymore after the object is passed to a class constructor

I have a minimal example here where I can reproduce the issue I'm facing.

#include <iostream>

class A {
public:
	long arr[3] = {0x10, 0x20, 0x30};
	long *item1 = &arr[0], *item2 = &arr[1], *item3 = &arr[2];

	A();
};

class B {
public:
	A a;

	B(A);
};

A::A() {}

B::B(A param) {
	a = param;
}

int main() {
	A a = A();
	B b = B(a);

	std::cout << &a.arr[0] << std::endl;
	std::cout << a.item1 << std::endl;

	std::cout << &b.a.arr[0] << std::endl;
	std::cout << b.a.item1 << std::endl;
}

If I pass a into the constructor for class B, then a's instance variables, which were set to point to the ith element of arr, no longer point to that. I do not want to pass in a reference of a into the constructor for B, I want to pass in a copy as I am currently doing.

What I expect to happen:

&a.arr[0] and a.item1 have the same value, and &b.a.arr[0] and b.a.item1 have the same value.

What actually happens:

&a.arr[0], a.item1, and b.a.item1 have the same value, while &b.a.arr[0] has a different value.

If I set item1 to be the memory address of arr[0], then how come item1 and arr[0] don't point to the same thing after passing it in to class B? I would expect &a.arr[0] to have a different value than &b.a.arr[0] of course, but I would also expect &a.arr[0] and a.item1 to have the same value, and &b.a.arr[0] and b.a.item1 to have the same value. Why is this not happening, and how do I make that happen? Again, I don't want to pass a reference to a into the constructor for B, because I would like to modify b.a and return the modified version without affecting the original a.

When you copy an instance of A, you also copy all the pointers. So the pointers in the new instance all point at the instance copied from, not the the instance containing the pointers.

If you want to pointers in each instance of A to always point at that instance of A, you need to write an explicit copy constructor (and copy assignment, if you want that), that does that. You may also want a move constructor (and assignment) for different situations, but in this case (as your array elements are just longs) it's not particularly useful.

A::A(const A &a) {
    std::copy(std::begin(a.arr), std::end(a.arr), std::begin(arr));
    item1 = &arr[0];
    item2 = &arr[1];
    item3 = &arr[2];
}

A &A::operator=(const A &a) {
    std::copy(std::begin(a.arr), std::end(a.arr), std::begin(arr));
    return *this;
}