所以我现在正在重构一个巨大的功能：
int giant_function(size_t n, size_t m, /*... other parameters */) {
int x[n]{};
float y[n]{};
int z[m]{};
/* ... more array definitions */
当我找到一组具有离散功能的相关定义时，将它们分组为类定义：
class V0 {
std::unique_ptr<int[]> x;
std::unique_ptr<float[]> y;
std::unique_ptr<int[]> z;
public:
V0(size_t n, size_t m)
: x{new int[n]{}}
, y{new float[n]{}}
, z{new int[m]{}}
{}
// methods...
}
重构版本不可避免地更具可读性，但我发现不太令人满意的一点是分配数量的增加。
在堆栈中分配所有这些（可能是非常大的）数组可能是一个等待在未经编译的版本中发生的问题，但是我们没有理由只通过一个更大的分配来解决这个问题：
class V1 {
int* x;
float* y;
int* z;
public:
V1(size_t n, size_t m) {
char *buf = new char[n*sizeof(int)+n*sizeof(float)+m*sizeof(int)];
x = (int*) buf;
buf += n*sizeof(int);
y = (float*) buf;
buf += n*sizeof(float);
z = (int*) buf;
}
// methods...
~V0() { delete[] ((char *) x); }
}
这种方法不仅涉及大量手册（阅读：容易出错）的簿记，而且更大的罪恶在于它不可组合。
如果我想在堆栈上有V1值和W1值，那么这就是＆＃39> s
为他们的幕后资源分配一个。更简单的是，我希望能够在单个分配中分配V1及其指向的资源，我不能用这种方法做到这一点。
这最初让我想到的是一个两遍方法 - 一个通道来计算需要多少空间，然后进行一个巨大的分配，然后另一个通过分配分配并初始化数据结构。
class V2 {
int* x;
float* y;
int* z;
public:
static size_t size(size_t n, size_t m) {
return sizeof(V2) + n*sizeof(int) + n*sizeof(float) + m*sizeof(int);
}
V2(size_t n, size_t m, char** buf) {
x = (int*) *buf;
*buf += n*sizeof(int);
y = (float*) *buf;
*buf += n*sizeof(float);
z = (int*) *buf;
*buf += m*sizeof(int);
}
}
// ...
size_t total = ... + V2::size(n,m) + ...
char* buf = new char[total];
// ...
void* here = buf;
buf += sizeof(V2);
V2* v2 = new (here) V2{n, m, &buf};
然而，这种方法在远处有很多重复，从长远来看这就是一个问题。回到工厂摆脱了：
class V3 {
int* const x;
float* const y;
int* const z;
V3(int* x, float* y, int* z) : x{x}, y{y}, z{z} {}
public:
class V3Factory {
size_t const n;
size_t const m;
public:
Factory(size_t n, size_t m) : n{n}, m{m};
size_t size() {
return sizeof(V3) + sizeof(int)*n + sizeof(float)*n + sizeof(int)*m;
}
V3* build(char** buf) {
void * here = *buf;
*buf += sizeof(V3);
x = (int*) *buf;
*buf += n*sizeof(int);
y = (float*) *buf;
*buf += n*sizeof(float);
z = (int*) *buf;
*buf += m*sizeof(int);
return new (here) V3{x,y,z};
}
}
}
// ...
V3::Factory v3factory{n,m};
// ...
size_t total = ... + v3factory.size() + ...
char* buf = new char[total];
// ..
V3* v3 = v3factory.build(&buf);
还有一些重复，但是参数只能输入一次。还有很多手工簿记。如果我能用小工厂建造这个工厂，那就太好了......
然后我的哈克尔大脑击中了我。我正在实施 Applicative Functor 。这可能更好！
我需要做的就是编写一些工具来自动求和大小并并排运行构建函数：
namespace plan {
template <typename A, typename B>
struct Apply {
A const a;
B const b;
Apply(A const a, B const b) : a{a}, b{b} {};
template<typename ... Args>
auto build(char* buf, Args ... args) const {
return a.build(buf, b.build(buf + a.size()), args...);
}
size_t size() const {
return a.size() + b.size();
}
Apply(Apply<A,B> const & plan) : a{plan.a}, b{plan.b} {}
Apply(Apply<A,B> const && plan) : a{plan.a}, b{plan.b} {}
template<typename U, typename ... Vs>
auto operator()(U const u, Vs const ... vs) const {
return Apply<decltype(*this),U>{*this,u}(vs...);
}
auto operator()() const {
return *this;
}
};
template<typename T>
struct Lift {
template<typename ... Args>
T* build(char* buf, Args ... args) const {
return new (buf) T{args...};
}
size_t size() const {
return sizeof(T);
}
Lift() {}
Lift(Lift<T> const &) {}
Lift(Lift<T> const &&) {}
template<typename U, typename ... Vs>
auto operator()(U const u, Vs const ... vs) const {
return Apply<decltype(*this),U>{*this,u}(vs...);
}
auto operator()() const {
return *this;
}
};
template<typename T>
struct Array {
size_t const length;
Array(size_t length) : length{length} {}
T* build(char* buf) const {
return new (buf) T[length]{};
}
size_t size() const {
return sizeof(T[length]);
}
};
template <typename P>
auto heap_allocate(P plan) {
return plan.build(new char[plan.size()]);
}
}
现在我可以简单地陈述我的课程：
class V4 {
int* const x;
float* const y;
int* const z;
public:
V4(int* x, float* y, int* z) : x{x}, y{y}, z{z} {}
static auto plan(size_t n, size_t m) {
return plan::Lift<V4>{}(
plan::Array<int>{n},
plan::Array<float>{n},
plan::Array<int>{m}
);
}
};
一次性使用它：
V4* v4;
W4* w4;
std::tie{ ..., v4, w4, .... } = *plan::heap_allocate(
plan::Lift<std::tie>{}(
// ...
V4::plan(n,m),
W4::plan(m,p,2*m+1),
// ...
)
);
它并不完美（在其他问题中，我需要添加代码来跟踪析构函数，让heap_allocate返回一个std::unique_ptr来调用所有这些），但在我进一步讨论之前在兔子洞里，我想我应该检查已有的艺术品。
就我所知，现代编译器可能足够聪明，可以识别V0中的内存总是被分配/解除分配，并为我分配分配。
如果没有，是否有一个预先实现的这个想法（或其变体）用于使用applicative functor批量分配？
答案 0 :(得分：1)
首先，我想就您的解决方案的问题提供反馈意见：
您忽略对齐方式。依赖于假设int和float在您的系统上共享相同的对齐方式，您的特定用例可能会“很好”。但是尝试在混合中添加一些double并且会有UB。由于访问不对齐，您可能会发现您的程序在ARM芯片上崩溃。
new (buf) T[length]{}; bad and non-portable。简而言之：Standard允许编译器保留给定存储的初始y字节以供内部使用。您的程序无法在y的系统上分配此y > 0个字节（是的，这些系统显然存在; VC ++据称这样做了。）
必须为y分配是不好的，但是使阵列放置新的无法使用的原因是无法找到实际调用放置新位置之前有多大y。在这种情况下真的没办法使用它。
你已经意识到了这一点，但是为了完整性：你没有破坏子缓冲区，所以如果你曾经使用过非破坏性的类型，那么就会有UB。
解决方案：
为每个缓冲区分配额外的alignof(T) - 1个字节。将每个缓冲区的开头与std::align对齐。
您需要循环并使用非数组展示位置。从技术上讲，做非数组放置新意味着在这些对象上使用指针算法有UB，但标准在这方面是愚蠢的，我选择忽略它。关于此问题的Here's语言律师讨论。据我了解，p0593r2提案包含了对此技术性的解决方案。
添加与放置新调用相对应的析构函数调用（或static_assert，只应使用简单的可破坏类型）。请注意，对非平凡销毁的支持提高了对异常安全的需求。如果构造一个缓冲区抛出异常，则需要销毁先前构造的子缓冲区。在单个元素的构造函数已经构造完毕后，需要同样小心。
我不知道现有技术，但后续艺术如何呢？我决定从略微不同的角度对此进行刺穿。但要注意，这缺乏测试，可能包含错误。
buffer_clump模板，用于构造/破坏对象到外部原始存储中，以及计算每个子缓冲区的对齐边界：
#include <cstddef>
#include <memory>
#include <vector>
#include <tuple>
#include <cassert>
#include <type_traits>
#include <utility>
// recursion base
template <class... Args>
class buffer_clump {
protected:
constexpr std::size_t buffer_size() const noexcept { return 0; }
constexpr std::tuple<> buffers(char*) const noexcept { return {}; }
constexpr void construct(char*) const noexcept { }
constexpr void destroy(const char*) const noexcept {}
};
template<class Head, class... Tail>
class buffer_clump<Head, Tail...> : buffer_clump<Tail...> {
using tail = buffer_clump<Tail...>;
const std::size_t length;
constexpr std::size_t size() const noexcept
{
return sizeof(Head) * length + alignof(Head) - 1;
}
constexpr Head* align(char* buf) const noexcept
{
void* aligned = buf;
std::size_t space = size();
assert(std::align(
alignof(Head),
sizeof(Head) * length,
aligned,
space
));
return (Head*)aligned;
}
constexpr char* next(char* buf) const noexcept
{
return buf + size();
}
static constexpr void
destroy_head(Head* head_ptr, std::size_t last)
noexcept(std::is_nothrow_destructible<Head>::value)
{
if constexpr (!std::is_trivially_destructible<Head>::value)
while (last--)
head_ptr[last].~Head();
}
public:
template<class... Size_t>
constexpr buffer_clump(std::size_t length, Size_t... tail_lengths) noexcept
: tail(tail_lengths...), length(length) {}
constexpr std::size_t
buffer_size() const noexcept
{
return size() + tail::buffer_size();
}
constexpr auto
buffers(char* buf) const noexcept
{
return std::tuple_cat(
std::make_tuple(align(buf)),
tail::buffers(next(buf))
);
}
void
construct(char* buf) const
noexcept(std::is_nothrow_default_constructible<Head, Tail...>::value)
{
Head* aligned = align(buf);
std::size_t i;
try {
for (i = 0; i < length; i++)
new (&aligned[i]) Head;
tail::construct(next(buf));
} catch (...) {
destroy_head(aligned, i);
throw;
}
}
constexpr void
destroy(char* buf) const
noexcept(std::is_nothrow_destructible<Head, Tail...>::value)
{
tail::destroy(next(buf));
destroy_head(align(buf), length);
}
};
buffer_clump_storage模板，利用buffer_clump将子缓冲区构建到RAII容器中。
template <class... Args>
class buffer_clump_storage {
const buffer_clump<Args...> clump;
std::vector<char> storage;
public:
constexpr auto buffers() noexcept {
return clump.buffers(storage.data());
}
template<class... Size_t>
buffer_clump_storage(Size_t... lengths)
: clump(lengths...), storage(clump.buffer_size())
{
clump.construct(storage.data());
}
~buffer_clump_storage()
noexcept(noexcept(clump.destroy(nullptr)))
{
if (storage.size())
clump.destroy(storage.data());
}
buffer_clump_storage(buffer_clump_storage&& other) noexcept
: clump(other.clump), storage(std::move(other.storage))
{
other.storage.clear();
}
};
最后，一个可以作为自动变量分配的类，并为buffer_clump_storage的子缓冲区提供命名指针：
class V5 {
// macro tricks or boost mpl magic could be used to avoid repetitive boilerplate
buffer_clump_storage<int, float, int> storage;
public:
int* x;
float* y;
int* z;
V5(std::size_t xs, std::size_t ys, std::size_t zs)
: storage(xs, ys, zs)
{
std::tie(x, y, z) = storage.buffers();
}
};
用法：
int giant_function(size_t n, size_t m, /*... other parameters */) {
V5 v(n, n, m);
for(std::size_t i = 0; i < n; i++)
v.x[i] = i;
如果你只需要聚集的分配而不是命名组的能力，这个直接用法几乎避免了所有的样板：
int giant_function(size_t n, size_t m, /*... other parameters */) {
buffer_clump_storage<int, float, int> v(n, n, m);
auto [x, y, z] = v.buffers();
批评我自己的工作：
V5成员const本来可以说是好的，但我发现它涉及的模板比我想要的更多。throw声明为noexcept。 g ++和clang ++都不够聪明，无法理解当函数为noexcept时抛出将永远不会发生。我想这可以通过使用部分特化来解决，或者我可以添加（非标准）指令来禁用警告。buffer_clump_storage可以设置为可复制和可分配。这涉及加载更多代码，我不希望它们需要它们。移动构造函数也可能是多余的，但至少它的实现是高效和简洁的。