Error with friend non-member function which gives a segmentation fault

Question

For this project we are suppose to cover the topic of dynamic memory allocation and deallocation. The functionality of the 'operator<<; is to output(to terminal or file depending on the type of ostream& os object passed as a parameter to it) the MyString data (the C-string representation held within m_buffer). Right after my program prints to the Terminal "Access Successful." I receive a Segmentation fault (core dumped) I am quite sure that it have something to do with the operator << but I do not know how to fix this. Hence, it fails to print "Testing Operator <<()". Any Suggestions? Thank you!

//int main
int main(){
std::cout << "Testing operator[]()" << std::endl;
MyString ms_access("Access successful (NOT)");
ms_access[17] = 0;

std::cout << "Testing operator<<()" << std::endl;
cout << ms_access << endl;
}

class MyString{

 public:
MyString();                                            
MyString(const char * str);                              
MyString(const MyString & other_myStr);                  
~MyString();                                              

size_t size() const;                                      
size_t length() const;                                   
const char * c_str() const;                               

bool operator== (const MyString & other_myStr) const;     
MyString & operator= (const MyString & other_myStr);      
MyString operator+ (const MyString & other_myStr) const;  
char & operator[] (size_t index);                         
const char & operator[] (size_t index) const;            

friend std::ostream & operator<<(std::ostream & os, const MyString & myStr);   

  private:
   void buffer_deallocate();                                
   void buffer_allocate(size_t size);                        

   char * m_buffer;
   size_t m_size;
};

//definition
std::ostream& operator<<(std::ostream& os, const MyString& myStr){
//if(os == std::cout){
os << myStr.m_buffer << std::endl;
//}
}

//will allow by-reference accessing of a specific character at index size_tindexwithin the allocated m_bufferchar arrayof a non-constqualified object. 
char& MyString::operator[](size_t index){
size_t counter = 0;
while(counter != index){
    counter++;
}
return m_buffer[counter];
}

//will allow by-reference accessing of a specific character at index size_tindexwithin the allocated m_bufferchar array of a constqualified object.
const char& MyString::operator[](size_t index)const{
size_t counter = 0;
while(counter != index){
    counter++;
}
return m_buffer[counter];
}


void MyString::buffer_deallocate(){
if(m_buffer != NULL){
delete [] m_buffer;
}
}
void MyString::buffer_allocate(size_t size){
if(m_buffer != NULL){
    buffer_deallocate();
}
m_size = size;
m_buffer = new char[m_size];

}
MyString::MyString(){
m_size = 0;
m_buffer = NULL;
 }
MyString::MyString(const char *str){
m_buffer = NULL;
m_size = strlen(str);
buffer_allocate(m_size);
strcpy(m_buffer,str);
}
 MyString::MyString(const MyString &other){
m_buffer = NULL;
m_size = other.m_size;
buffer_allocate(m_size);
strcpy(m_buffer,other.m_buffer);
}

size_t MyString::size()const{
return m_size;
}
size_t MyString::length(){
return strlen(m_buffer)-1;
 }
 const char* MyString::c_str() const {
char *str = NULL;

    str = new char[m_size];
    for(size_t i = 0; i < m_size;i++){
        str[i] = *(m_buffer+i);
    }
    return str;
    delete [] str;
    str = NULL;

}
bool MyString::operator==(const MyString & other)const{
if(strcmp(m_buffer,other.m_buffer) == 0){
    return true;
}else if (strcmp(m_buffer,other.m_buffer) != 0){
    return false;
}
}
MyString & MyString::operator=(const MyString & str1){
buffer_deallocate();
m_buffer = new char[str1.m_size];
strcpy(m_buffer,str1.m_buffer);

}
MyString MyString::operator+(const MyString & other_myStr)const{
MyString myStr(strcat(m_buffer,other_myStr.m_buffer));
return myStr;

}