在 C++ 中分配内存而不初始化它

Question

我正在熟悉 C++，但我在内存管理方面遇到了问题。在 C 中，每当我想为任意数量的元素保留内存时，无论类型如何，我只需调用 malloc() ，然后手动初始化（通过循环），无论是我想要的值。通缉。使用 C++ 的 new，一切都会自动初始化。

问题是，我有一个 BattlePoint 类，它有点像这样：

class BattlePoint {
public:
    BattlePoint(int x, int y) : x(x), y(y) { };
    bool operator==(const BattlePoint &right);
    virtual ~BattlePoint();

private:
    int x, y;
};

如您所见，它通过初始化程序获取一些 x 和 y 值，然后从中设置自己的 x 和 y 。问题是，这个函数将从一个将分配它们数组的函数中调用：

BattleShip::BattleShip(BattlePoint start, enum shipTypeSize size, enum shipOrientation orientation) : size(size), orientation(orientation) {
    points = new BattlePoint[size]; // Here be doubts.
}

所以，我需要我的战舰点来保存一组 BattlePoints，每个 BattlePoints 都有不同的初始化值（例如 0,1; 0,2 ；0,3，等等）。

问题是：如何分配未初始化的内存？

Julian，

PS：我还没有对 new 的工作方式进行任何测试，我简单地阅读了 维基百科关于它的文章 内容如下：

在 C++ 编程语言以及许多基于 C++ 的语言中 语言中，new 是一种动态分配的语言结构 堆上的内存并使用初始化内存 构造函数。除了一种称为“安置新”的形式外，新 尝试在堆上为新数据分配足够的内存。如果 成功，初始化内存并返回地址 新分配和初始化的内存。但是如果 new 无法分配 堆上的内存会抛出 std::bad_alloc 类型的异常。 这消除了显式检查分配结果的需要。 调用delete，它调用析构函数并返回内存 由 new 分配回堆，每次调用 new 时都必须进行 以避免内存泄漏。

放置 new 应该是解决方案，但它没有提及如何做到这一点。

PS 2：我知道这可以通过 stdlib 的向量类来完成，但我故意避免它。

Answer 1

您需要使用std::vector。在这种情况下，您可以push_back任何您想要的内容，例如

std::vector<BattlePoint> x;
x.push_back(BattlePoint(1, 2));

，如果您曾经发现自己使用new[]、delete ，或delete[]，立即重构您的程序以删除此类内容。他们几乎在所有可以想象到的方面都非常不安全。相反，请使用资源管理类，例如 std::unique_ptr、std::vector 和 std::shared_ptr。

常规new可能在涉及unique_ptr的某些情况下很有用，但要避免使用它。此外，放置新的通常不值得。当然，如果您正在编写一个资源管理类，那么您可能必须将它们用作底层原语，但这种情况很少而且相差很远。

编辑：我的错误，我没有看到你问题的最后一行。解决它：

PS 2：我知道这可以通过 stdlib 的向量类来完成，但我
故意避免它。

如果您有一些针对标准库的活动，请推出您自己的向量替代品。但不要没有 vector 类。所有符合标准的编译器都必须提供它，这是有原因的。

Answer 2

点数 = new BattlePoint[大小]; // 这里有疑问。
PS 2：我知道这可以通过 stdlib 的向量类来完成，但我故意避免它。

肯定会有疑问！使用std::vector。你为什么不呢？ 没有没有理由不使用std::vector，尤其如果它能解决您的问题。

std::vector<BattlePoint> bpoints;
bpoints.reserve(size); // there, only alloc'd memory, not initialized it.
bpoints.push_back(some_point); // still need to use push_back to initialize it

我当然会有问题 - std::vector 如何只分配内存？！
operator new 就是答案。当您使用 new 时，会调用该运算符来分配内存。 new 用于构造和初始化，而 operator new 用于分配（这就是为什么你可以重载它）。

BattlePoint* bpoints = ::operator new(size); // happens in reserve
new (bpoints[index]) BattlePoint(some_x, some_y); // happens in push_back

