Debug notes (Update: Valgrind: Conditional jump or move depends on uninitialized value(s))

Valgrind: Conditional jump or move depends on uninitialized value(s)

https://bytes.usc.edu/cs104/wiki/valgrind/bytes.usc.edu

The example given there is easy to understand, but I encountered a less obvious one when writing a function to add a node to a linked list:

Node* appendNode(Node* head, int v) {
   if (head == NULL) {
      return NULL;
   }

    Node* p = head;
    while (p->next != NULL) {
        p = p->next;
    }

    // bad style
    p->next = (Node *)malloc(sizeof(Node));
    p = p->next;
    p->data = v;
    p->next = NULL;

    return p;
}

Valgrind reports an error here because after allocating space for p->next, that space is not assigned (i.e. not initialized), and then p = p->next is executed, which effectively jumps to an uninitialized location.

It should be changed to:

Node *node = (Node *)malloc(sizeof(Node));
    node->data = v;
    node->next = NULL;
    p->next = node;

Same hashcode

public static int hashCode(int[] array) {
        int total = 0;
        for (int element : array) {
            total = total * 256;
            total = total + element;
        }
        return total;
    }

public static void main(String[] args) {
    int[] array1 = {80, 103, 142, 91, 160, 250, 7, 7, 7, 7};
    int[] array2 = {130, 105, 209, 7, 7, 7, 7};
    int hashCode1 = hashCode(array1);
    int hashCode2 = hashCode(array2);
    System.out.println("hashCode1: " + hashCode1);//117901063
    System.out.println("hashCode2: " + hashCode2);//117901063
    }

This hashCode() function produces the same hashCode; 256 = 2^8, and after multiplying several times it will overflow, so the hashCode depends on the last few elements of the array.