如何初始化本身具有非平凡构造函数的对象的stl向量

Question

假设我有以下类：

class MyInteger {
private:
  int n_;
public:
  MyInteger(int n) : n_(n) {};
  // MORE STUFF
};

假设这个类没有默认的平凡构造函数MyInteger()。出于某种原因，我必须始终提供一个int来初始化它。然后假设在我的代码中的某个地方我需要一个vector<MyInteger>。如何初始化此vector<>中的每个MyInteger组件？

我有两种情况（可能解决方案是一样的，但无论如何我都会说明它们），一个函数中的正常变量：

int main(){
    vector<MyInteger> foo(10);  //how do I initialize each 
                                //MyInteger field of this vector? 
    doStuff(foo);
}

作为一类数据：

class MyFunClass {
private:
   vector<MyInteger> myVector;
public:
   MyFunClass(int size, int myIntegerValue) : myVector(size) {}; 
   // what do I put here if I need the 
   // initialization to call MyInteger(myIntegerValue) for all 
   // components of myVector?
};

是否可以只在初始化列表中完成，或者我必须在MyFunClass（int，int）构造函数中手动编写初始化？

这看起来很基本，但不知怎么的，我在书中错过了，在网上找不到。

Answer 1

实现这一目标有很多方法。以下是其中的一些（没有特定的出现顺序）。

使用vector(size_type n, const T& t)构造函数。它用t的n拷贝初始化向量。例如：

#include <vector>
struct MyInt
{
    int value;
    MyInt (int value) : value (value) {}
};
struct MyStuff
{
    std::vector<MyInt> values;
    MyStuff () : values (10, MyInt (20))
    {
    }
};

将元素逐个推入矢量。当值应该不同时，这可能很有用。例如：

#include <vector>
struct MyInt
{
    int value;
    MyInt (int value) : value (value) {}
};
struct MyStuff
{
    std::vector<MyInt> values;
    MyStuff () : values ()
    {
        values.reserve (10); // Reserve memory not to allocate it 10 times...
        for (int i = 0; i < 10; ++i)
        {
            values.push_back (MyInt (i));
        }
    }
};

另一个选项是构造函数初始化列表，如果C++0x是一个选项：

#include <vector>
struct MyInt
{
    int value;
    MyInt (int value) : value (value) {}
};
struct MyStuff
{
    std::vector<MyInt> values;
    MyStuff () : values ({ MyInt (1), MyInt (2), MyInt (3) /* ... */})
    {
    }
};

当然，还有一个选项可以提供默认构造函数和/或使用std::vector以外的东西。

希望能有所帮助。

Answer 2

如果向量的元素在默认情况下是不可构造的，那么您就无法对向量执行某些操作。你不能写这个（示例1）：

vector<MyInteger> foo(10);

然而，您可以这样写（示例2）：

vector<MyInteger> foo(10, MyInteger(37));

（这只需要一个复制构造函数。）第二个参数是向量元素的初始值设定项。

在你的情况下，你也可以写：

vector<MyInteger> foo(10, 37);

因为MyInteger有一个以"int"为参数的非显式构造函数。因此，编译器将把37强制转换为MyInteger（37），并给出与示例2相同的结果。

您可能想研究一下std:：vector的文档。

Answer 3

vector<MyInteger> foo(10, MyInteger(MY_INT_VALUE));
MyFunClass(int size, int myIntegerValue) : myVector(size, MyInteger(myIntegerValue)) {}; 

Answer 4

除了所有答案都很好地回答了这个问题之外，如果你的类MyInteger不可复制构造，你可以使用这个技巧：你可以创建vector< shared_ptr< MyInteger > > ，而不是创建vector< MyInteger>

初始化列表可以在不引用底层对象的情况下使用。

#include <string>
#include <vector>
using namespace std;

class Test
{
   public:
   struct NumStr
   {
      int num;
      string str;
   };
   Test(vector<int> v1,vector<NumStr> v2) : _v1(v1),_v2(v2) {}
   vector<int> _v1;
   vector<NumStr> _v2;
};
int main()
{
   Test t={ {1,2,3}, {{1,"one"}, {2,"two"}, {3,"three"}} };
   cout << t._v1[1] << " " << t._v2[1].num << " " << t._v2[1].str << endl;
   return 0;
}

输出：2 2两个