Part 1: get, put, del 4.1 Dictionary library (dict.c) In Part 1, you will have to implement the bulk of the dictionary library in dict.c. 4.1.1 Dictionary structure You will start by giving a definition for your main structure struct dict. (You cannot change the name of this type, it is however aliased (typedef’d) in dict.h as dict_t to avoid having to type struct each time.) For instance, you may want to have a dictionary implemented as a linked list; in that case, you can store the head of that list and its length in your structure: struct dict { struct dict_list* head; size_t size; }; The first field is a pointer (*) to the head of the list, that is, its memory address. The struct dict_list itself contains the key, the value, and the address of the next element in the list: struct dict_list { char* key; char* val; struct dict_list* next; }; The end of the list is signaled by having next be NULL // Forward declaration. void execute_command (const char* cmd); int main (int argc, char** argv) { ... } void execute_command (const char* cmd) { // Actual code } This is in fact what happens with C header files: they only contain the declarations of functions, but the code appears in other files. These forward declarations are further resolved during linking (Ch. 7).
Part 1: get, put, del
4.1 Dictionary library (dict.c)
In Part 1, you will have to implement the bulk of the dictionary library in dict.c.
4.1.1 Dictionary structure
You will start by giving a definition for your main structure struct dict. (You cannot change the name of this type, it is however aliased (typedef’d) in dict.h as dict_t to avoid having to type struct each time.)
For instance, you may want to have a dictionary implemented as a linked list; in that case, you can store the head of that list and its length in your structure:
The first field is a pointer (*) to the head of the list, that is, its memory address. The struct dict_list itself contains the key, the value, and the address of the next element in the list:
The end of the list is signaled by having next be NULL
This is in fact what happens with C header files: they only contain the declarations of functions, but the code appears in other files. These forward declarations are further resolved during linking (Ch. 7).
Note: I've already implemented dict_get and dict_create
4.1.4 dict_put
It is now time for:
This function stores the pair key / val in the dictionary dict, possibly erasing the previous value associated with key.
It should make private copies of key and val as required. This means that the function cannot use, for instance, my_element->val = val. To make a copy of a string s, one could:
- allocate strlen(s) + 1 bytes using malloc(3) (strlen(3) returns the length of a string, not counting the end-of-string marker)
- go through the strlen(s) + 1 bytes of s and copy each byte, using either a loop or the function memcpy(3)
Again, the standard library provides a function for this: strdup(3)—remember that since its return value was malloc’d, it needs to be free’d.
The function works as follows:
- If key is found in dict, then the associated value should be freed and replaced by a copy of val.
- If key is not found in dict, then a new element is added to the list; that element’s key is a copy of key and its value is a copy of val.
4.1.5 dict_del
Finally, you should implement:
This function goes through dict searching for key, if it finds it, it should delete the corresponding key/value pair. The memory allocated for the element and its key/value pair should be free’d. If the key does not exist, this function does nothing.
4.2 User interface (main.c)
The main function will contain the main loop of your program and should behave like this:
- Create an empty dictionary
- Print "> " on the standard output (this is important).
- Read the command from the user; the first three characters are the command name, then a space, then the arguments, and a newline character \n.
- If the command is unknown, exit.
- If end-of-file was read (EOF), destroy the dictionary and exit.
- Otherwise, execute the corresponding command and go back to 2.
To read from the standard input, you will be using the stream reading functions from the standard library, with stream being stdin, a variable defined in <stdio.h>:
- int fgetc(FILE* stream): read one character of the given stream. This returns the constant EOF on end of file.
- char* fgets (char* s, int size, FILE* stream): read in at most one less than size chars from stream and stores them into the buffer pointed to by s. Reading stops after an EOF or a newline. If a newline is read, it is stored into the buffer. A terminating null byte (\0) is stored after the last character.
The function fgets is a bit tricky to work with when you want to read a whole line. Indeed, if the line is very long, fgets needs to be called multiple times. For this reason I will show you how to implement a robust “readline” function.
To write to the standard output, you will be using printf(3).
4.2.1 Commands
The three commands to be implemented in this part are:
- get KEY: print the value associated with KEY followed by a newline \n. If no such value exists, a blank line is printed.
- put KEY:VALUE: store the pair KEY / VALUE. Note that both KEY and VALUE can be arbitrary strings, with the only guarantee being that KEY does not contain a colon. Additionally, these strings don’t contain a newline \n. Nothing is printed in return.
- del KEY: delete the pair associated with KEY, if it exists. Nothing is printed in return, even if the key does not exist in the dictionary.
Trending now
This is a popular solution!
Step by step
Solved in 4 steps with 3 images
