C++：复制构造函数后两个对象的值都会更改

问：

我编写了一个简单的 c++ 代码来理解复制构造函数/运算符重载的概念。代码片段如下所示。

在代码中，我正在创建一个对象，然后创建一个新对象并分配 .接下来，我调用重载来更改 和 的值。vec v2v4vec v2operator[]v4[0]v4[1]

我的问题是，在分配这些值后，的值也发生了变化。 我不太确定这是怎么发生的。希望有人能帮我解决这个问题。vec v2

class vec {
private:
    // Variable to store the number of elements contained in this vec.
    size_t elements;
    // Pointer to store the address of the dynamically allocated memory.
    double* data;

public:

    vec(size_t size) : elements{ size }, data{ new double[size] } {std::cout << "First constructor" << "\n"; };
    
    vec(size_t size, double ival) : elements{ size }, data{ new double[size] } {
        std::cout << "Second constructor" << std::endl;
        for (int i = 0; i < elements; i++) {
            data[i] = ival;
        }
    }
    
    vec(std::initializer_list<double> iList): vec(static_cast<size_t>(iList.size())) {
        std::cout << "Third constructor" << std::endl;
        auto count{ 0 };

        for (auto element: iList) {
            data[count] = element;
            count++;
        }
    
    }
    
    /// Copy constructor that creates a copy of the vec variable 'v'.
    vec(const vec& v) : elements{ v.elements }, data{ new double[v.elements] }{
        std::cout << "Copy constructor " << "\n";
        std::memcpy(&data, &(v.data), v.elements);
    }
    
    /// Copy assignment operator. Creates a copy of vec variable 'v'.
    vec& operator=(const vec& v) {
        std::cout << "Copy assignment " << "\n";
        if (this != &v) {
            const auto new_data{ new double[v.elements] };
            delete[] data;

            data = new_data;
            elements = v.elements;
            std::memcpy(&data, &(v.data), v.elements);
        }
        return *this;
    }
    
    double& operator[](size_t idx){
        return this->data[idx];
    }
    
    friend std::ostream& operator<<(std::ostream& os, const vec& v) {

        for (int i = 0; i < v.elements; i++) {
            os << v.data[i] << "\n";
        }

        return os;
    }
};

int main(void) {

vec v2 = {4, 5, 6};
vec v4 = v2

v4[0] = 11;                                          // call to operator[]
v4[1] = 12;                                          // call to operator[]

return 0;
}