Segmentation fault während Struktur Sortierung Array aus Zeiger

Question

Mögliche Duplizieren:
How do I find a segfault in my C++ program?

Ich bin der Segmentierungsfehler bekommen, während die Struktur Sortierung Hier ist meine Struktur

typedef struct 
    { 
    char *id; 
    char *timestamp; 
    char *name; 
    char *text; 
    }DATA; 

DATA *the_array = NULL; 

Ich bin dynamisch den Speicher mit mallo zuweisen c und realloc. Jetzt verwende ich bubblesort, um diese Struktur zu sortieren. Ich verwende Blutvergießen C/C++ IDE unter Windows 7. Hinzufügen des Codes, wo ich die Ausnahme bekomme.

for(int i =0;i < num_elements;i++) 
    { 
      if(strcmp("DUP",the_array[i].id)==1) 
      for(int j = i+ i; j < num_elements; j++) 
        { 
         if(strcmp("DUP",the_array[j].id)==1){ 
         float n1 = strtof(the_array[i].timestamp,NULL); 
         float n2 = strtof(the_array[j].timestamp,NULL); 
         // Exchange the elements 
         if(n1 > n2) 
          { 
            // Exchange the id 
            temp_id = (char*)malloc(sizeof(the_array[i].id)); 
            strcpy(temp_id,the_array[i].id); 
            strcpy(the_array[i].id,the_array[j].id); 
            strcpy(the_array[j].id,temp_id); 

            //Exchange the timestamps 
            temp_timestamp = (char*)malloc(sizeof(the_array[i].timestamp)); 
            strcpy(temp_timestamp,the_array[i].timestamp); 
            strcpy(the_array[i].timestamp,the_array[j].timestamp); 
            strcpy(the_array[j].timestamp,temp_timestamp); 

            //Exchange the username 
            temp_username = (char*)malloc(sizeof(the_array[i].name)); 
            strcpy(temp_username,the_array[i].name); 
            strcpy(the_array[i].name,the_array[j].name); 
            strcpy(the_array[j].name,temp_username); 

            //Exchange the text 
            temp_text = (char*)malloc(sizeof(the_array[i].text)); 
            strcpy(temp_text,the_array[i].text); 
            strcpy(the_array[i].text,the_array[j].text); 
            strcpy(the_array[j].text,temp_text); 



          } 
          } 
        } 
    } 

Kann ich es tun wie dieses

for(int i =0;i < num_elements;i++) 
{ 
     if(strcmp(dup,the_array[i].id)==1) 
     for(int j = i+ i; j < num_elements; j++) 
       { 

        float n1 = strtof(the_array[i].timestamp,NULL); 
        float n2 = strtof(the_array[j].timestamp,NULL); 
        // Exchange the elements 
        if(n1 < n2) 
         { 
          //Change the pointer locations 
          temp_array1 = &the_array[i]; 
          temp_array2 = &the_array[j]; 

          temp_array3=temp_array1; 
          temp_array1=temp_array2; 
          temp_array2=temp_array3; 


         } 

       } 
} 

Answer 1

Beim Kopieren von Elementen sind Sie beispielsweise malloc in sizeof(the_array[i].name)), die die Größe eines Zeichenzeigers hat. Wenn der Name länger als 3 Byte ist, überschreiben Sie beim Kopieren in den Speicher nicht zugewiesenen Speicher. Sie müssen strlen(the_array[i].name)+1 zuweisen. Ähnlich für andere Elemente. Und selbst dann hast du das Problem, dass der Name in Knoten X kürzer sein kann als der Name in Knoten Y, den du hineinkopierst. Diese ganze Strategie ist zum Scheitern verurteilt.

Gibt es einen Grund, warum Sie die Knoten nicht einfach austauschen? Oder noch besser tun qsort(list, N, sizeof(DATA), DataTimestampCompare);

Answer 2

Ohne zu sehen, wie Sie die Zuordnung zu tun und das Array verwenden, wird es schwierig sein, zu beantworten, aber die meisten wahrscheinlich werden Sie nur für die Struktur Zuweisung Speicher und vergisst die Mitgliedszeiger. Sie müssen auch Speicher für sie reservieren, sonst erhalten Sie einen Seg-Fehler, wenn Sie versuchen, auf einige von ihnen zuzugreifen.

*the_array->name Wird ein Seg-Fehler verursacht, wenn Sie z. B. nur Speicher für "the_array" zuweisen. Und ich schätze, Ihr Sortieralgorithmus versucht, auf einige Attribute der Struktur zuzugreifen.

Answer 3

Ihr Code zum Austausch der Out-of-Order-Array-Element hat mehrere Probleme. Ihre Frage ist sowohl C markiert und C++ aber in C++ kann man einfach sagen:

// Exchange the elements 
if(n1 > n2) 
{ 
    std::swap(the_array[i], the_array[j]); 
} 

Sie müssen nur die structs tauschen oder die Zeiger sie enthalten. Ihr vorhandener Code weist nicht genügend Speicher für das (unnötige) Kopieren von Zeichenfolgen zu und hat schreckliche Speicherlecks.