你如何得到一个 std::list 来为 C++ 中的 n 个对象分配内存？

如何解决你如何得到一个 std::list 来为 C++ 中的 n 个对象分配内存？

我的目标是让 std::list 为我将放入其中的对象分配足够的内存，这样我就不必在它扩展时处理潜在的异常，或者扩展所需的额外时间。

我的第一次尝试涉及从波表拼接：

std::list<T> list();
        auto listI = list.begin;
        typename std::list<T>::iterator waveStart = waveTable.begin();
        for(int i = 0; i < waveIndex; i++) {
            waveStart++;
        }
        typename std::list<T>::iterator waveEnd;
        int tCounter = nSamples;
        while(tCounter > 0) {
            if(tCounter > (waveTable.size() - waveIndex)) {
                waveEnd = waveStart;
                for(int i = 0; i < (waveTable.size() - waveIndex); i++) {
                    waveEnd++;
                }
                tCounter = (tCounter - (waveTable.size() - waveIndex));
            } else {
                waveEnd = waveStart;
                for(int i = 0; i < tCounter; i++) {
                    waveEnd++;
                }
                tCounter = 0;
            }
            list.splice(listI,waveTable,waveStart,waveEnd);
            waveStart = waveTable.begin();
        }

        phase += (tp * frequency * (nSamples/sampleRate));
        while(phase > tp) {
            phase -= tp;
        }
        waveIndex = (phase / tp) * waveTable.size();

我打算复制这些值，但 splice 从 waveTable 中删除了这些值，所以我打算使用 insert。

问题是，插入会增加列表的大小，我无法找到一种方法来告诉列表需要多少内存来保存我想存储在其中的所有值。

解决方法

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

好吧，看起来很合理。您可以通过调用@Gyross 提到的适当构造函数来完成此操作。

所以当它扩展时我不必处理潜在的异常

现在这就是您的问题没有意义的地方。如果内存不足，预分配肯定不会解决问题。同样取决于您的类型，当您调用复制（或在某些情况下）移动赋值函数时（使用 node = newvalue 时），它仍然可能引发异常。

或扩展所需的额外时间

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

,

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

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

还有std::list::resize。

,

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

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

下面的示例分配器总是在堆栈上分配 num_items 元素，如果元素数量超过静态定义的大小，则抛出 std::bad_alloc()。

如果您有很多元素，您可能希望使用 new delete 或类似方法移出堆栈以避免溢出。

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;