Bedingter Sprung oder Bewegung hängt von nicht initialisierten Werten ab [closed]

ich zerbreche mir seit stunden den kopf über folgendes problem: ich habe 2 funktionen eingefügt obwohl es noch viel mehr gibt. Ich führe Valgrind in meinem Programm aus und erhalte 32 ähnliche Fehler:

==4214== 6 errors in context 8 of 10:
==4214== Conditional jump or move depends on uninitialised value(s)
==4214==    at 0x40088F: getNextFreeCell (in /a/fr-01/vol/home/stud/ashers03/c/ex4/test)
==4214==    by 0x400C7A: InsertObject (in /a/fr-01/vol/home/stud/ashers03/c/ex4/test)
==4214==    by 0x401137: main (in /a/fr-01/vol/home/stud/ashers03/c/ex4/test)  

Ich bekomme mehr Fehler bei anderen Funktionen, aber es ist derselbe Fehler. Ich kann nicht verstehen, warum es nicht initialisiert ist. Vielen Dank an alle für Ihre Hilfe.

das ist die Hauptfunktion:

int main(int argc, char* argv[]) {
     size_t tableSize = (size_t)atoi(*(argv+1));
     TableP table = CreateTable(tableSize,IntFcn, IntPrint,IntCompare);
     int i;
     for (i=FIRST; i<=LAST; i++) {
         int *key = (int*)malloc(sizeof(int));
         *key = i;

         ObjectP obj = CreateObject(key);
         InsertObject(table,obj);
     }
     PrintTable(table);
     FreeTable(table);
     return 0;
}

Diese Defs befinden sich in einer Header-Datei:

typedef struct Object* ObjectP;
typedef struct Table* TableP;
typedef const struct Table* ConstTableP;
typedef enum {FALSE, TRUE} Boolean;

Dieser Code befindet sich in einer anderen Datei:

typedef struct Table {
    ObjectP* _table;
    int _firstTableSize;
    int _currentTableSize;
    int _increaseFactor;
    HashFcn _hfun;
    PrintFcn _pfun;
    ComparisonFcn _fcomp;
} Table;

typedef struct Object {

     ObjectP _next;
     void* _key;
     int _numInChain;
} Object;

Diese Funktion fügt einen Schlüssel in eine Hashtabelle ein. Wenn 3 Schlüssel bereits in der Zelle verkettet sind, wird die Größe der Tabelle verdoppelt und ich mache einige andere Dinge in doubleTable () …

Boolean InsertObject(TableP table, ObjectP object) {

    int index=table->_increaseFactor*table->_hfun(object->_key,table->_firstTableSize);

    if (table->_table[index] != NULL) {
        if (table->_table[index]->_numInChain == MAX_CHAIN) { //search for next cell
            int nextFreeCell = getNextFreeCell(table,index+1);
            if (nextFreeCell == FAILED) { //double table size
                if(doubleTable(table)) {
                InsertObject(table,object);
                return TRUE;
            }
            else {
                ReportError(MEM_OUT);
                return FALSE;
            }
        }
        else {
            table->_table[nextFreeCell] = chainObject(table->_table[nextFreeCell],object);
            return TRUE;
        }
    }
    else { //place object in chain:
        table->_table[index] = chainObject(table->_table[index],object);
        return TRUE;
    }
}
else { //empty cell, place object
     table->_table[index] = chainObject(table->_table[index],object);
     return TRUE;
}
}

static int getNextFreeCell(TableP table, int index) {

    int tableSize = table->_currentTableSize;
    while ( (index < tableSize) && (index % table->_increaseFactor != 0) ) {
         if (table->_table[index] == NULL || table->_table[index]->_numInChain < MAX_CHAIN) {
         return index;
         }
    index++;
    }
    return FAILED;
}

BEARBEITEN:

Ich habe Valgrind ausgeführt, wie Sie gesagt haben, und ich habe Folgendes erhalten:

==4563== Conditional jump or move depends on uninitialised value(s)
==4563==    at 0x40088F: getNextFreeCell (GenericHashTable.c:75)
==4563==    by 0x400C7A: InsertObject (GenericHashTable.c:222)
==4563==    by 0x401137: main (HashIntMain.c:34)
==4563==  Uninitialised value was created by a heap allocation
==4563==    at 0x4C241A7: malloc (vg_replace_malloc.c:195)
==4563==    by 0x4007AF: allocateArray (GenericHashTable.c:41)
==4563==    by 0x400924: doubleTable (GenericHashTable.c:90)
==4563==    by 0x400C8F: InsertObject (GenericHashTable.c:225)
==4563==    by 0x401137: main (HashIntMain.c:34)

Ich habe diese Methode:

static ObjectP* allocateArray(int tableSize) {

    objectP* arr = (ObjectP*)malloc(tableSize * sizeof(ObjectP));
        return arr;
}

Dadurch wird ein Array von Zeigern erstellt, die ich nie initialisiert habe. könnte das das problem sein? und wie sollte ich ein Zeigerarray initialisieren? auf NULL?

Sie müssen Valgrind mit ausführen --track-origins=yes Option, um die Ursprünge von undefinierten Werten zu finden.

Das Problem war, dass ich das Pointers-Array nicht initialisiert habe, als ich es erstellt habe.

Es scheint mir, dass Sie Ihr Programm nicht mit einem Debugging-Flag kompiliert haben (-g für gcc). Wenn Sie dann valgrind mit allen Optionen ausführen, sollte es Ihnen genau sagen, welche Variablen das Problem verursachen.

Wo initialisiert man table->_table? Überprüfen Sie, ob Sie es richtig initialisieren, nehme ich an, CreateTable(). Bitte posten Sie den Code für diese Funktion, wenn Ihnen nichts Offensichtliches auffällt.

Einfach – einfach laufen

valgrind --tool=memcheck --track-origins=yes <program_path>

…herausfinden.