如何生成具有唯一值的矢量

Question

我有这个例子来生成唯一的对象到一个向量:

#include <iostream>
#include <vector>
#include <algorithm>
int v=0;
struct A
{
    A() : refValue( v++)
    { std::cout<<"constructor refValue="<<refValue<<std::endl; }
    A( const A &r ) : refValue(r.refValue)
    { std::cout<<"copy constructor refValue="<<refValue<<std::endl; }
    A& operator=( const A &r )
    {
        refValue = r.refValue;
        std::cout<<"operator= refValue="<<refValue<<std::endl;
        return *this;
    }
    ~A() { std::cout<<"destructor refValue="<<refValue<<std::endl; }
    int refValue;
};
A GenerateUnique()
{
    A unique;
    return unique;
}
struct B
{
    B( const int n) : v()
    {
        std::generate_n( std::back_inserter( v ), n, &GenerateUnique );
    }
    std::vector< A > v;
};
int main()
{
    B b(3);
}

如果我把main改成这样:

struct B
{
    B( const int n) : v(n)
    {
    }
    std::vector< A > v;
};

则将一个A型对象复制到所有vector元素中。

是否有一种方法来创建一个向量与所有唯一的对象(如在第一个例子)?

说得更清楚一点:我有一个包含vector的类。这个向量必须包含所有唯一对象(不是一个对象的副本)。我想在初始化列表中初始化它(而不是在构造函数体中)

Answer 1

您的第一次尝试是有效的。

在当前标准c++ 03中

std::vector< A > as( n ); 

被显式定义为创建一个A对象并复制该n数次。

我相信在c++ 0x中，这被更改为创建n默认构造的A s(略有不同)。然后，您也许可以在A的构造函数中做一些事情，使每个实例唯一。

现在不行

Answer 2

它被复制是因为构造函数的签名如下:

​explicit vector( size_type count,
             const T& value = T(),
             const Allocator& alloc = Allocator());

很明显，你只需要传递一个默认构造的对象给这个构造函数，它就会复制它。

如果你想在初始化列表中进行初始化，显然，你只能使用某些对象的构造函数。我猜，您不会想要创建一个包装器类，只是为了在初始化列表中初始化vector，所以我们仅限于vector的构造函数。唯一合理的是

template <class InputIterator>
vector( InputIterator first, InputIterator last,
        const Allocator& alloc = Allocator() );

因此，可以创建一个迭代器来返回所需数量的默认构造对象。

我建议只在构造函数体中构造

Answer 3

如前所述，您可以在boost中使用make_function_input_iterator，如下所示:

#include <iostream>
#include <vector>
#include <algorithm>
#include <boost/iterator/function_input_iterator.hpp>
// A && GenerateUnique the same ...
struct B
{
    B( const int n) : v(boost::make_function_input_iterator(&GenerateUnique, 1), boost::make_function_input_iterator(&GenerateUnique, n))
    {
    }
    std::vector< A > v;
};
int main()
{
    B b(3);
}

但是请注意，当我测试代码时，我看到了比第一个解决方案更多的复制构造/operator=。除此之外，还创建了一个额外的对象(refvalue 3)(用于最后一个"停止"迭代器)。我不知道这个额外的行为是否可行，但是如果你真的需要的话，它可以在初始化列表中初始化vector。