Se detectó corrupción en el montón después del bloque normal

Question

Tengo el siguiente código y no estoy seguro de por qué recibo el error de corrupción detectado en el montón cuando golpea el destructor de Myclass. Creo que estoy desasignando la memoria correctamente?

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

class MyClass{ 
private: 
    char* mp_str; 
public: 
    MyClass():mp_str(NULL){} 
    ~MyClass(){ 
     delete [] mp_str; 
    } 

    void setString(const char* str); 
    void printString(); 
}; 

int main(){ 
    MyClass* a = new MyClass(); 
    std::vector<MyClass> myVector; 

    myVector.push_back(*a); 

    a->setString("Hello World"); 
    myVector[0].setString("Goodbye world"); 

    a->printString(); 
    myVector[0].printString(); 

    return 1; 
} 

void MyClass::setString(const char* const str){ 
    if(!str) 
     return; 

    size_t len = strlen(str); 

    if(!this->mp_str){ 
     this->mp_str = new char[len]; 
     memset(mp_str, 0, len+1); 
    } 
    strncpy(mp_str, str, len); 
} 

void MyClass::printString(){ 
    if(this->mp_str) 
     cout << mp_str; 
    else 
     cout << "No string found"; 
} 

EDITAR: (Código fijo)

void MyClass::setString(const char* const str){ 
    if(!str) 
     return; 

    size_t len = strlen(str); 

    if(!this->mp_str){ 
     this->mp_str = new char[len+1]; 
     memset(mp_str, 0, len+1); 
    } 
    strncpy(mp_str, str, len); 
} 

en main(), también añadió

delete a; 

antes de llamar retorno 1;

Answer 1

Debe asignar la longitud de la cadena +1, para tener en cuenta el nulo. Lo estás haciendo bien.

if(!this->mp_str){ 
    this->mp_str = new char[len+1]; 
    memset(mp_str, 0, len+1); 
} 

Answer 2

(Publicado después de la respuesta de Rafael fue aceptada, como debe ser.)

La saturación del búfer fue sin duda la causa raíz de este accidente en particular, pero el accidente podría haberse evitado mediante la simplificación de la mientras que la ejecución ajustando para la adherencia al Rule of Three. A saber, desde que implementó un destructor (para tratar con mp_str), también debería haber implementado un constructor de copia y un operador de asignación.

Pero, otra forma de adherirse a TRoT es evitar la necesidad de implementar cualquiera de esas cosas en absoluto. En este caso, el uso de un std::string en lugar de un char * habría resuelto tanto el accidente y ser compatible con Trot:

class MyClass{ 
private: 
    std::string mp_str; 
public: 
    void setString(const char* str) { mp_str = str ? str : ""; } 
    void printString() { 
     if (mp_str.size()) std::cout << mp_str; 
     else std::cout << "(mp_str is empty)"; 
    } 
};