pushback() 函数

`pushback()` 函数是一个向容器的末尾添加元素的函数。在 C++ 中，它通常被用于向 vector、deque、list 等容器中添加元素。它的作用是将一个元素添加到容器的最后一个位置，使得容器的大小增加 1。例如，以下代码将向一个 vector 中添加一个整数元素：

#include <vector>

int main() {
    std::vector<int> v;
    v.push_back(1);  // 添加元素 1 到 vector 中
    return 0;
}

在这个例子中，`push_back()` 函数被调用，将整数值 1 添加到 vector 中。由于 vector 最初是空的，因此添加元素后，vector 的大小将变为 1。

相关问题

rapidjson 合成{"s":["lie","swh","bgss","swi","fa","cc"],"se":["me","sch","briess","sh1","fe","ct"]} ，PushBack函数第一个参数是CString

如果你希望使用RapidJSON将一个CString数组合成为JSON字符串 `{"s":["lie","swh","bgss","swi","fa","cc"],"se":["me","sch","briess","sh1","fe","ct"]}`，你可以按照以下步骤进行操作：

#include <iostream>
#include "rapidjson/document.h"
#include "rapidjson/writer.h"
#include "rapidjson/stringbuffer.h"

using namespace rapidjson;

int main() {
    // 创建一个空的Document对象
    Document document;
    document.SetObject();

    // 创建并设置CString数组s
    Value s(kArrayType);
    s.PushBack("lie", document.GetAllocator());
    s.PushBack("swh", document.GetAllocator());
    s.PushBack("bgss", document.GetAllocator());
    s.PushBack("swi", document.GetAllocator());
    s.PushBack("fa", document.GetAllocator());
    s.PushBack("cc", document.GetAllocator());

    // 创建并设置CString数组se
    Value se(kArrayType);
    se.PushBack("me", document.GetAllocator());
    se.PushBack("sch", document.GetAllocator());
    se.PushBack("briess", document.GetAllocator());
    se.PushBack("sh1", document.GetAllocator());
    se.PushBack("fe", document.GetAllocator());
    se.PushBack("ct", document.GetAllocator());

    // 将数组s和se添加到document中
    document.AddMember("s", s, document.GetAllocator());
    document.AddMember("se", se, document.GetAllocator());

    // 创建一个StringBuffer来存储JSON字符串
    StringBuffer buffer;
    Writer<StringBuffer> writer(buffer);
    document.Accept(writer);

    // 将StringBuffer转换为std::string并输出
    std::string jsonStr = buffer.GetString();
    std::cout << jsonStr << std::endl;

    return 0;
}

在上面的代码中，我们首先创建一个空的`Document`对象。然后，我们创建一个数组`s`并添加了一些CString元素。接下来，我们创建另一个数组`se`并添加了一些CString元素。最后，我们将这两个数组作为成员添加到`document`中。然后，我们使用`StringBuffer`和`Writer`将`document`转换为JSON字符串，并将其输出。

运行上述代码，你将得到输出的JSON字符串：

{"s":["lie","swh","bgss","swi","fa","cc"],"se":["me","sch","briess","sh1","fe","ct"]}

希望这个示例对你有帮助！如果有任何疑问，请随时提问。

请设计实现一个容器类模板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`操作，期望抛出异常并捕获。