在C++中，分配器（allocator）是用于管理內存的模板類，它允許用戶自定義內存分配和釋放的行為。C++標準庫提供了一些預定義的分配器，如std::allocator，但用戶也可以創建自定義分配器以滿足特定需求。

要設置自定義分配策略，您需要定義一個分配器類，并重寫其allocate和deallocate成員函數。以下是一個簡單的示例，展示了如何創建一個自定義分配器，該分配器使用固定大小的內存塊：

#include <iostream>
#include <memory>

template <typename T>
class FixedSizeAllocator {
public:
    using value_type = T;
    using pointer = T*;
    using const_pointer = const T*;
    using reference = T&;
    using const_reference = const T&;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;

    FixedSizeAllocator() noexcept {}

    template <typename U>
    FixedSizeAllocator(const FixedSizeAllocator<U>&) noexcept {}

    pointer allocate(size_type n, const void* hint = 0) {
        if (n > max_size()) {
            throw std::bad_alloc();
        }

        pointer result = static_cast<pointer>(::operator new(n * sizeof(T)));
        if (!result) {
            throw std::bad_alloc();
        }

        return result;
    }

    void deallocate(pointer p, size_type n) noexcept {
        ::operator delete(p);
    }

    size_type max_size() const noexcept {
        return std::numeric_limits<size_type>::max() / sizeof(T);
    }

    template <typename U, typename... Args>
    void construct(U* p, Args&&... args) {
        new (p) U(std::forward<Args>(args)...);
    }

    template <typename U>
    void destroy(U* p) {
        p->~U();
    }
};

int main() {
    FixedSizeAllocator<int> allocator;
    int* arr = allocator.allocate(10);

    for (int i = 0; i < 10; ++i) {
        allocator.construct(arr + i, i);
    }

    for (int i = 0; i < 10; ++i) {
        std::cout << *(arr + i) << ' ';
    }

    for (int i = 0; i < 10; ++i) {
        allocator.destroy(arr + i);
    }

    allocator.deallocate(arr, 10);

    return 0;
}

在這個示例中，FixedSizeAllocator類重寫了allocate和deallocate成員函數，以便使用固定大小的內存塊分配和釋放內存。allocate函數接受一個大小參數n，并嘗試分配足夠的連續內存來存儲n個T類型的對象。如果分配失敗，它將拋出一個std::bad_alloc異常。

請注意，這個示例僅用于演示目的，實際應用中可能需要根據具體需求調整分配策略。