relacionales - sobrecarga de operadores unarios en c++

Error de segmentación de C++ cuando el primer parámetro es nulo en la sobrecarga del operador de comparación

Question

Estoy escribiendo una clase llamada Word , que maneja una cadena de caracteres y sobrecarga los operadores < , > , <= , >= .

word.h :

friend bool operator<(const Word &a, const Word &b);

word.cc :

bool operator<(const Word &a, const Word &b) {
if(a == NULL && b == NULL)
return false;
if(a == NULL)
return true;
if(b == NULL)
return false;
return strcmp(a.wd, b.wd) < 0; //wd is a valid c string, EDIT: changed to strcmp
}

main :

char* temp = NULL; //EDIT: i was mistaken, temp is a char pointer
Word a("blah"); //a.wd = [b,l,a,h]
cout << (temp<a);

Aparece un error de segmentación antes de la primera línea del operator< método después de la última línea en el main . Puedo corregir el problema escribiendo

cout << (a>temp);

donde el operator> está definido de manera similar y no recibo ningún error, pero mi tarea requiere (temp < a) que funcione, así que aquí es donde pido ayuda.

EDIT: cometí un error la primera vez y dije que la temperatura era de tipo Word , pero en realidad es de tipo char* . Así que supongo que el compilador convierte temp a Word utilizando uno de mis constructores. No sé cuál usaría y por qué funcionaría, ya que el primer parámetro no es Word .

aquí está el constructor que creo que se está utilizando para hacer que Word use temp :

Word::Word(char* c, char* delimeters="/n") {
char *temporary = "/0";
if(c == NULL)
c = temporary;
check(stoppers!=NULL, "(Word(char*,char*))NULL pointer"); // exits the program if the expression is false
if(strlen(c) == 0)
size = DEFAULT_SIZE; //10
else
size = strlen(c) + 1 + DEFAULT_SIZE;
wd = new char[size];
check(wd!=NULL, "Word(char*,char*))heap overflow");
delimiters = new char[strlen(stoppers) + 1]; // EDIT: changed to []
check(delimiters!=NULL,"Word(char*,char*))heap overflow");
strcpy(wd,c);
strcpy(delimiters,stoppers);
count = strlen(wd);
}

wd es de tipo char*

gracias por mirar esta gran pregunta y tratar de ayudar. avíseme si necesita más código para mirar

Answer 1

Estoy casi seguro de que no pretendías construir un char en el montón con un valor inicial de un entero basado en el tamaño de los stoppers :

delimiters = new char(strlen(stoppers) + 1); // Should use [] not ()

También estás usando C ++ y nunca te diría qué hacer, pero por favor, a menos que sepas exactamente que no hay peligro, no uses strcpy . Por exactamente esta razón.

Es una copia oculta de cadenas, y cuando el destino no tiene suficiente espacio (como es el caso de su asignación de tipográficas), las cosas van mal.

EDITAR:

También veo en su sobrecarga de operator< que usa

a.wd < b.wd

y afirman que .wds son cadenas C válidas. Si ese es el caso, no puede aplicarles un operador simple <y deben usar strcmp , strncmp o alguna otra función de comparación completa

Answer 2

Recortando los otros bits del constructor:

Word::Word(char* c, char* delimeters=NULL) {
check(stoppers!=NULL, "(Word(char*,char*))NULL pointer"); //exits the program if the expression is false
delimiters = new char[strlen(stoppers) + 1];
check(delimiters!=NULL,"Word(char*,char*))heap overflow");
strcpy(delimiters,stoppers);
}

Está asignando y copiando al parámetro de entrada ( delimiters ) no a la variable miembro ( stoppers ). Por lo tanto, cuando llamas:

delimiters = new char[strlen(stoppers) + 1];

Aquí, stoppers == NULL (inferido de la llamada de check ) así strlen(NULL) bloquea.

También en:

bool operator<(const Word &a, const Word &b)

Verifica cosas como a == NULL . Esto no es necesario ya que a y b son referencias, por lo que los objetos no son nulos.

Si wd puede ser nulo, deberá cambiarlos para verificar a.wd y b.wd