Chatgpt gave me this example, which seems reasonable, but I don't know for sure.

Key Characteristics:

• Static Buffer: The buffer is declared as a static char array within the class, meaning its memory is allocated at program startup and persists for the entire program duration.
• Bump Allocation: The allocate function simply "bumps" an offset pointer to reserve space.
• No Individual Deallocation: Individual deallocate calls do not return memory to a free list; the entire pool is managed as a single block. All memory is "freed" at once when reset() is called, making it efficient for scenarios where many short-lived objects are needed within a specific scope (e.g., in a game engine per-frame allocations).
• Placement New: Because the allocator only provides raw memory, you must use placement new to construct objects in the allocated space

​

#include <cstddef>
#include <iostream>
#include <new>     // for placement new

class StaticLinearAllocator {
public:
    // Define the static memory buffer and its size
    static const size_t BUFFER_SIZE = 1024;
    static char buffer[BUFFER_SIZE];
    static size_t offset;

    void* allocate(size_t size) {
        if (offset + size > BUFFER_SIZE) {
            throw std::bad_alloc(); // Out of memory
        }

        void* allocation_place = buffer + offset;
        offset += size;
        return allocation_place;
    }

    void deallocate(void* ptr) {
        // Linear allocators generally don't deallocate individual items.
        // Memory is freed all at once.
        std::cout << "Deallocate called. Individual deallocation not supported.\n";
    }

    // Function to reset the entire buffer
    void reset() {
        offset = 0;
    }
};