template <typename T>
constexpr void destroy_at(T* location) {
    if constexpr (is_array_v<T>) {
	    for (auto& x : *location) {
            // 如果是个 array，那么要对所有位置执行 destroy
            std::destroy_at(std::addressof(x));
        }
	} else {
        location->~T();
    }
}

template <typename T, typename... Args>
constexpr auto construct_at(T* location, Args&&... args)
    noexcept(noexcept(::new(static_cast<void*>(nullptr)) T(std::declval<Args>()...)))
    -> decltype(::new(static_cast<void*>(nullptr)) T(std::declval<Args>()...)) {
    // 在 location 位置传入 args 构造一个对象
    return ::new(static_cast<void*>(location)) T(std::forward<Args>(args)...);
}

template <typename ForwardIterator>
constexpr void Destroy(ForwardIterator first, ForwardIterator last);

template <typename T>
constexpr void Destroy(T* pointer) {
    // 单个指针直接调用 destroy_at
    std::destroy_at(pointer);
}

template <bool>
struct Destroy_aux {
    template <typename ForwardIterator>
    static constexpr void destroy(ForwardIterator first, ForwardIterator last) {
        for (; first != last; ++first) {
            std::Destroy(std::addressof(*first));
        }
    }
};

template <>
struct Destroy_aux<true> {
    template <typename ForwardIterator>
    static void destroy(ForwardIterator, ForwardIterator) {
    }
};

template <typename ForwardIterator>
constexpr void Destroy(ForwardIterator first, ForwardIterator last) {
    using Value_type = typename std::iterator_traits<ForwardIterator>::value_typ;
    // 必须可以被析构
    static_assert(std::is_destructible_v<Value_type>, "value type is destructible");
    if (std::is_constant_evaluated()) {
        // 如果当前是 constexpr 语境，那么直接使用 constexpr 版本的函数，在编译期展开
        return Destroy_aux<false>::destroy(first, last);
    }
    // 如果非 constexpr 语境，因为调用函数会产生开销，只需要在非平凡析构时执行析构函数
    // __has_trivial_destructor 在用户有自定义的析构函数时返回 false
    std::Destroy_aux<__has_trivial_destructor(Value_type)>::destroy(first, last);
}

template <bool>
struct Destroy_n_aux {
    template <typename ForwardIterator, typename Size>
    static constexpr ForwardIterator destroy_n(ForwardIterator first, Size count) {
        for (; count > 0; (void)++first, --count) {
            std::Destroy(std::addressof(*first));
        }
        return first;
    }
};

template <>
struct Destroy_n_aux<true> {
    template <typename ForwardIterator, typename Size>
    static ForwardIterator destroy_n(ForwardIterator first, Size count) {
        // 将 first 迭代器直接移动到 count 处
        std::advance(first, count);
        return first;
    }
};


template <typename ForwardIterator, typename Size>
constexpr ForwardIterator Destroy_n(ForwardIterator first, Size count) {
    using Value_type = typename std::iterator_traits<ForwardIterator>::value_type;
    static_assert(std::is_destructible_v<Value_type>, "value type is destructible");
    if (std::is_constant_evaluated()) {
        return Destroy_n_aux<false>::destroy_n(first, count);
    }
    return std::Destroy_n_aux<__has_trivial_destructor(Value_type)>::destroy_n(first, count);
}

template <typename ForwardIterator>
constexpr void destroy(ForwardIterator first, ForwardIterator last) {
    std::Destroy(first, last);
}

template <typename ForwardIterator, typename Size>
constexpr ForwardIterator destroy_n(ForwardIterator first, Size count) {
    return std::Destroy_n(first, count);
}

template<typename T>
class new_allocator {
    ...
    
    [[no_discard]] T allocate(std::size_t n, const void* = static_cast<const void*>(nullptr)) {
	    static_assert(sizeof(T) != 0, "cannot allocate incomplete types");
        
        // 检查一下数量
	    if (__builtin_expect(n > std::size_t(__PTRDIFF_MAX__) / sizeof(T), false)) {
	        if (n > (std::size_t(-1) / sizeof(T))) {
                std::throw_bad_array_new_length();
            }
	        std::throw_bad_alloc();
	    }
	    return static_cast<T*>(::operator new(n * sizeof(T)));
    }
    
    void deallocate(T* p, std::size_t n) {
        ::operator delete(p, n * sizeof(T));
    }
    
    ...
};

template<typename T>
class allocator : public new_allocator<T> {
    ...
    
    constexpr T* allocate(std::size_t n) {
        if (std::is_constant_evaluated()) {
            // 看一下 n * sizeof(T) 是否会溢出
    	    if (__builtin_mul_overflow(n, sizeof(T), &n)) {
                std::throw_bad_array_new_length();
            }
    	    return static_cast<T*>(::operator new(n));
    	}
        return new_allocator<T>::allocate(n);
    }
    
    constexpr void deallocate(T* p, std::size_t n) {
    	if (std::is_constant_evaluated()) {
    	    ::operator delete(p);
    	    return;
    	}
    	new_allocator<T>::deallocate(p, n);
    }
    
    ...
};

void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
int munmap(void *addr, size_t length);

struct malloc_chunk {  
  INTERNAL_SIZE_T      prev_size;    // 如果前一个块空闲，那么这个值记录的是前一个块的大小，否则无意义
  INTERNAL_SIZE_T      size;         // 当前块的大小，在这个变量的某几位记录了 overhead 头信息
  
  // 下面两个变量只有当当前块空闲时才有用
  struct malloc_chunk* fd;           // 空闲块链表 next
  struct malloc_chunk* bk;           // 空闲块链表 prev
  
  // 下面两个变量只有当当前的块存在于 large bins 时才有用
  struct malloc_chunk* fd_nextsize;  // 指向下一个比当前空闲块大的第一个空闲块
  struct malloc_chunk* bk_nextsize;  // 指向前一个比当前空闲块大的第一个空闲块
};

#define PREV_INUSE     0x1  // 前一个块是否正在使用
#define IS_MMAPPED     0x2  // 是否由 mmap 分配
#define NON_MAIN_ARENA 0x4  // 是否非主线程使用的 arena