c++ - 关于指针、双指针、malloc、realloc 和 new 的一系列问题(澄清事实)

Question

我正在追赶指针。我写下了几行代码来测试动态分配二维数组的不同方式(贴在底部)

我的问题如下:

1. 我应该在 C++ 中使用 malloc 还是 new？如果我使用 new，我还能使用 realloc 吗？
2. 什么时候应该使用realloc？使用它对性能和错误有何影响？
3. 在下面的示例中，我应该使用哪个 objectNew 版本？如果答案取决于应用程序，它取决于什么？

非常感谢，马特

#include <stdio.h>
#include <stdlib.h>

struct myObject
{
    int data;
    myObject(int i)
    {
        data = i;
    }
    myObject()
    {
        data = 0;
    }

};

int main(){
    int r = 7;
    int c = 6;

    printf("Objects using NEW===============================\n");
    //notice the triple pointer being assigned a new double pointer array
    myObject*** objectNew = new myObject** [r];

    for(int i=0;i<r;i++)
    {
        //objectNew is a 1D array of double pointers, however if we assign another layer of pointers, it becomes a 2D array of pointers to myObject
        objectNew[i] = new myObject* [c];
        for(int j=0;j<c;j++){
            objectNew[i][j] = new myObject(10*i+j);
            //notice that we dereference data (->)
            printf("objectNew[%2d][%2d]=%02d\n",i,j,objectNew[i][j]->data);
        }
    }
    delete objectNew;

    printf("Objects using NEW version 2===============================\n");
    //notice the triple pointer being assigned a new double pointer array
    myObject** objectNew2 = new myObject* [r];

    for(int i=0;i<r;i++)
    {
        //objectNew is a 1D array of double pointers, however if we assign another layer of pointers, it becomes a 2D array of pointers to myObject
        objectNew2[i] = new myObject [c];
        for(int j=0;j<c;j++){
            objectNew2[i][j] = myObject(10*i+j);
            //notice that we dereference data (->)
            printf("objectNew2[%2d][%2d]=%02d\n",i,j,objectNew2[i][j].data);
        }
    }
    delete objectNew2;

    printf("Objects using MALLOC===============================\n");
    //notice the double pointer being allocated double pointers the size of pointers to myObject
    myObject** objectMalloc =(myObject**) malloc(sizeof(myObject*)*r);

    for(int i=0;i<r;i++)
    {
        //now we are assigning array of pointers the size of myObject to each double pointer
        objectMalloc[i] = (myObject*) malloc(sizeof(myObject)*c);
        for(int j=0;j<c;j++){
            objectMalloc[i][j] = myObject(10*i+j);
            //notice that we access  data without dereferencing (.)
            printf("objectMalloc[%2d][%2d]=%02d\n",i,j,objectMalloc[i][j].data);
        }
    }
    free((void*) objectMalloc);

    //same as Malloc
    printf("Objects using CALLOC===============================\n");
    myObject** objectCalloc = (myObject**) calloc(r,sizeof(myObject*));

    for(int i=0;i<r;i++)
    {
        objectCalloc[i] = (myObject*) calloc(c,sizeof(myObject));
        for(int j=0;j<c;j++){
            objectCalloc[i][j] = myObject(10*i+j);
            printf("objectCalloc[%2d][%2d]=%02d\n",i,j,objectCalloc[i][j].data);
        }
    }
    free((void*) objectCalloc);

    printf("Int using NEW===============================\n");
    //int is not an object
    int** intNew = new int* [r];

    for(int i=0;i<r;i++)
    {
        intNew[i] = new int[c];
        for(int j=0;j<c;j++){
            intNew[i][j] = 10*i+j;
            printf("intNew[%2d][%2d]=%02d\n",i,j,intNew[i][j]);
        }
    }
    delete intNew;

    printf("Int using malloc===============================\n");
    int** intMalloc =(int**) malloc(sizeof(int*)*r);

    for(int i=0;i<r;i++)
    {
        intMalloc[i] =(int*) malloc(sizeof(int)*c);
        for(int j=0;j<c;j++){
            intMalloc[i][j] = 10*i+j;
            printf("intMalloc[%2d][%2d]=%02d\n",i,j,intMalloc[i][j]);
        }
    }
    free((void*) intMalloc);
    getchar();
    return 0;
}

Answer 1

• new和 new[]是构造函数感知的，C 内存分配函数不是。
• 同样，delete和 delete []是析构函数感知的，而 free不是。
• realloc不适用于分配给 new 的内存, 没有定义类似于 realloc 的标准具有 C++ 内存管理功能的函数。

• 不要混合new和 delete与 malloc/calloc/realloc和 free (即不要 free 分配给 new 的任何内存，不要 delete 分配给 malloc 的任何内存)

• 如果你正在做 new [] ，您很可能应该使用 std::vector ，它为您封装了所有内存管理。

• 如果您正在使用内存分配的原始指针，您可能会更好地使用像 boost::shared_ptr 这样的智能/半智能指针。或 boost::scoped_ptr或 std::auto_ptr ，取决于您的需要。

• 感谢 David Thornley 提出此问题:

• 切勿混合标量 new和 delete用他们的数组形式，即不要 delete[]用 new 分配的内存，并且不要 delete用 new[] 分配的内存.到处都是未定义的行为。

• 在您的示例中，您应该使用 new和 new[]如果必须的话，因为正如我所说，它们是构造函数感知的，并且您的类不是 POD数据类型，因为它有一个构造函数。

有关更多信息，请参阅 C++ 常见问题解答:

• > C++ FAQ Freestore Management