Answer 3

comp.lang.c++ 常见问题解答提供了有用的信息就此事发表意见，包括试图劝阻您不要使用新的展示位置 - 但如果您真的坚持，它确实有一个关于新的展示位置及其所有陷阱。

Answer 4

为了呼应上述答案，我肯定会向您指出 std::vector ，因为它是最好的解决方案。在 C++ 中管理自己的动态数组几乎从来都不是一个好主意，也几乎从来没有必要。

但是，要回答直接问题 - 在这种情况下，您可以创建一个默认构造函数和一些修改器以获得所需的效果：

class BattlePoint {
public:
    // default constructor, default initialize to 0,0
    BattlePoint() x(0), y(0) {};

    BattlePoint(int x, int y) : x(x), y(y) { };
    bool operator==(const BattlePoint &right);
    virtual ~BattlePoint();

    // mutator functions allow you to modify the classes member values
    void set_x(int x_) {x = x_;}
    void set_y(int y_) {y = y_;}

private:
    int x, y;
};

然后您可以像在 C 中习惯的那样初始化它：

BattlePoint* points = new BattlePoint[100];

for(int x = 0; x < 100; ++x)
{
   points->set_x(x);
   points->set_y(x * 2);
}

如果您'如果您对使 BattlePoint 类公开可变感到烦恼，您可以将变异器保持为私有并引入一个专门用于初始化值的友元函数。这是一个稍微复杂一些的概念，因此除非需要，否则我现在将放弃对此进行进一步解释。

既然您问了:)

使用默认构造函数和变异器再次创建您的 BattlePoint 类，但是这次将变异器保留为私有，并声明一个友元函数来使用它们：

class BattlePoint {
public:
    // default constructor, default initialize to 0,0
    BattlePoint() x(0), y(0) {};

    BattlePoint(int x, int y) : x(x), y(y) { };
    bool operator==(const BattlePoint &right);
    virtual ~BattlePoint();

private:
    // mutator functions allow you to modify the classes member values
    void set_x(int x_) {x = x_;}
    void set_y(int y_) {y = y_;}

    int x, y;

    friend void do_initialize_x_y(BattlePoint*, int, int);
};

创建一个包含本地的头文件用于创建 BattlePoint 对象数组的函数。包含标头的任何人都可以使用此函数，但如果命名正确，那么“每个人”都应该知道不要使用它。

// BattlePoint_Initialize.h
BattlePoint* create_battle_point_array(size_t count, int* x, int* y);

这个函数和我们的友元函数一起在实现文件中定义，我们将向外界“隐藏”它：

// BattlePoint_Initialize.cpp
#include <BattlePoint_Initialize.h>

namespace
{
    // by putting this function in an anonymous namespace it is only available
    // to this compilation unit.  This function can only be called from within
    // this particular file.
    //
    // technically, the symbols are still exported, but they are mangled badly
    // so someone could call this, but they would have to really try to do it
    // not something that could be done "by accident"
    void do_initialize_x_y(BattlePoint* bp, int x, int y)
    {
        bp->set_x(x);
        bp->set_y(y);
    }
}

// caution, relies on the assumption that count indicates the number of
// BattlePoint objects to be created, as well as the number of valid entries
// in the x and y arrays
BattlePoint* create_battle_point_array(size_t count, int* x, int* y)
{
    BattlePoint* bp_array = new BattlePoint[count];

    for(size_t curr = 0; curr < count; ++curr)
    {
        do_initialize_x_y(bp_array[curr], x[curr], y[curr]);
    }

    return bp_array;
}

所以你已经有了它。满足您的基本要求的非常复杂的方式。

虽然理论上可以在任何地方调用 create_battlepoint_array()，但它实际上无法修改已创建的 BattlePoint 对象。 do_initialize_x_y() 函数本质上隐藏在初始化代码后面的匿名命名空间 中，无法轻松地从程序中的其他任何地方调用。实际上，一旦创建了 BattlePoint 对象（并分两步初始化），就无法进一步修改。