怎样在C++中减少动态内存分配？

// 使用栈分配
void processData() {
    std::vector<int> tempVector(100);
    // 使用tempVector
}

// 使用动态分配
void processData() {
    std::vector<int>* tempVector = new std::vector<int>(100);
    // 使用tempVector
    delete tempVector;
}

// 使用智能指针
void processData() {
    std::unique_ptr<std::vector<int>> tempVector = std::make_unique<std::vector<int>>(100);
    // 使用tempVector
}

// 使用std::array
void processData() {
    std::array<int, 100> tempArray;
    // 使用tempArray
}

// 使用reserve预分配内存
void processData() {
    std::vector<int> tempVector;
    tempVector.reserve(10000);
    // 添加元素到tempVector
}

// 对象池示例
class ObjectPool {
private:
    std::vector<std::unique_ptr<MyObject>> pool;
    std::queue<std::unique_ptr<MyObject>> available;

public:
    ObjectPool(size_t size) {
        for (size_t i = 0; i < size; ++i) {
            pool.push_back(std::make_unique<MyObject>());
            available.push(std::move(pool.back()));
        }
    }

    std::unique_ptr<MyObject> acquire() {
        if (available.empty()) {
            throw std::runtime_error("Object pool is exhausted");
        }
        auto obj = std::move(available.front());
        available.pop();
        return obj;
    }

    void release(std::unique_ptr<MyObject> obj) {
        available.push(std::move(obj));
    }
};

// 自定义内存分配器示例
template <typename T>
class MyAllocator {
public:
    typedef T value_type;

    T* allocate(std::size_t n) {
        return static_cast<T*>(::operator new(n * sizeof(T)));
    }

    void deallocate(T* p, std::size_t n) {
        ::operator delete(p);
    }
};

// 使用自定义分配器
std::vector<int, MyAllocator<int>> vec;