I have an assignment where I need to use an overloaded destructor to delete dynamically allocated pointers. However, when it runs, some of my pointers are deleted until a segmentation fault with one of my objects' pointers the one pointing to " and the second" made with a parameterized constructor. 
I have tried to go through and make sure the delete operator had brackets (because my new operator did) I made sure the object still existed by printing out its information and address. I have tried to rewrite my allocation function, and I have tried to go over my destructor to see where it messes up.
If it helps, I have included my destructor, my allocation function, my deallocation function, and my parameterized constructor.

```
'''
//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];
      }

};
'''

```

Every time however I get the output after "and the second" to be 
Segmentation fault (core dumped)

Edit: I have tried the majority of what was recommended. At least what I understood, the problem still persists, and I realize now I was kind of sparse on my code. (Please forgive me, I'm still learning.) Here is the new code along with the rest of the function file for reference:

```
'''
#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;
    }

}

```

'''