请设计实现一个容器类模板CXMUVector，该类模板包含： 容量(capacity), 元素个数（size）和指向数据存储位置的指针(T* pdata，其中T为模板参数)。向量的数据存储在动态分配的数组中，通过pdata指向该数组，每个数组元素为T类型。CXMUVector还包含函数成员： （1）构造函数XMUVector(int c = 100)和析构函数，完成，完成存储空间的分配和回收。 （2）拷贝构造函数，完成深度复制； （3）重载运算符[]，实现对容器中元素的随机访问； （4）重载运算符号=，实现容器对象的深度赋值； （5）设计PushBack函数，在向量末尾插入元素，存储空间不足时可自动翻倍增长； （6）设计PopBack函数，弹出向量末尾的元素作为函数的返回值，当向量为空是执行此操作，抛出字符串异常“Pop On Empty Vector!”。 （7）在主函数函数中编程测试代码，实现异常信息的捕捉。 请按要求完成CXMUVector类模板的设计。

下面是CXMUVector类模板的设计实现：

#include <iostream>
#include <stdexcept>

template <typename T>
class CXMUVector {
public:
    // 构造函数
    CXMUVector(int c = 100) : capacity(c), size(0) {
        pdata = new T[capacity];
    }

    // 拷贝构造函数
    CXMUVector(const CXMUVector& other) : capacity(other.capacity), size(other.size) {
        pdata = new T[capacity];
        for (int i = 0; i < size; i++) {
            pdata[i] = other.pdata[i];
        }
    }

    // 析构函数
    ~CXMUVector() {
        delete[] pdata;
    }

    // 重载运算符[]
    T& operator[](int index) {
        if (index >= size) {
            throw std::out_of_range("Index out of range!");
        }
        return pdata[index];
    }

    // 重载运算符=
    CXMUVector& operator=(const CXMUVector& other) {
        if (this != &other) {
            delete[] pdata;
            capacity = other.capacity;
            size = other.size;
            pdata = new T[capacity];
            for (int i = 0; i < size; i++) {
                pdata[i] = other.pdata[i];
            }
        }
        return *this;
    }

    // PushBack函数
    void PushBack(const T& element) {
        if (size >= capacity) {
            int newCapacity = capacity * 2;
            T* newData = new T[newCapacity];
            for (int i = 0; i < size; i++) {
                newData[i] = pdata[i];
            }
            delete[] pdata;
            pdata = newData;
            capacity = newCapacity;
        }
        pdata[size++] = element;
    }

    // PopBack函数
    T PopBack() {
        if (size == 0) {
            throw std::string("Pop On Empty Vector!");
        }
        return pdata[--size];
    }

private:
    int capacity; // 容量
    int size; // 元素个数
    T* pdata; // 数据存储位置的指针
};


int main() {
    try {
        CXMUVector<int> myVector(5);
        myVector.PushBack(1);
        myVector.PushBack(2);
        myVector.PushBack(3);

        std::cout << "Vector elements: ";
        for (int i = 0; i < myVector.size; i++) {
            std::cout << myVector[i] << " ";
        }
        std::cout << std::endl;

        int poppedElement = myVector.PopBack();
        std::cout << "Popped element: " << poppedElement << std::endl;

        std::cout << "Vector elements after popping: ";
        for (int i = 0; i < myVector.size; i++) {
            std::cout << myVector[i] << " ";
        }
        std::cout << std::endl;

        // 测试异常捕捉
        int poppedElement2 = myVector.PopBack(); // Pop the last element
        int poppedElement3 = myVector.PopBack(); // Pop on empty vector, throws exception

    } catch (const std::string& exception) {
        std::cout << "Exception: " << exception << std::endl;
    }

    return 0;
}

这里我们使用模板类`CXMUVector`来实现一个动态数组容器。其中，`capacity`表示容器的容量，`size`表示容器中的元素个数，`pdata`是指向动态数组存储位置的指针。在构造函数中，我们进行了存储空间的分配，并在析构函数中进行回收。

为了实现深度复制，我们重载了拷贝构造函数和赋值运算符。其中，拷贝构造函数会创建一个新的动态数组，并将原数组中的元素复制到新数组中。赋值运算符会首先删除原数组，然后创建一个新的动态数组，并将赋值对象中的元素复制到新数组中。

通过重载运算符`[]`，我们可以实现对容器中元素的随机访问。如果索引超出容器大小的范围，将抛出`std::out_of_range`异常。

通过重载运算符`=`, 我们可以实现容器对象的深度赋值。在赋值之前，我们会首先删除原数组，然后创建一个新的动态数组，并将赋值对象中的元素复制到新数组中。

`PushBack`函数用于在向量末尾插入元素。如果存储空间不足，我们会将容量翻倍，并将原有元素复制到新的存储空间中。

`PopBack`函数用于弹出向量末尾的元素，并返回该元素的值。如果向量为空，则抛出自定义异常字符串`"Pop On Empty Vector!"`。

在主函数中，我们进行了一些测试。首先，我们创建一个`CXMUVector`对象，并使用`PushBack`函数插入一些元素。然后，我们使用重载运算符`[]`随机访问元素，并使用`PopBack`函数弹出末尾的元素。最后，我们测试了异常捕捉，进行了一次在空向量上的`PopBack`操作，期望抛出异常并捕获。