标签: delete-operator

在C++中,如果我有一个动态分配的基本类型数组,是否有必要使用delete []来防止内存泄漏？例如,

char * x = new char[100];
delete x; // is it required to call delete [] x?
struct A {
 ...
};
A *p = new A[30];
delete [] p; // delete p would cause memory leakage

请评论.

我在C++代码中有错误的行为,似乎是由于动态创建的结构的错误释放造成的.结构形式如下:

typedef struct
{
    char *value;
} Element;

typedef struct
{
    int num;
    Element **elements;
    int *index;
} Container;

它们是这样创建的:

Element *new_element(int size)
{
    Element *elem = new Element;
    elem->value = new char[size];
    return elem;
}

Container *new_container(int num)
{
    Container *cont = new Container;
    cont->num = num;
    cont->elements = new Element*[num];
    cont->index = new int[num];
}

解冻这些的正确方法是什么？

我试图用C++破坏对象,但我不能让它工作.我有几个关于如何在C++中清除内存的问题,由于GarbageCollector,我在Java中没有这么做.

我的Image类有以下析构函数和属性:

Class Image{
public:
Image(int w, int h){
    width = w; height = h;
    pixels = new int[w*h];
}
    ~Image() {
        delete [] pixels;
}
private:

        int *pixels; 
        int width, height;

}

这是我正在用我的图像做的事情:

void keyboard(unsigned char key, int x, int y){
        Image* sub1 = new Image(1,1);
        Image* sub2 = new Image(1,1);
    if (key == 'd' && camadas[1].getpXf() < camadas[1].getImage().getWidth() - gameWidth/2) {

        sub1 = &camadas[0].ScrollH(true);
        sub2 = &camadas[1].ScrollH(true);
        sub1->plot(sub2->getPixels(), 0, 0, gameWidth, gameHeight);
        lastScreen = sub1->getPixels();
        glutPostRedisplay();
    }
    if …

首先要说我是西班牙语,我的英语非常糟糕,我使用了一名翻译,因为我看起来像个文盲而道歉:)

我已经多年没有玩c ++而且我已经忘记了很多,以至于我可能怀疑或者可能的失败是语言中的基本内容.

我编写了一个小代码来测试c ++中带有虚拟析构函数的delete运算符的开销,我发现只有在第一次调用delete时它才能正常工作.

代码就在这里(这是一个允许你在线编写代码并执行代码的页面,我在visual studio和gcc中进行了测试,它完全相同):https://onlinegdb.com/SkiI1dNDQ

有人能告诉我为什么会这样吗？只有第一次运作良好,第二次运行不顺利

我也把代码放在这里,结果给出了:

#include <stdio.h>
class Base
{
public:
    virtual ~Base() { printf("~Base\r\n"); }
    void operator delete(void *m) { printf("delete Base\r\n"); }
};
class Derived : public Base
{
public:
    Derived() { x = 1; }
    ~Derived() { printf("~Derived\r\n"); }
    void operator delete(void *m) { printf("delete Derived\r\n"); }
    int x;
};

int main()
{
    Derived *derived = new Derived();
    printf("1) delete derived (%i)\r\n", ((Derived*)derived)->x);
    delete derived;
    printf("2) delete derived (%i)\r\n", ((Derived*)derived)->x); …

#include <iostream>
#include <cstdio>
using namespace std;

int main(void)
{
    int arr[] = {1,4,2,3,5,6};
    int *p = arr;
    delete p;

    for(int i = 0 ; i < 6; i++)
        cout << p[i];

    return 0;
}

输出是142356。当我说delete p为什么不删除 p 时？

运行代码时不应该出现分段错误吗？

下面的代码编译正常,但不执行

#include <iostream>
using namespace std;

int main()
{
    int *a;
    int b = 5;
    a = &b;
    cout << *a << endl;
    delete a;
    return 0;
}

编辑:

int main()
{
    int *a = 0;
    delete a;
    return 0;
}

这很好用.为什么会这样？

这段代码合法吗？

int * a = new int[1];
delete a;

还是这一个？

int * a = new int;
delete [] a;

显然,这似乎并不正确,至少应该劝阻,但它会导致任何实际问题(内存泄漏等等)吗？

请检查下面foo函数的析构函数.如果我删除p指针然后运行正常.但如果我在主程序中执行相同操作,那么我会收到错误.为什么它允许我在析构函数中执行此操作？

PS我知道删除指针没有意义,因为没有动态分配的内存.

class foo
{
  int* p;

public:
  ~foo()
  {
    delete p; // runs fine
    cout << "Destructor run \n";
  }
};


int main()
{

int* p;
delete p; // This will cause error "uninitialized local variable 'p' used "

foo test; // destructor runs fine at the end of the program

  return 0;
}

void show(int* x){
    printf("%d",x[3]);
}

int main(){
    int* ptr;

    ptr = new int[9]();
    delete [] ptr;    


    printf("%d %d\n", ptr[7], *(ptr+7));
    show(ptr);

return 0;
}

我通常知道,*和&符号.但我们的老师给了我们一个例子,她说"问题发生在这里"

int *a1;
int *a2 = new int[100];
a1=a2 //What does this line mean???
delete []a2;

k=a1[0]//she said error occurs here.

我无法理解什么是a1 = a2？为什么会出现错误？