06-03. Notebook

This programme is a simple notebook.

We'll start with our boilerplate and because this programme will make use of an array, we'll tell C we need the collections library.

We'll start with the main programme.

The notebook will store 10 notes and as these are text, this will be a string identified as notebook, which is a new collection of strings, and there'll be 10 of them, hence the 10 in the square brackets.

Our notebook will just run continuously until the user closes the app.

So while true gives us an infinite loop, there are two things we want to do continually.

That's show the notebook.

So we'll write a subprogram for that in a moment, passing it the Notebook array and menu, which we will ask the user, what they want to do with the notebook.

As the notebook array is being used by all our subprograms, it would have been acceptable to use a global array instead of defining it in the main programme and then passing it to the subprograms.

But as we generally want to avoid global variables when we can, we'll do it this way.

You could easily make an argument for doing it in a different way, like many programmes.

Ok, let's define the subprogram to show the notebook on the screen.

We want to output the 10 notes in a user friendly way, so we'll use a for loop to iterate through each note.

For integer, index is zero loop.

When the index is less than the length of the notebook, that's how many notes are in it.

We could have said 10 here, but maybe we want to expand the notebook in the future index, which means add one to the index in each iteration.

Note that we didn't use for each here because we want to output the index or the number of the note and not just the note itself.

Output the index followed by a colon followed by the note stored in the notebook at that index, that's the Show Notebooks subprogram complete.

Next, let's define our menu.

Output the options to the user A for adding a note, C for clearing the notebook and O for ordering the notes in the notebook.

We'll put a colon on the screen as a prompt for the user and collect their choice in a variable identified as choice switch.

What part of the code executes next?

Depending on the user's choice in the case they entered A call a subprogram addnote to the notebook, then break out of the condition in the case they entered C call a subprogram, clear notes from the notebook and then break out of the condition in the case they Entered.

Call a subprogram, order notes with the notebook and break out of the condition.

Now we'll write a little helper function to collect a number of a note from the user and make sure it's a valid number.

Static int because it return a note number, an integer getnotenumber with no data passed in.

Initialise validinput to be false.

We haven't collected it yet.

Will initialise the Note number to be minus 1, so we have a variable to use later.

Then, while not valid input, we could also use while validinput does not equal true.

Here it's the same logic.

This is slightly easier to read.

Remember, an exclamation mark means not.

Notenumber becomes the integer of the input from the user.

Then if the note number is inside the range, that is if it's greater than or equal to 0 and it is less than 10, the input was valid, so valid input becomes true.

This is very simple validation.

It is just what is known as a range check.

It checks the input is in range.

It doesn't prevent an invalid character being entered.

We'll learn how to do that in the future.

Otherwise else output invalid input with a prompt to tell the user what was expected.

Return the note number entered.

Next, we'll define the AddNotesubprogram.

This takes the notebook as an array of strings as a parameter, the index becomes a number entered by the user and we'll call our getnotenumber function for that.

So creating a little helper function like this means that every time we want a number of a note from the user, we can call this function instead of duplicating code throughout the programme.

This is called creating a reusable programme component and is a key advantage of a sub programme.

Ask the user to enter the note and collect that in a string variable identified as note.

Now, to put the note into the notebook, we can say notebook, at the index becomes note.

Next, we'll write the subprogram to clear the notebook.

This is a dangerous thing for the user to do, as they will lose all their notes.

So a bit of verification from the user that this is actually what they want is a good idea.

We'll set their choice to be an empty string and then use a while loop to repeatedly ask them to enter Y or N until they give us one of those two inputs.

So this little bit of code prevents the programme continuing until the user enters either Y or N.

We could also have done this as a little helper function too.

If they entered Y, then we loop through all the indexes of our notebook with a for loop and assign the element of the notebook at that index to be empty.

We could also have done this with a foreach approach too.

We don't need to say what to do if the user entered n because we don't want anything to happen.

Finally, we write our order notes subprogram.

This uses a method array sort to sort the contents automatically.

This is an example of abstraction.

We don't know how the computer does the sorting, but we don't need to know either.

For those of you who are interested, it actually uses what is known as an intro sort of selecting the best algorithm for the data.

An insertion sort for our small array.

But it could have used a quicksort or a heap sort for larger data sets.

Okay, let's give the programme a run.

We can see it outputs the indexes 0 to 9 with blank notes.

We can add a note by entering a the note number five and the note we want to store.

We can see this has been added to index five.

We can continue adding more notes and test the functionality of the other options.