c++ - 创建在 C++ 中的结构内声明的数组 a[1] 的多个实例

Question

假设我有如下两个结构:

struct address{
  int x;
  int y;
} addr;

struct details{
  int count;
  int size;
  addr addre[1];// Instances of count number of addresses
} detail;                 

如何创建一个变量，比如 det，它有多个 addre 实例，由计数定义？

Answer 1

这是通过在对象末尾分配动态大小的容器(具有固定大小)来减少内存分配次数和改善引用局部性的常用技巧。

不过在 C++ 中，使用那个额外的 member[1] 会导致一些麻烦 - 该成员会自动初始化，而其余元素则不会。最好完全避免声明该成员，而是为元素提供访问器/迭代器。然后手动初始化并销毁所有成员。例如:

struct address {
    int x;
    int y;
};

struct details {
    int count;
    int size;

    address* addr_begin() { return reinterpret_cast<address*>(this + 1); }
    address* addr_end() { return addr_begin() + count; }

    static void* operator new(size_t sizeof_details, int count) {
        return ::operator new(sizeof_details + count * sizeof(address));
    }

    static void operator delete(void* p) {
        ::operator delete(p);
    }

    static std::unique_ptr<details> create(int count, int size) {
        return std::unique_ptr<details>(new(count) details(count, size));
    }

    ~details() {
        std::for_each(addr_begin(), addr_end(), [](address& a) { a.~address(); });
    }

private:
    details(int count, int size)
        : count(count)
        , size(size)
    {
        std::uninitialized_fill(addr_begin(), addr_end(), address{});
    }
};

int main() {
    auto det = details::create(10, 10);
}

---

如果你不能改变结构，那么:

#include <new>
#include <algorithm>

struct address {
    int x;
    int y;
};

struct details {
    int count;
    int size;
    address addre[1];
};

details* create_details(int count, int size) {
    void* mem = ::operator new(sizeof(details) + (count - 1) * sizeof(address));
    auto* p = new (mem) details{count, size};
    std::uninitialized_fill(p->addre + 1, p->addre + count, address{});
    return p;
}

void destroy_details(details* p) {
    std::for_each(p->addre + 1, p->addre + p->count, [](address& a) { a.~address(); });
    p->~details();
    ::operator delete(p);
}

int main() {
    auto* p = create_details(10, 10);
    destroy_details(p);
}