Question

在我的C ++应用程序中，我大量使用像vector这样的STL容器。有很多对push_back的调用，我一直关注不必要的构造和复制操作。

我的应用程序非常低级，我非常关心CPU和内存使用情况。我是否应该通过拨打push_back？

来取消对emplace_back的所有来电

我正在使用Visual Studio 2013。

Answer 1

我通过调用push_back替换了对emplace_back的所有来电，并注意到以下内容：

RAM使用量减少约20％（更新：这可能是由于其他影响）
CPU使用率不变
二进制文件略小（x64）
没有兼容性问题

根据这些经验，如果您的项目不需要与旧编译器向后兼容，我强烈建议您从push_back迁移到emplace_back。

Answer 2

这几乎总是规则。你不能依赖拷贝构造函数的副作用，所以它应该意味着明确地跳过它是正确的做法，但有一种情况。

std::vector<std::unique_ptr<A>> foo;
foo.emplace_back( new A );

如果在某个时候触发了抛出，就像向量调整大小时一样，就会以泄漏结束。所以emplace_back是不可能的。

如果A构造函数和您发送的参数是异常安全的，那么没有理由不使用emplace_back。

Answer 3

这个测试：

#include <type_traits>
#include <typeinfo>
#include <iostream>
#ifndef _MSC_VER
#   include <cxxabi.h>
#endif
#include <memory>
#include <string>
#include <cstdlib>
#include <vector>

template <typename T>
std::string
type_name()
{
    typedef typename std::remove_reference<T>::type TR;
    std::unique_ptr<char, void(*)(void*)> own
           (
#ifndef _MSC_VER
                abi::__cxa_demangle(typeid(TR).name(), nullptr,
                                           nullptr, nullptr),
#else
                nullptr,
#endif
                std::free
           );
    std::string r = own != nullptr ? own.get() : typeid(TR).name();
    if (std::is_const<TR>::value)
        r += " const";
    if (std::is_volatile<TR>::value)
        r += " volatile";
    if (std::is_lvalue_reference<T>::value)
        r += "&";
    else if (std::is_rvalue_reference<T>::value)
        r += "&&";
    return r;
}

template <int N>
struct member
{
    member()
    {
        std::cout << type_name<member>() << "()\n";
    }

    ~member()
    {
        std::cout << "~" << type_name<member>() << "()\n";
    }

    member(member const& x)
    {
        std::cout << type_name<member>()
                  << "(" << type_name<decltype(x)>() << ")\n";
    }

    member& operator=(member const& x)
    {
        std::cout << type_name<member>() << "::operator=("
                  << type_name<decltype(x)>() << ")\n";
        return *this;
    }

    member(member&& x)
    {
        std::cout << type_name<member>()
                  << "(" << type_name<decltype(x)>() << ")\n";
    }

    member& operator=(member&& x)
    {
        std::cout << type_name<member>() << "::operator=("
                  << type_name<decltype(x)>() << ")\n";
        return *this;
    }
};

int
main()
{
    std::vector<member<1>> v;
    v.reserve(10);
    member<1> m;
    std::cout << "\npush_back an lvalue\n";
    v.push_back(m);
    std::cout << "\nemplace_back an lvalue\n";
    v.emplace_back(m);
    std::cout << "\npush_back an xvalue\n";
    v.push_back(std::move(m));
    std::cout << "\nemplace_back an xvalue\n";
    v.emplace_back(std::move(m));
    std::cout << "\npush_back a prvalue\n";
    v.push_back(member<1>{});
    std::cout << "\nemplace_back an prvalue\n";
    v.emplace_back(member<1>{});
    std::cout << "\nDone\n";
}

对我来说输出：

member<1>()

push_back an lvalue
member<1>(member<1> const&)

emplace_back an lvalue
member<1>(member<1> const&)

push_back an xvalue
member<1>(member<1>&&)

emplace_back an xvalue
member<1>(member<1>&&)

push_back a prvalue
member<1>()
member<1>(member<1>&&)
~member<1>()

emplace_back an prvalue
member<1>()
member<1>(member<1>&&)
~member<1>()

Done
~member<1>()
~member<1>()
~member<1>()
~member<1>()
~member<1>()
~member<1>()
~member<1>()

即。我不希望任何差别。

我应该用emplace_back替换所有对push_back的调用吗？

3 个答案: