为什么我的删除功能会不断出现分段错误

问题描述 投票：1回答：2

我有一个作业，需要使用重载的析构函数来删除动态分配的指针。但是，当它运行时，我的一些指针将被删除，直到出现分段错误，而对象错误的一个指针指向由参数化构造函数生成的“第二个”指针。我已经尝试过并确保delete运算符带有方括号（因为我的new运算符确实有），所以我通过打印出其信息和地址来确保该对象仍然存在。我试图重写我的分配函数，并且试图遍历我的析构函数以查看它的混乱之处。如果有帮助，则包括析构函数，分配函数，释放函数和参数化构造函数。

'''
//Destructor
MyString::~MyString()
{
  buffer_deallocate();
};

void MyString::buffer_deallocate() {
  cout << m_buffer << endl;
  delete[](m_buffer);
  m_buffer = NULL;
  m_size = 0;

}

void MyString::buffer_allocate(size_t size) {
  try {

    m_buffer = new char[size];
    m_size = size;
  }
  catch(bad_alloc&)
    {
      cout << "Errror: Unable to allocate memory" << endl;
      buffer_deallocate();
    }

}


//Parameterized Constructor
MyString::MyString(const char * str)
  :m_size(0)
{
  const char * strPtr = str;
  while(*strPtr)
    {
      strPtr++;
      m_size++;
    }

    buffer_allocate(m_size);

    for(int i = 0; i < m_size; i++)
      {
        m_buffer[i] = str[i];
      }

};
'''

但是每次我得到“和第二个”之后的输出分段错误（核心已转储）

编辑：我已经尝试了大部分推荐的方法。至少据我所知，问题仍然存在，现在我意识到我的代码很少。 （请原谅，我仍在学习中。）这是新代码以及函数文件的其余部分供参考：

'''
#include<iostream>
#include<string.h>
using namespace std;

#include"MyString.h"


//Default Constructor
MyString::MyString()
:m_size(0), m_buffer(NULL)
{
        buffer_allocate(0);
};



//Parameterized Constructor
MyString::MyString(const char * str)
  :m_size(strlen(str)+1), m_buffer(NULL)
{
        buffer_allocate(m_size);
        strncpy(m_buffer, str, m_size);

};



//Copy Constructor
MyString::MyString(const MyString & other)
  :m_size(0), m_buffer(NULL)
{
  const char * otherPtr = other.c_str();
  buffer_allocate(other.size());

  for(int i = 0; i < size(); i++)
    {
      m_buffer[i] = otherPtr[i];
    }
        m_buffer[m_size] = '\0';
};


//Destructor
MyString::~MyString()
{
  buffer_deallocate();
};



size_t MyString::size() const
{
  return m_size;
}



size_t MyString::length() const{
  return m_size-1;
}



const char * MyString::c_str() const{
  return m_buffer;
}


bool MyString::operator==(const MyString & other) const {
  char * m_bufferPointer = m_buffer;
  while(*m_bufferPointer++)
    {
      const char * str_ptr = other.c_str();
      if(*m_buffer != *str_ptr++)
        {
          return 0;
        }
    }
  return 1;
}


MyString & MyString::operator=(const MyString & rhs) {
  buffer_deallocate();

  buffer_allocate(rhs.size());
  const char * c_strPtr = rhs.c_str();
  int i;
  for(i = 0; i < rhs.size(); i++)
    {
      this->m_buffer[i] = c_strPtr[i];
    }
  return *this;
}




MyString MyString::operator+ (const MyString & other_myStr) const {

  char * temp_pointer;
  temp_pointer;
  size_t temp_size = m_size + other_myStr.size();
  //New Combined Buffer for Concatanation
  try {
    temp_pointer = new char[temp_size];
    temp_pointer = strcat(this->m_buffer, other_myStr.c_str());

  }
  catch(bad_alloc&)
    {
      cout << "Error: Unable to Allocate Memory";
      return NULL;
    }
  return MyString(temp_pointer);
}



char & MyString:: operator[](size_t index) {
  return m_buffer[index];
}


const char & MyString::operator[] (size_t index) const {
  return m_buffer[index];
}


ostream & operator << (ostream& os, const MyString & myStr) {
  os << myStr.m_buffer;
  return os;

}

void MyString::buffer_deallocate() {



  cout << "Trying to delete : " <<m_buffer << endl;
        if(m_buffer){
                delete[](m_buffer);
        }
        cout << " Success" <<endl;
  m_buffer = NULL;
  m_size = 0;

}

void MyString::buffer_allocate(size_t size) {
        try {

    m_buffer = new char[size];
    m_size = size;
  }
  catch(bad_alloc&)
    {
      cout << "Errror: Unable to allocate memory" << endl;
        m_size = 0;
    }

}

'''

c++ segmentation-fault dynamic-memory-allocation delete-operator
2个回答
0
投票

在MyString::buffer_deallocate中

cout << m_buffer << endl;

[要求m_buffer为空终止。不幸的是，MyString::MyString(const char * str)不能提供此保证。

您可以

for(int i = 0; i < m_size; i++)
{
    cout << m_buffer[i] << endl;
}

而是逐个字符地输出字符串，但是浪费一个字节，终止为null并利用标准库可能更有用

MyString::MyString(const char * str)
  :m_size(0)
{
  const char * strPtr = str;
  while(*strPtr)
    {
      strPtr++;
      m_size++;
    }

    buffer_allocate(m_size); 

    for(int i = 0; i < m_size; i++)
      {
        m_buffer[i] = str[i];
      }
    m_buffer[m_size] = '\0'; // add the null
}

然后

void MyString::buffer_allocate(size_t size) {
  try {

    m_buffer = new char[size+1]; // +1 for the null terminator
    m_size = size;
  }
  catch(bad_alloc&) // this is a bad thing to do here. More on that later.
    {
      cout << "Errror: Unable to allocate memory" << endl;
      buffer_deallocate();
    }

}

但是我们可以通过一些库函数调用来简化此过程。

MyString::MyString(const char * str)
  :m_size(strlen(str))
{
    buffer_allocate(m_size);
    strcpy(m_buffer, str);
}

附录：

您的课程可能违反了the Rule of Three。如果MyString没有副本构造函数，并且没有赋值运算符与析构函数一起使用，则任何有意或偶然的副本都会将MyString变成定时炸弹。其中一个副本的析构函数将在其他副本没有有效的m_buffer离开其他副本之前运行。

MyString::buffer_allocate不能安全地返回void，除非它允许传播异常。捕获bad_alloc将使对象没有在m_buffer处进行有效分配，程序的其余部分将不知道这一点。程序中的所有其他访问都必须测试是否有有效的缓冲区，或者尝试访问无效的内存而发生未定义的行为。最好让异常消失并被程序的另一部分捕获，该部分更适合于决定要做什么。

MyString::buffer_allocate将泄漏现有分配，如果在MyString处已经具有有效分配的m_buffer上调用。我推荐一个

if (m_buffer) 
{
    delete[] m_buffer;
}

并在m_buffer的构造函数中将MyString初始化为空
MyString(const char* str)
    : m_size(std::strlen(str)), m_buffer(nullptr) 
{
    buffer_allocate(m_size);
    std::strncpy(m_buffer, str, m_size);
}
0
投票

所以我不得不将其重新制作为一些工作代码。问题可能是字符串长度必须加1才能添加nul终止。这样就可以：

0
投票

所以我不得不将其重新制作为一些工作代码。问题可能是字符串长度必须加1才能添加nul终止。这样就可以：

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.