[英]C++11 emplace_back on vector<struct>?
Consider the following program:考虑以下程序:
#include <string>
#include <vector>
using namespace std;
struct T
{
int a;
double b;
string c;
};
vector<T> V;
int main()
{
V.emplace_back(42, 3.14, "foo");
}
It doesn't work:它不起作用:
$ g++ -std=gnu++11 ./test.cpp
In file included from /usr/include/c++/4.7/x86_64-linux-gnu/bits/c++allocator.h:34:0,
from /usr/include/c++/4.7/bits/allocator.h:48,
from /usr/include/c++/4.7/string:43,
from ./test.cpp:1:
/usr/include/c++/4.7/ext/new_allocator.h: In instantiation of ‘void __gnu_cxx::new_allocator<_Tp>::construct(_Up*, _Args&& ...) [with _Up = T; _Args = {int, double, const char (&)[4]}; _Tp = T]’:
/usr/include/c++/4.7/bits/alloc_traits.h:253:4: required from ‘static typename std::enable_if<std::allocator_traits<_Alloc>::__construct_helper<_Tp, _Args>::value, void>::type std::allocator_traits<_Alloc>::_S_construct(_Alloc&, _Tp*, _Args&& ...) [with _Tp = T; _Args = {int, double, const char (&)[4]}; _Alloc = std::allocator<T>; typename std::enable_if<std::allocator_traits<_Alloc>::__construct_helper<_Tp, _Args>::value, void>::type = void]’
/usr/include/c++/4.7/bits/alloc_traits.h:390:4: required from ‘static void std::allocator_traits<_Alloc>::construct(_Alloc&, _Tp*, _Args&& ...) [with _Tp = T; _Args = {int, double, const char (&)[4]}; _Alloc = std::allocator<T>]’
/usr/include/c++/4.7/bits/vector.tcc:97:6: required from ‘void std::vector<_Tp, _Alloc>::emplace_back(_Args&& ...) [with _Args = {int, double, const char (&)[4]}; _Tp = T; _Alloc = std::allocator<T>]’
./test.cpp:17:32: required from here
/usr/include/c++/4.7/ext/new_allocator.h:110:4: error: no matching function for call to ‘T::T(int, double, const char [4])’
/usr/include/c++/4.7/ext/new_allocator.h:110:4: note: candidates are:
./test.cpp:6:8: note: T::T()
./test.cpp:6:8: note: candidate expects 0 arguments, 3 provided
./test.cpp:6:8: note: T::T(const T&)
./test.cpp:6:8: note: candidate expects 1 argument, 3 provided
./test.cpp:6:8: note: T::T(T&&)
./test.cpp:6:8: note: candidate expects 1 argument, 3 provided
What is the correct way to do this and why?这样做的正确方法是什么,为什么?
(Also tried single and double braces) (也试过单双大括号)
You need to explicitly define a ctor for the class:您需要为该类显式定义一个ctor:
#include <string>
#include <vector>
using namespace std;
struct T
{
int a;
double b;
string c;
T(int a, double b, string &&c)
: a(a)
, b(b)
, c(std::move(c))
{}
};
vector<T> V;
int main()
{
V.emplace_back(42, 3.14, "foo");
}
The point of using emplace_back
is to avoid creating a temporary object, which is then copied (or moved) to the destination.使用
emplace_back
是避免创建临时对象,然后将其复制(或移动)到目的地。 While it is also possible to create a temporary object, then pass that to emplace_back
, it defeats (at least most of) the purpose.虽然也可以创建一个临时对象,然后将其传递给
emplace_back
,但它违背了(至少大部分)目的。 What you want to do is pass individual arguments, then let emplace_back
invoke the ctor with those arguments to create the object in place.您要做的是传递单个参数,然后让
emplace_back
使用这些参数调用 ctor 以在适当的位置创建对象。
Of course, this is not an answer, but it shows an interesting feature of tuples:当然,这不是答案,但它显示了元组的一个有趣特性:
#include <string>
#include <tuple>
#include <vector>
using namespace std;
using T = tuple <
int,
double,
string
>;
vector<T> V;
int main()
{
V.emplace_back(42, 3.14, "foo");
}
For anyone from the future, this behavior will be changed in C++20 .对于未来的任何人,这种行为将在C++20 中改变。
In other words, even though implementation internally will still call T(arg0, arg1, ...)
it will be considered as regular T{arg0, arg1, ...}
that you would expect.换句话说,即使内部实现仍然会调用
T(arg0, arg1, ...)
它会被视为您期望的常规T{arg0, arg1, ...}
。
If you do not want to (or cannot) add a constructor, specialize allocator for T (or create your own allocator).如果您不想(或不能)添加构造函数,请专门为 T 分配分配器(或创建您自己的分配器)。
namespace std {
template<>
struct allocator<T> {
typedef T value_type;
value_type* allocate(size_t n) { return static_cast<value_type*>(::operator new(sizeof(value_type) * n)); }
void deallocate(value_type* p, size_t n) { return ::operator delete(static_cast<void*>(p)); }
template<class U, class... Args>
void construct(U* p, Args&&... args) { ::new(static_cast<void*>(p)) U{ std::forward<Args>(args)... }; }
};
}
Note: Member function construct shown above cannot compile with clang 3.1(Sorry, I don't know why).注意:上面显示的成员函数构造不能用 clang 3.1 编译(对不起,我不知道为什么)。 Try next one if you will use clang 3.1 (or other reasons).
如果您将使用 clang 3.1(或其他原因),请尝试下一个。
void construct(T* p, int a, double b, const string& c) { ::new(static_cast<void*>(p)) T{ a, b, c }; }
This seems to be covered in 23.2.1/13.这似乎包含在 23.2.1/13 中。
First, definitions:一、定义:
Given a container type X having an allocator_type identical to A and a value_type identical to T and given an lvalue m of type A, a pointer p of type T*, an expression v of type T, and an rvalue rv of type T, the following terms are defined.
给定一个容器类型 X,它具有与 A 相同的 allocator_type 和与 T 相同的 value_type,并给定一个 A 类型的左值 m、一个 T* 类型的指针 p、一个 T 类型的表达式 v 和一个 T 类型的右值 rv,定义了以下术语。
Now, what makes it emplace-constructible:现在,是什么让它可以就地建造:
T is EmplaceConstructible into X from args , for zero or more arguments args, means that the following expression is well-formed: allocator_traits::construct(m, p, args);
T 是 EmplaceConstructible 从 args 到 X 的,对于零个或多个参数 args,意味着以下表达式是良构的: allocator_traits::construct(m, p, args);
And finally a note about the default implementation of the construct call:最后是关于构造调用的默认实现的说明:
Note: A container calls allocator_traits::construct(m, p, args) to construct an element at p using args.
注意:容器调用 allocator_traits::construct(m, p, args) 使用 args 在 p 处构造一个元素。 The default construct in std::allocator will call ::new((void*)p) T(args), but specialized allocators may choose a different definition.
std::allocator 中的默认构造将调用 ::new((void*)p) T(args),但专用分配器可能会选择不同的定义。
This pretty much tells us that for a default (and potentially the only) allocator scheme you must have defined a constructor with the proper number of arguments for the thing you're trying to emplace-construct into a container.这几乎告诉我们,对于默认(并且可能是唯一的)分配器方案,您必须为您尝试将构造放入容器的事物定义一个具有适当数量参数的构造函数。
you have to define a constructor for your type T
because it contains an std::string
which is not trivial.你必须为你的类型
T
定义一个构造函数,因为它包含一个重要的std::string
。
moreover, it would be better to define (possible defaulted) move ctor/assign (because you have a movable std::string
as member) -- this would help to move your T
much more efficient...此外,最好定义(可能默认)移动构造函数/分配(因为你有一个可移动的
std::string
作为成员)——这将有助于更有效地移动你的T
...
or, just use T{...}
to call overloaded emplace_back()
as recommended in neighboug response... everything depends on your typical use cases...或者,只需使用
T{...}
调用重载的emplace_back()
按照 neighboug 响应中的建议...一切都取决于您的典型用例...
您可以创建struct T
实例,然后将其移动到向量:
V.push_back(std::move(T {42, 3.14, "foo"}));
You can use the {}
syntax to initialize the new element:您可以使用
{}
语法来初始化新元素:
V.emplace_back(T{42, 3.14, "foo"});
This may or may not be optimized, but it should be.这可能会也可能不会被优化,但它应该是。
You have to define a constructor for this to work, note that with your code you can't even do:您必须定义一个构造函数才能使其工作,请注意,使用您的代码,您甚至不能这样做:
T a(42, 3.14, "foo");
But this is what you need to have emplace work.但这就是你需要的地方工作。
so just:所以就:
struct T {
...
T(int a_, double b_, string c_) a(a_), b(b_), c(c_) {}
}
will make it work the desired way.将使其以所需的方式工作。
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.