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