[Anfänger]Hilfe bei valgrind



  • Kann gelöscht werden


  • Mod

    Hallo, Willkommen im Forum,

    deine Fehlermeldung bezieht sich offenbar auf Zeile 40 deiner main-Funktion. Die du nicht zeigst. Bitte poste genau den Code, den du benutzt hast, um den Fehler zu erzeugen. Vollständig. Aber idealerweise versuchst du vorher noch den Code möglichst zu minimieren und den Fehler einzugrenzen, siehe:
    http://www.c-plusplus.net/forum/304133
    Dein Code ist sehr lang, das schreckt Leser ab. Da lässt sich bestimmt sehr viel reduzieren. Vielleicht findest du den Fehler dabei schon selber.

    Compiliere mit Debugsymbolen (Machst du wahrscheinlich schon. Falls nicht: Beim GCC zum Beispiel mit Option -g, bei vielen anderen Compilern ebenfalls). Bei valgrind kannst du auch noch die Option --track-origins=yes angeben, wodurch du noch etwas mehr Information zu dieser Art Fehler erhältst. Wird dadurch aber sehr langsam in der Ausführung, daher diese Option lieber nur benutzen, wenn man tatsächlich diese Art Fehler hat.

    Dein Code hat anscheinend die Syntaxhervorhebung des Forums verwirrt. Ich weiß nicht warum. Hier ist er noch einmal mit Hervorhebungen. Mir fällt auf, dass die Einrückung sehr merkwürdig ist. Wenn du Code postest, dann bitte mit einem einheitlichen, lesbaren Einrückungsstil.

    int add(char* pfad, char* ziel, char* zieldatei){
    
        FILE *store, *structure, *datei;
        char *zeiger1, *zeiger2, *auslesen, *end, *test;    //Hilfszeiger zum Auslesen des VFS
        uint64_t bsize, bcounter, bbelegt, bfrei, anzahl,merken;
        uint64_t i,j;
        uint64_t *barray;
    
        datei = fopen(ziel, "r");
                if(datei == NULL){
                    return 13;
                }
    
        char *save;
        save = (char*) malloc(strlen(pfad)+1+10);
        if(save == NULL){
            return 66;
        }
    
        strcpy(save, pfad);
    
    // Dateiexistenz pruefen
        store = fopen(strcat(pfad, ".store"),"r");
        if(store == NULL){
            fclose(datei);
            free(save);
            return 2;
        }
        structure = fopen(strcat(save, ".structure"), "r");
        if(structure == NULL){
            fclose(store);
            fclose(datei);
            free(save);
            return 2;
        }
    
        fclose(store);
    
        //Dateinen oeffnen zum Bearbeiten
        store = fopen(pfad,"r+w");
        if(store == NULL){
            free(save);
            return 2;
        }
    
        //VFS auslesen
            //Groeße von Stucture ermitteln
            uint64_t sizeStructure;
                fseek( structure, 0, SEEK_END );    //ans Ende der Datei gehen
                sizeStructure = ftell( structure );
                fseek(structure, 0, SEEK_SET); //wieder an den Dateianfang gehen
    
            auslesen = (char*) malloc(sizeStructure+1);
                if(auslesen == NULL){
                    fclose(store);
                    fclose(structure);
                    fclose(datei);
                    free(save);
                    return 66;     
                }
    
            //erste Zeile auslesen
            fgets(auslesen, sizeStructure, structure);
                zeiger1 = strtok(auslesen, "\n");
                zeiger2 = strtok(zeiger1, " ");
                bsize = strtod(zeiger2, &end);
                zeiger2 = strtok(NULL, " ");
                bcounter = strtod(zeiger2, &end);
    
            //zweite Zeile auslesen
            fgets(auslesen, sizeStructure, structure);
                zeiger1 = strtok(auslesen, "\n");
                zeiger2 = strtok(zeiger1, " ");
                bfrei = strtod(zeiger2, &end);
                zeiger2 = strtok(NULL, " ");
                bbelegt = strtod(zeiger2, &end);
                zeiger2 = strtok(NULL, " ");
                anzahl = strtod(zeiger2, &end);
    
                //Groeße der Zieldatei ermitteln
                uint64_t sizeZiel;
                    fseek( datei, 0, SEEK_END );    //ans Ende der Datei gehen
                    sizeZiel = ftell( datei );
                    fseek( datei, 0, SEEK_SET );//wieder aus den Anfang setzten
    
                //pruefen, ob genuegend Speicher in store fuer die Zieldatei vorhanden ist
                if(bsize*bfrei < sizeZiel){
                    fclose(store);
                    fclose(structure);
                    fclose(datei);
                    free(save);
                    free(auslesen);
                    return 12;
                }
    
            //dritte Zeile auslesen
            fgets(auslesen, sizeStructure, structure);
            barray = (uint64_t*) malloc(bfrei*sizeof(uint64_t));
            if(barray == NULL){
                    fclose(store);
                    fclose(structure);
                    fclose(datei);
                    free(save);
                    free(auslesen);
                return 66;
            }
            //Array mit Werten fuellen
                zeiger1 = strtok(auslesen, "\n");
                zeiger2 = strtok(zeiger1, ",");
                barray[0] = strtod(zeiger2, &end);
    
                for(i = 1; i < bfrei; i++){
                    zeiger2 = strtok(NULL, ",");
                    barray[i] = strtod(zeiger2, &end);
                }
    
            // restelichen Zeilen pruefen, ob der Dateiname schon im VFS vorhanden ist
                if(anzahl > 0){
                    for(i = 0; i < anzahl; i++){
                        fgets(auslesen, sizeStructure, structure);
                        zeiger1 = strtok(auslesen, "\n");
                        zeiger2 = strtok(zeiger1, ",");
                        if(zeiger2 == NULL){
                                printf("hier\n");
                                }
                        if(strcmp(zeiger2, zieldatei) == 0){
                            fclose(store);
                            fclose(structure);
                            fclose(datei);
                            free(save);
                            free(auslesen);
                            free(barray);
                            return 11;
                        }
                    }
                }
    
                test = (char*) malloc(sizeZiel+1);
                if(test == NULL){
                    fclose(store);
                    fclose(structure);
                    fclose(datei);
                    free(save);
                    free(auslesen);
                    free(barray);
                    return 66;     
                }
                fread(test, sizeof(char), sizeZiel,datei);
                merken = 0;
                //Datei in store schreiben
                    for(i = 0; i < sizeZiel; i++){
                        if((i%bsize) == 0){
                            fseek(store, barray[merken]*bsize, SEEK_SET);
                            merken++;
                            bfrei--;
                            bbelegt++;
                    }
                        putc(test[i],store);
                    }
    
                if(anzahl > 0){
                        fseek(structure, 0 , SEEK_SET);
                        fread(auslesen, sizeof(char), sizeStructure,structure);
                    }
    
                    fclose(structure);
    
                    structure = fopen(save,"w");
                        if(structure == NULL){
                            fclose(store);
                            free(barray);
                            free(auslesen);
                            fclose(datei);
                            free(save);
                            free(test);
                            return 2;
                        }
    
                //Blockgroeße und Blockanzahl speichern
                    fprintf(structure, "%" PRIu64 " %" PRIu64 "\n", bsize,bcounter);
                //Anzahl der freien Bloecke und der belegten Bloecke
                    fprintf(structure, "%" PRIu64 " %" PRIu64 " %" PRIu64 "\n",bfrei,bbelegt, anzahl+1);
    
                    //freie Bloecke merken
                    for(i = merken; i < bfrei+merken; i++){
                        fprintf(structure,"%" PRIu64 ",", barray[i]);
                    }
                    fprintf(structure,"\n");
    
                    if(anzahl > 0){
                        zeiger1 = strtok(auslesen,"\n");
                        zeiger1 = strtok(NULL,"\n");
                        zeiger1 = strtok(NULL,"\n");
                        zeiger1 = strtok(NULL,"\n");
                        fprintf(structure, zeiger1);
                        fprintf(structure,"\n");
                        if(anzahl > 1){
                            for(i = 1; i < anzahl ; i++){
                                zeiger1 = strtok(NULL,"\n");
                                fprintf(structure, zeiger1);
                                fprintf(structure,"\n");
                            }
                        }
                    }
    
                    fprintf(structure, zieldatei);
                    fprintf(structure, ",%" PRIu64 ",%" PRIu64, sizeZiel, merken);
                    for(i = 0; i < merken; i++){
                        fprintf(structure,",%" PRIu64, barray[i]);
                    }
    
                            fclose(store);
                            fclose(structure);
                            fclose(datei);
                            free(save);
                            free(auslesen);
                            free(barray);
                            free(test);
                            return 0;
    }
    

Anmelden zum Antworten