如何获得 std：：list 来为 C++ 中的 n 个对象分配内存？

您可以在构造函数中指定初始大小，并使用 .std::list<T> list_obj(n)

https://en.cppreference.com/w/cpp/container/list/list

还有.std::list::resize

我的目标是有一个 std：：list 来为我将放入其中的对象分配足够的内存

好吧，似乎很合理。您可以通过调用相应的构造函数来执行此操作，如@Gyross所述。

因此，当它扩展时，我不必处理潜在的异常

现在你的问题在这里不再有意义。如果你没有记忆，预分配肯定不会解决问题。此外，根据您的类型，当您调用复制（或在某些情况下）移动赋值函数时（使用 时），它仍可能引发异常。node = newvalue

或扩展所需的额外时间

具有讽刺意味的是，您如此频繁地使用和关心性能，因为它是标准库中最慢的容器之一。如果你想要一个高性能的固定容器，我建议你编写/使用一个环形缓冲器。std::list

您可能需要考虑实现自定义分配器。

自定义分配器类的完整要求如下 https://en.cppreference.com/w/cpp/memory/allocator

下面的示例分配器始终在堆栈上分配元素，如果元素数超过静态定义的大小，则引发元素。num_itemsstd::bad_alloc()

如果您有很多元素，您可能希望远离堆栈 using 或类似，以避免溢出。newdelete

template<typename T, size_t num_items>
class MyAllocator
{
public:
    using value_type = T;
    using pointer = T*;
    using const_pointer = const T*;
    using void_pointer = std::nullptr_t;
    using const_void_pointer = const std::nullptr_t;
    using reference = T&;
    using const_reference = const T&;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;

    /* should copy assign the allocator when copy assigning container */
    using propagate_on_container_copy_assignment = std::true_type;

    /* should move assign the allocator when move assigning container */
    using propagate_on_container_move_assignment = std::true_type;

    /* should swap the allocator when swapping the container */
    using propagate_on_container_swap = std::true_type;

    /* two allocators does not always compare equal */
    using is_always_equal = std::false_type;

    MyAllocator() : m_index(0) {};
    ~MyAllocator() noexcept = default;

    template<typename U>
    struct rebind {
        using other = MyAllocator<U, num_items>;
    };

    [[nodiscard]] pointer allocate(size_type n) {
        if (m_index+n >= num_items)
            throw std::bad_alloc();

        pointer ret = &m_buffer[m_index];
        m_index += n;
        return ret;

    }

    void deallocate(pointer p, size_type n) {
        (void) p;
        (void) n;
        /* do nothing */
    }

    size_type max_size() {
        return num_items;
    }


    bool operator==(const MyAllocator& other) noexcept {
        /* storage allocated by one allocator cannot be freed by another */
        return false;
    }

    bool operator!=(const MyAllocator& other) noexcept {
        /* storage allocated by one allocator cannot be freed by another */
        return !(*this == other);
    }

private:
    value_type m_buffer[num_items];
    size_t m_index;
};

然后你可以使用

constexpr size_t always_allocate_this_amount_of_elements = 10;
std::list<int, MyAllocator<int, always_allocate_this_amount_of_elements>> list;