C++ 是否可以创建std:：vector<；标准：：唯一性\u ptr<；酒吧>&燃气轮机；使用填充构造函数？

我有一个Foo类，其成员变量的类型为

std:：vector

，我想将其填入该类构造函数的初始化列表中。这可能吗

我希望使用向量的填充构造函数是可能的，类似这样的东西

Foo::Foo(int n):
    vector<unique_ptr<Bar>> (n, unique_ptr<Bar> (new Bar))
{}

Foo:：Foo（int n）：
向量（n，唯一性_ptr（新条））
{}

但我认为这需要复制

std:：unique_ptr

的构造函数，它被删除（应该是这样的）（

unique_ptr（const unique_ptr&）=delete

）

---

有更好的方法吗？

因为它不可复制，请移动它

具有硬编码对象的解决方案：

#include <memory>
#include <vector>
#include <iterator>
class Bar{};
class Foo{
    public:
    Foo():bars(get_bars()) {}
    std::vector<std::unique_ptr<Bar>> bars;

    private:
    std::vector<std::unique_ptr<Bar>> get_bars(){
        std::unique_ptr<Bar> inilizer_list_temp[]={std::make_unique<Bar>(),std::make_unique<Bar>(),std::make_unique<Bar>()};
        return  std::vector<std::unique_ptr<Bar>>{std::make_move_iterator(std::begin(inilizer_list_temp)),std::make_move_iterator(std::end(inilizer_list_temp))};
    }
};
int main()
{
    Foo foo;
}

#include <memory>
#include <vector>
#include <iterator>
#include <iostream>
class Bar{
    public:
    int a=5;
    };
class Foo{
    public:
    Foo():bars(get_bars(10)) {}
    std::vector<std::unique_ptr<Bar>> bars;

    private:
    std::vector<std::unique_ptr<Bar>> get_bars(int n){
        std::vector<std::unique_ptr<Bar>> inilizer_list_temp;
        inilizer_list_temp.reserve(n);
        for(size_t i=0;i<n;++i){
            inilizer_list_temp.emplace_back(std::make_unique<Bar>());
        }
        return inilizer_list_temp;
    }
};
int main()
{
 Foo foo;
 for(auto const& item:foo.bars){
     std::cout << item->a;
 }
}

#包括
#包括
#包括
类条{}；
福班{
公众：
Foo（）：bars（get_bars（））{}
std：：矢量条；
私人：
std:：向量获取_条（）{
std:：unique_ptr inilizer_list_temp[]={std:：make_unique（），std:：make_unique（），std:：make_unique（）；
返回std：：vector{std：：make_move_iterator（std：：begin（inilizer_list_temp）），std：：make_move_iterator（std：：end（inilizer_list_temp））；
}
};
int main（）
{
富富,；
}

具有动态对象数的解决方案：

#include <memory>
#include <vector>
#include <iterator>
class Bar{};
class Foo{
    public:
    Foo():bars(get_bars()) {}
    std::vector<std::unique_ptr<Bar>> bars;

    private:
    std::vector<std::unique_ptr<Bar>> get_bars(){
        std::unique_ptr<Bar> inilizer_list_temp[]={std::make_unique<Bar>(),std::make_unique<Bar>(),std::make_unique<Bar>()};
        return  std::vector<std::unique_ptr<Bar>>{std::make_move_iterator(std::begin(inilizer_list_temp)),std::make_move_iterator(std::end(inilizer_list_temp))};
    }
};
int main()
{
    Foo foo;
}

#include <memory>
#include <vector>
#include <iterator>
#include <iostream>
class Bar{
    public:
    int a=5;
    };
class Foo{
    public:
    Foo():bars(get_bars(10)) {}
    std::vector<std::unique_ptr<Bar>> bars;

    private:
    std::vector<std::unique_ptr<Bar>> get_bars(int n){
        std::vector<std::unique_ptr<Bar>> inilizer_list_temp;
        inilizer_list_temp.reserve(n);
        for(size_t i=0;i<n;++i){
            inilizer_list_temp.emplace_back(std::make_unique<Bar>());
        }
        return inilizer_list_temp;
    }
};
int main()
{
 Foo foo;
 for(auto const& item:foo.bars){
     std::cout << item->a;
 }
}

#包括
#包括
#包括
#包括
分类栏{
公众：
INTA=5；
};
福班{
公众：
Foo（）：条（get_条（10））{}
std：：矢量条；
私人：
标准：：向量获取_条（int n）{
标准：：矢量输入列表温度；
点火器列表温度储备（n）；
对于（size_t i=0；i您的尝试是正确的，因为您只调用一次
new Bar
，而对于唯一指针向量，您需要为每个元素调用一次
new Bar
。我想您最好使用带有
emplace\u back
的循环。或者，您可以使用空的
unique\ptrs，然后循环调用
reset（新条）在C++中得到迭代的协同过程，我认为你最好的选择是循环。@ ZNEAK以前从未听说过“迭代的协同程序”。有一个链接到解释吗？我觉得问题的关键是避免循环，避免为每个实例键入UNIQUIGYONG指针创建逻辑。收集唯一指针并从中移动，这与手动填充向量基本相同…适用于2，2000年怎么样？这看起来很有希望。如果我没有C++14支持怎么办？（我认为std:：make_unique是C++14的一个功能）。