将指针设置为 null 会使我的 C++ 程序崩溃

Question

我有一个构造函数，它接收一个字符指针。如果它为空，我需要将其成员变量设置为 NULL，但是，当我尝试退出时，程序会在退出时崩溃。

我已经验证它到达了将它设置为 NULL 的行，这就是崩溃的原因。

我尝试了以下方法：

val = NULL;

val = 0;

val = "";

这些都会导致崩溃，但是如果我使用：

val = new Char[1];
val = "o";

它没有崩溃。

有什么我没有做的吗？

更新：

这是我的问题的快速更新。

我使用的析构函数是：

~LField() { 
    if (val)
      delete[] val;
}

如果我拿出来：

if (val)
  delete[] val;

然后程序在退出时不会崩溃：

val = "";

这里有更多的代码：

LField(int rowNumVal, int colNumVal, int widthVal, const char *valVal = "", bool canEditVal = true) { 
    if(strlen(valVal) > 0) {            
      //doesn't jump in here since valVal is empty
    }
    else {
      val = ""; // this is where I'm trying to set a NULL value
    }
}

LField(const LField &clone) { 
  if (val)
    delete[] val;

  val = new char[strlen(clone.val)]; 
  strcpy(val, clone.val);
  rowNum = clone.rowNum;
  colNum = clone.colNum;
  width = clone.width;
  canEdit = clone.canEdit;
  index = clone.index;
}

LField& operator=(const LField &lfieldobj) {
    if (this != &lfieldobj) {
    if (val)
       delete[] val;

    val = new char[strlen(lfieldobj.val)];
    strcpy(val, lfieldobj.val);
    rowNum = lfieldobj.rowNum;
    colNum = lfieldobj.colNum;
    width = lfieldobj.width;
    canEdit = lfieldobj.canEdit;
    index = lfieldobj.index;
   }

   return *this;
}

修改：

LField(int rowNumVal, int colNumVal, int widthVal, const char *valVal = NULL, bool canEditVal = true) { 
    if(valVal != NULL) {            

    }
    else {
      val = NULL; 
    }
}

LField(const LField &clone) { 
  delete[] val;
  if (clone.val != NULL) {
     val = new char[strlen(clone.val) + 1]; 
     strcpy(val, clone.val);
  }
  else
    val = NULL;
  rowNum = clone.rowNum;
  colNum = clone.colNum;
  width = clone.width;
  canEdit = clone.canEdit;
  index = clone.index;
}

LField& operator=(const LField &lfieldobj) {
    if (this != &lfieldobj) {
       delete[] val;
    if (lfieldobj.val != NULL) {                
       val = new char[strlen(lfieldobj.val) + 1];
       strcpy(val, lfieldobj.val);
    }
    else
       val = NULL;
    rowNum = lfieldobj.rowNum;
    colNum = lfieldobj.colNum;
    width = lfieldobj.width;
    canEdit = lfieldobj.canEdit;
    index = lfieldobj.index;
   }

   return *this;
}

~LField() { 
      delete[] val;
}

我已经更新了代码。现在 val 要么是用 new[] 分配的内存，要么是 NULL，所以 delete[] 应该没有问题。但是，它仍然在退出时崩溃。

Answer 1

在复制构造函数中你尝试delete[]一个未初始化的指针：

LField(const LField &clone) { 
  //good code here, then...
  if (val) //<+ some random address here
    delete[] val;//<-undefined behavior
}

不要那样做，跳过整个结构。复制构造函数是在一个未初始化的对象上调用的，还没有资源可以“释放”。

您还尝试delete[] 字符串文字，这是未定义的行为。尝试以下更改：

LField(int rowNumVal, int colNumVal, int widthVal, const char *valVal = "", bool canEditVal = true) { 
    if(strlen(valVal) > 0) {            
      //doesn't jump in here since valVal is empty
    }
    else {
      val = new char[1];
      *val = 0;
    }
}

以下也是缓冲区溢出：

val = new char[strlen(whatever)];  <-forgot to +1 for the null terminator
strcpy(val, whatever);

在delete[] 之前检查空指针也是不必要的——空指针上的delete[] 是合法的并且没有效果。

Answer 2

天哪，从哪里开始？？

一个：

LField(const LField &clone) { 
  if (val)
    delete[] val;

这是愚蠢的，因为 val 是未定义的。您将在随机内存上调用 delete[]。

b:

  val = new char[strlen(clone.val)]; 
  strcpy(val, clone.val);

c-type 字符串需要一个空终止符。你需要 new[] 和额外的字节。

Answer 3

可能在您尝试访问（取消引用）val 的代码中的某个地方，它仍然引用 NULL。

确保您的代码中没有您正在执行此操作的位置

  val=NULL; //in the constructor

  //somewhere in your code      
  char ch= *val; //This would be Undefined Behavior

---

编辑

您正在调用val 上的delete[]，其值为""（字符串字面量），这是未定义的行为。

UB的一些例子

 1)
   char *p="hello";
  delete p; //UB
  delete []p; //UB

 2)
  char *p==new char[20]("Hello");
  delete p; //UB
  delete []p; //fine

 3) 
  char *p=new char('a');
  delete []p; //UB
  delete p; //fine

Answer 4

打电话

delete[] NULL;
delete[] 0;

没关系，你甚至不需要空检查。 但是调用

delete[] "whatever"; 

不行，因为这个 char* 没有用 new[] 分配。

请注意，在构造函数中调用 strlen() 之类的字符串函数在空引用中是非法的。

在第一次分配之前，您可以在构造函数中访问 val。这也可能导致未定义的行为。

Answer 5

我和 Prasoon Saurav 在一起。您显示的代码看起来不错，所以问题出在其他地方。

试试这个：

1. 改回val = 0;
2. 删除所有您的代码，除了构造函数、析构函数和该类的对象的声明。注释掉所有内容。我敢打赌它不会崩溃。
3. 慢慢取消注释您的其他代码并重试该程序。当它再次崩溃时，你找到了罪魁祸首。