我看到的一个主要问题是你的ownVector类根本不遵循Rule of Three**：
如果一个类需要一个用户定义的析构函数、一个用户定义的复制构造函数或一个用户定义的复制赋值运算符，那么几乎可以肯定它需要所有这三个。

• 析构函数被注解掉，从而导致内存泄漏。
• 您根本没有实现复制构造函数或复制赋值运算符。默认的编译器生成的实现不足以满足该类的需要。它将创建数组指针的 * 浅 * 副本，从而允许多个ownVector对象共享一个数组。你需要数组的 deep 拷贝。ownVector的每个示例都需要拥有数组。

在C++11和更高版本中，三的规则变成了五的规则：
由于用户定义的（或= default或= delete声明的）析构函数、复制构造函数或复制赋值运算符的存在阻止了移动构造函数和移动赋值运算符的隐式定义，因此需要使用移动语义的任何类都必须声明所有五个特殊成员函数

• 您也没有实现移动构造函数或移动赋值运算符。

您的ownVector类还存在一些其他问题：

• push()没有delete[]处理旧数组，导致内存泄漏。
• push()应该只将size数量的元素复制到temp数组中，而不是capacity数量的元素。
• clear()在delete[]后不会将arr重置为空，以防new[]随后抛出。实际上，根本不需要clear()到delete[]现有阵列。它应该简单地将size重置为0，但保持现有capacity完整。但是，它至少应该将现有的数组元素重置为默认状态，以允许任何非平凡类型释放它们可能正在管理的资源。

那么，试试这个：

#pragma once
#include <iostream>
using namespace std;

template <typename T>
class ownVector {
    T* arr;
    int capacity;
    int size;

public:
    ownVector() {
        arr = new T[1];
        capacity = 1;
        size = 0;
    }

    ownVector(const ownVector& src) {
        arr = new T[src.capacity];
        capacity = src.capacity;
        size = src.size;
        for (int i = 0; i < size; ++i) {
            arr[i] = src.arr[i];
        }
        // or: std::copy_n(src.arr, src.size, arr);
    }

    ownVector(ownVector&& src) {
        arr = nullptr;
        capacity = 0;
        size = 0;
        src.swap(*this);
    }

    ~ownVector() {
        delete[] arr;
    }

    ownVector& operator=(ownVector rhs) {
        rhs.swap(*this);
        return *this;
    }
    
    void swap(ownVector& other) {
        T* ptr = arr;
        arr = other.arr;
        other.arr = ptr;
        // or: std::swap(arr, other.arr);

        int cap = capacity;
        capacity = other.capacity;
        other.capacity = cap;
        // or: std::swap(capacity, other.capacity);
        
        int sz = size;
        size = other.size;
        other.size = sz;
        // or: std::swap(size, other.size);
    }

    void push(const T& data) {
        if (size == capacity) {
            T* temp = new T[capacity + 2];
            for (int i = 0; i < size; ++i) {
                temp[i] = arr[i];
            }
            // or: std::copy_n(arr, size, temp);
            delete[] arr;
            arr = temp;
            capacity += 2;
        }
        arr[size] = data;
        ++size;
    }

    T& get(int index) {
        return arr[index];
    }

    T get(int index) const { // or: const T&
        return arr[index];
    }

    void set(int index, const T& value) {
        arr[index] = value;
    }

    T* begin() {
        return arr;
    }

    const T* begin() const {
        return arr;
    }

    T* end() {
        return arr + size;
    }

    const T* end() const {
        return arr + size;
    }

    int getSize() const {
        return size;
    }

    int getCapacity() const {
        return capacity;
    }

    void clear() {
        delete[] arr;
        arr = nullptr;
        capacity = 0;
        size = 0;
        arr = new T[1];
        capacity = 1;

        /* or:
        for(int i = 0; i < size; ++i) {
            arr[i] = T();
        }
        or:
        std::fill_n(arr, size, T());

        size = 0;
        */
    }
};