如果有人能给我一个关于如何测试仿函数的琐碎复制能力的提示,我将不胜感激(打算使用 lambda)。如 this question 中所述它是实现定义的 lambda 是否可以简单地复制。例如,对于本问题末尾显示的代码 gcc (5.4) 和 msvc (2015) 都触发断言,这些断言不是简单的可复制分配的。
我希望这些类型的 lambdas 由 struct
表示,保持 this
指针并拥有每个捕获值(如果有)的拷贝。因此,它们似乎都可以轻松复制 - 至少对于捕获的值可以轻松复制的情况。
驱动这个问题的真正用例是我正在使用一个保持固定缓冲区的回调(std::function
的简约版本,它不分配并且用于非常简单的仿函数)它在其中复制构造(就地)传递仿函数。然后我希望能够复制/分配这些回调,但为了使其工作(开箱即用)这些固定缓冲区的简单内存复制应该等同于应对/分配保存在其中的仿函数。
所以我有两个问题:
想象一下,在下面的
test_functor()
中,我做了new
放置,例如喜欢new (&buffer) F(functor)
只
memcopy
这个缓冲区用于下面显示的那种 lambda 是否安全?我希望这应该是这样,因为对于所有情况,只有this
指针被捕获或被捕获的值是可简单复制的,但如果有人能证实这一点,那就太好了。我如何测试简单复制保存仿函数的内存是否等同于复制仿函数?如果第一个问题的答案是肯定的,那么
std::is_trivially_copy_assignable
不是正确答案。
#include <type_traits>
template <typename F>
void test_functor(const F& functor)
{
static_assert(std::is_trivially_destructible<F>::value,
"Functor not trivially destructible");
static_assert(std::is_trivially_copy_constructible<F>::value,
"Functor not trivially copy constructible");
static_assert(std::is_trivially_copy_assignable<F>::value,
"Functor not trivially copy assignable");
}
struct A
{
void test() { test_functor([this]() { }); }
};
struct B
{
void test() { test_functor([this](int v) { value = v; }); }
int value;
};
struct C
{
void test(int v) { test_functor([=]() { value = v; }); }
int value;
};
int main()
{
A a;
B b;
C c;
a.test();
b.test();
c.test(1);
return 0;
}
最佳答案
不,这不安全。如果编译器说某些东西不能简单地复制,那就不能了。
它可能会起作用。但它工作并不意味着它是安全。
即使它今天可以工作,但明天编译器更新后它会停止工作。
修复非常简单。编写不需要简单可复制的 SBO 类型(小缓冲区优化)。
template<std::size_t S, std::size_t A>
struct SBO {
void(*destroy)(SBO*) = nullptr;
// void(*copy_ctor)(SBO const* src, SBO* dest) = nullptr;
void(*move_ctor)(SBO* src, SBO* dest) = nullptr;
std::aligned_storage_t< S, A > buffer;
void clear() {
auto d = destroy;
destroy = nullptr;
// copy_ctor = nullptr;
move_ctor = nullptr;
if (d) d(this);
}
template<class T, class...Args>
T* emplace( Args&&... args ) {
static_assert( sizeof(T) <= S && alignof(T) <= A, "not enough space or alignment" );
T* r = new( (void*)&buffer ) T(std::forward<Args>(args)...);
destroy = [](SBO* buffer) {
((T*)&buffer->buffer)->~T();
};
// do you need a copy ctor? If not, don't include this:
//copy_ctor = [](SBO const* src, SBO* dest) {
// auto s = (T const*)&src.buffer;
// dest->clear();
// dest->emplace<T>( *s );
//};
move_ctor = [](SBO* src, SBO* dest) {
auto* s = (T*)&src->buffer;
dest->clear();
dest->emplace<T>( std::move(*s) );
src->clear();
};
return r;
}
SBO() = default;
SBO(SBO&& o) {
if (o.move_ctor) {
o.move_ctor(&o, this);
}
}
SBO& operator=(SBO&& o) {
if (this == &o) return *this; // self assign clear, which seems surprising
if (o.move_ctor) {
o.move_ctor(&o, this);
}
return *this;
}
// do you need a copy ctor? If so, implement `SBO const&` ctor/assign
};
现在是重点。 std::function
几乎可以肯定已经为你做到了。
在 std::function
中放置一个没有 throw 移动和构造的小型类型,并询问创建是否可以 throw 。我猜您的实现将使用 SBO 将类型存储在其中。
MSVC 2015 我认为有足够的空间让 lambda 存储两个 std::string
s。
做正确的事情的开销是适度的(两个指针,和一点间接)。您可以以更多间接为代价将存储成本降低到每个实例一个指针(将表粘贴到工厂函数中存储为静态本地的“手动 vtable”中:如果没有,我可以提供示例链接点亮一个灯泡),但使用 2 个删除方法最好将它们存储在本地(在 3+ 时考虑静态表),除非空间非常宝贵。
您已经在“删除”调用,这基本上需要存储一个函数指针,添加移动(可能还有复制)和销毁并没有那么多开销。
关于c++ - 如何测试可简单复制的可分配 lambda,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/39143774/