C++ C++；：我可以使用新放置的向量吗？

我正在做一个思维实验，我想让我的生活更轻松。我使用的是一个数据结构，其中包括一对按顺序排列的元素数组。我将这些数据结构分配到固定大小的块中，以便更容易地放置内存，并且（在将来的某个时候）能够更容易地从稳定的存储中读取/写入数据。以下是我目前正在使用的代码：

#include <limits>

const int NODE_SIZE = 512;

template <typename K, typename D>
class Node {
    long   next;
    short  num;
    K*     keys;
    D*     data;
public:
    Node( int l, int order );
};

// num is calculated by something like this...
num = NODE_SIZE - sizeof( Node<K,D> ) - sizeof( long );
num /= (sizeof( D ) + sizeof( K ));

// Constructor
//     Will be called with a placement-new and given a NODE_SIZE
//     byte block of memory, aligned at NODE_SIZE
template<typename K, typename D>
Node<K,D>::Node( int n ) : num ( n ), next( 0 ) {
    keys = reinterpret_cast<K*>(reinterpret_cast<char*>(&next) +
                                sizeof( *this ));

    int numbytes = num*sizeof(K);
    // Make sure we're aligned to a void *.
    if ( numbytes % sizeof( void * ) ) {
        numbytes = (numbytes / sizeof( void * )+1)*sizeof( void * );
    }

    // Align to the number of bytes in a void *
    data = reinterpret_cast<D*>( reinterpret_cast<char*>(keys)+numbytes);

    for( int i=0; i<num; i++ ) keys[i] = std::numeric_limits<K>::max();
}

#包括
const int NODE_SIZE=512；
模板
类节点{
长下；
短num；
K*键；
D*数据；
公众：
节点（int-l，int-order）；
};
//num是这样计算的。。。
num=节点大小-sizeof（节点）-sizeof（长）；
num/=（sizeof（D）+sizeof（K））；
//建造师
//将使用新位置调用，并给定节点大小
//内存字节块，按节点大小对齐
模板
Node:：Node（intn）：num（n），next（0）{
键=重新解释强制转换（重新解释强制转换（&next）+
sizeof（*本））；
int numbytes=num*sizeof（K）；
//确保我们与一个空*对齐。
if（numbytes%sizeof（void*））{
numbytes=（numbytes/sizeof（void*）+1）*sizeof（void*）；
}
//与空白中的字节数对齐*
数据=重新解释强制转换（重新解释强制转换（键）+numbytes）；
对于（int i=0；i您对
num
的计算：

(NODE_SIZE - sizeof( Node<K,D> ) - sizeof( long )) / (sizeof( D ) + sizeof( K ))

（NODE_SIZE-sizeof（NODE）-sizeof（long））/（sizeof（D）+sizeof（K））

是编译时常量。为什么不简单地声明：

template <typename K, typename D>
class BpTreeNode {
    static const std::size_t num = (NODE_SIZE - sizeof( long )) /
                                   (sizeof( D ) + sizeof( K ));
    K    keys[num];
    D    data[num];
    long next;
public:
    Node( int l, int order );
};

模板
BpTreeNode类{
静态常量std:：size\u t num=（节点大小-sizeof（长））/
（D）+K）；
K键[num]；
D数据[num]；
长下；
公众：
节点（int-l，int-order）；
};

让编译器为你做这项工作？
你知道分配器吗？我知道它们存在，但我还没有利用它们。我相信你可以通过为分配器提供一个
std:：vector
来做你想做的事情。我不确定，因为我既不完全理解你在做什么，也不完全理解分配器，但我的无知与我认为您和分配器重叠的地方相匹配。：）您当然可以使用placement
new
将
std:：vector
放在特定地址，但这只会放向量的成员变量（通常是三个指针和一个可能为空的分配器）在该内存中，向量的元素将分别存储在从其分配器获得的内存中。正如上面的注释所述，您可以使用自定义分配器，该分配器使用指向已分配存储的指针进行初始化，并在请求分配内存时返回指向该内存的指针，但这样做令人惊讶不幸的是，这很复杂，很难纠正。