C++ 移动到唯一的\u ptr容器中

我想做一些与for unique_ptr上的代码片段非常相似的事情。下面是代码片段。它编译得很好

#include <iostream>
#include <list>
#include <vector>
#include <string>
#include <iterator>

int main()
{
    std::list<std::string> s{"one", "two", "three"};

    std::vector<std::string> v1(s.begin(), s.end()); // copy

    std::vector<std::string> v2(std::make_move_iterator(s.begin()),
                                std::make_move_iterator(s.end())); // move

    std::cout << "v1 now holds: ";
    for (auto str : v1)
            std::cout << "\"" << str << "\" ";
    std::cout << "\nv2 now holds: ";
    for (auto str : v2)
            std::cout << "\"" << str << "\" ";
    std::cout << "\noriginal list now holds: ";
    for (auto str : s)
            std::cout << "\"" << str << "\" ";
    std::cout << '\n';
}

#包括
#包括
#包括
#包括
#包括
int main（）
{
列表{“一”、“二”、“三”}；
std:：vector v1（s.begin（），s.end（））；//复制
std:：vector v2（std:：make_move_迭代器（s.begin（）），
std:：make_move_迭代器（s.end（））；//move
std:：cout是，如果您使用Herb Sutter建议的
make_unique
功能，您可以：

template<typename T, typename ...Args>
std::unique_ptr<T> make_unique( Args&& ...args )
{
    return std::unique_ptr<T> ( new T( std::forward<Args>(args)... ) );
}

int main()
{
    std::list<std::string> s{"one", "two", "three"};

    std::vector<std::unique_ptr<std::string>> v2;
    std::transform(begin(s), end(s), std::back_inserter(v2),
            &make_unique<std::string, std::string&>
    );
}

模板
std:：unique_ptr使_唯一（Args&&…Args）
{
返回std:：unique_ptr（新的T（std:：forward

不幸的是，我们无法使用类型推断，因此我们必须手动提供类型。
如果您使用Herb Sutter建议的
make_unique
功能，则可以：

template<typename T, typename ...Args>
std::unique_ptr<T> make_unique( Args&& ...args )
{
    return std::unique_ptr<T> ( new T( std::forward<Args>(args)... ) );
}

int main()
{
    std::list<std::string> s{"one", "two", "three"};

    std::vector<std::unique_ptr<std::string>> v2;
    std::transform(begin(s), end(s), std::back_inserter(v2),
            &make_unique<std::string, std::string&>
    );
}

模板
std:：unique_ptr使_唯一（Args&&…Args）
{
返回std:：unique_ptr（新的T（std:：forward

不幸的是，我们无法使用类型推断，因此我们必须手动提供类型。
如果您使用Herb Sutter建议的
make_unique
功能，则可以：

template<typename T, typename ...Args>
std::unique_ptr<T> make_unique( Args&& ...args )
{
    return std::unique_ptr<T> ( new T( std::forward<Args>(args)... ) );
}

int main()
{
    std::list<std::string> s{"one", "two", "three"};

    std::vector<std::unique_ptr<std::string>> v2;
    std::transform(begin(s), end(s), std::back_inserter(v2),
            &make_unique<std::string, std::string&>
    );
}

模板
std:：unique_ptr使_唯一（Args&&…Args）
{
返回std:：unique_ptr（新的T（std:：forward

不幸的是，我们无法使用类型推断，因此我们必须手动提供类型。
如果您使用Herb Sutter建议的
make_unique
功能，则可以：

template<typename T, typename ...Args>
std::unique_ptr<T> make_unique( Args&& ...args )
{
    return std::unique_ptr<T> ( new T( std::forward<Args>(args)... ) );
}

int main()
{
    std::list<std::string> s{"one", "two", "three"};

    std::vector<std::unique_ptr<std::string>> v2;
    std::transform(begin(s), end(s), std::back_inserter(v2),
            &make_unique<std::string, std::string&>
    );
}

模板
std:：unique_ptr使_唯一（Args&&…Args）
{
返回std:：unique_ptr（新的T（std:：forward

不幸的是，我们不能使用类型推断，所以我们必须手动提供类型。
OP想要移动，而不是复制-所以可以使用
[]（std:：string&s）{return make_unique（std:：move（s））；}
哦，他想要在一行中进行转换-所以将整个
std:：transform
调用合并成一行；）OP想要移动，而不是复制-所以可能用
[]（std:：string&s）{return make_unique（std:：move（s））}
哦，他想把它放在一行中-所以把整个
std:：transform
调用混合成一行；）OP想要移动，而不是复制-所以可能用
[]（std:：string&s）{return make_unique（std:：move（s））}
Oh，他想把它放在一行中-所以把整个
std:：transform
call合并成一个大行；）OP想移动，而不是复制-所以也许可以用
[]（std:：string&s）{return make_unique（std:：move（s））}
Oh，他想把它合并成一行-所以把整个
std:：transform
调用合并成一个大行；）