使用 std::vector 时如何将索引信息传递给元素构造函数？

Question

有什么方法可以将向量的索引传递给它的元素的构造函数？ 例如：

#include <iostream>
#include <vector>

class Foo {
 public:
  Foo(unsigned long index) {
    std::cout << index << std::endl;
  }
};

int main() {
  std::vector<Foo> foo;
  foo.resize(2); // any way to make this work?
}

此代码确实不起作用，因为编译器不知道如何构造Foo(unsigned long index)，但我可以做一些技巧（例如自定义分配器？）以使此代码实际工作？

Answer 1

您可以在 for 循环中添加元素并将索引作为参数传递给它们的 ctor，如下所示：

// Init your vector + optionally reserve space
std::vector<Foo> foo;
const unsigned elements_to_add = 5; // or whatever number
foo.reserve(foo.size() + elements_to_add);

// foo.size() will be passed as parameter to the ctor you defined
for (std::size_t i = 0; i < elements_to_add; i++) {
    foo.emplace_back(foo.size());
}

Answer 2

不，您需要使用 std::generate() 或 std::generate_n() 与 std::back_inserter() 结合使用。

Answer 3

您可以编写一个自定义的有状态分配器，该分配器将在构造对象时传递一个索引。

小例子：

template<class T>
class Allocator {
public:
    using value_type = T;

    T* allocate(std::size_t n) {
        return static_cast<T*>(::operator new(n * sizeof(T)));
    }

    void deallocate(T* p, std::size_t) noexcept {
        ::operator delete(p);
    }

    template<class... Args>
    void construct(T* p, Args&&... args) {
        ::new(static_cast<void*>(p)) T(counter_++, std::forward<Args>(args)...);
    }

    void destroy(T* p) noexcept {
        p->~U();
        --counter_;
    }

private:
    std::size_t counter_ = 0;
};

使用示例：

struct Foo {
    Foo(std::size_t index) {
        std::cout << index << ' ';
    }

    Foo(std::size_t index, const Foo& other) : Foo(other) {
        std::cout << index << ' ';
    }
};

std::vector<Foo, Allocator<Foo>> foos1;
foos1.resize(3);
std::cout << std::endl;

std::vector<Foo, Allocator<Foo>> foos2;
foos2.resize(4);

// Output: 
// 0 1 2 
// 0 1 2 3

Answer 4

我想有很多方法可以或多或少地得到你想要的。但迟早你可能会发现你不需要这个。

这是一个可能的解决方案：

#include <iostream>
#include <vector>

class Foo
{
    inline static unsigned long _static_index = 0;
    unsigned long _index;

public:
    Foo() : _index(_static_index) { ++_static_index; }

    auto index() const { return _index; }
    static void resetIndex() { _static_index = 0; }
};

int main()
{
    std::vector<Foo> foos;
    Foo::resetIndex();
    foos.resize(2);

    for (const auto& f : foos)
        std::cout << f.index() << std::endl;

    return 0;
}

因此，您只需增加一个静态计数器并将其分配给私有成员 _index。这显然有其局限性。例如，假设您在填写 Foos 的 vector 之前创建了 3 个 Foo 实例，那么 foos[0].index() 将返回 3 而不是 0。因此，在填写 foos 之前，您需要重置 @ 987654328@。