Programming Fundamentals

How are you progressing with the assignment?

Do you have any questions? Have you learned anything that would be useful to share with the rest of the tutorial?

What does free do?

What is the input to free and how does it help it do what it needs to do?

What is a use after free error? Give an example.

Why are these one of the worst causes of bugs in C programs?

What is a memory leak? What does dcc --leak-check do?

In the following example, how much memory are we leaking? How do we stop it from leaking?

int i = 0;
struct node *head = NULL;
while (i < 10) {
    // `insert_first` is a function which malloc's a new node, 
    // inserts it at the head of the list, and
    // returns it.
    head = insert_first(i, head);
    i++;
}
free(head);

What is wrong with this code? How do we fix it so it malloc's a node?

struct node *new_node(int data) {
    struct node *new = malloc(sizeof(struct node *));
    new->data = data;
    new->next = NULL;

    return new;
}

Implement a function copy which returns a copy of a linked list.

copy should have this prototype.

struct node *copy(struct node *old_head);

copy should call malloc to create a new linked list of the same length and which contains the same data.

Implement a function list_append which creates a new list by appending the second list to the first.

list_append should have this prototype:

struct node *list_append(struct node *first_list, struct node *second_list);

Why do we need to make sure it is a new list? Why can't we just change the first list's final node's next pointer to the second list's head?

Implement a function identical that returns 1 if the contents of the two linked lists are identical (same length, same values in data fields) and otherwise returns 0.

identical should have this prototype:

int identical(struct node *first_list, struct node *second_list);

identical should not create (malloc) any new list elements.

Implement a function set_intersection which given two linked lists in strictly increasing order returns a new linked list containing a copy of the elements found in both lists.

set_intersection should have this prototype:

struct node *set_intersection(struct node *set1, struct node *set2);

The new linked list should also be in strictly increasing order. It should include only elements found in both lists.

set_intersection should call malloc to create the nodes of the new linked list.

Implement the functions add_movie() and print_genre() inside cinema.c:

1. add_movie(): This function should add a new struct movie node to the *movies linked list inside its corresponding struct genre node.
2. print_genre(): This function shoud print each movie associated with a given genre name. Each movie should be printed in the format: "TITLE, RATING/100 (LENGTH minutes)"

add_genre() is provided as an example. To help you visualise the structure of the cinema, a diagram has been provided below:

This program 'won't work'. What's wrong with it? Split off into groups and discuss why. Line numbers are included for reference.

This week's exercise has been simplified compared to previous weeks feedback

1  #include <stdio.h>
2  
3  struct node {
4      node next;
5      int value;
6  }
7
8  struct node *new_node(int data) {
9      struct node *new = malloc(sizeof(node *));
10     new->data = data;
11     return new;
12 }
13 
14 int main() {
15     struct node = new_node(1);
16     node->next = new_node(2);
17     node->next->next = new_node(3);
18
19     int i = 0;
20     while (node[i] != NULL) {
21         printf("%d\n", node[i].value);
22     }
23 }

#include <stdio.h>

struct node {
    node next;
    int value;
}

struct node *new_node(int data) {
    struct node *new = malloc(sizeof(node *));
    new->data = data;
    return new;
}

int main() {
    struct node head = new_node(1);
    node->next = new_node(2);
    node->next->next = new_node(3);

    int i = 0;
    while (node[i] != NULL) {
        printf("%d\n", node[i].value);
    }
}