DEV Community: Gilad Ri

Recursion

Gilad Ri — Mon, 26 Aug 2019 17:11:08 +0000

If you google "recursion", Google asks you: "Do you mean: recursion".

That's one silly joke, but it can tell us how much this topic is important that Google chose to add a built-in joke inside their search engine for it.

Anyways, although Recursion is considered one of the most hated subjects by students, it is not really such a difficult subject in practice and a very useful one.

Recursion is just a way for creating a loop by a function that calls to itself. That's all. Let's see an example. First, there is a code which uses a for loop:

#include <stdio.h>

void printHello(int times) {
    for (int i = times; i > 0; i--) {
        printf("Hello\n");
    }
}

int main() {
    printHello(3);
    // Success
    return 0;
}

As you've probably figured out, the above code just prints "Hello" exactly 3 times. Now, let's see the same code, but with recursion:

#include <stdio.h>

void printHello(int times) {
    if (times <= 0) { // You can write instead: if (!times)
        return;
    }
    printf("Hello\n");
    printHello(--times);
}

int main() {
    printHello(3);
    // Success
    return 0;
}

This code also prints:

Hello
Hello
Hello

"But... why?"

Because the main function calls printHello(3). This function has times==3 and therefore its prints and calls itself: printHello(2). Again, the condition is not met and the function prints and calls itself: printHello(1). And again: printHello(0). Now, finally, the condition is met and we return to printHello(1). This function also finishes its scope and we return to printHello(2). The same for this function and we return to printHello(3). After that, we return to main and the running of our code ends with exit code 0 (success).

"What, what what?!"

The following flowchart will explain everything:

As you can see, each printHello(n) calls to printHello(n-1) until we reach 0. Then, each printHello(k) finishes its run, and return to its caller - the function printHello(k+1). That's all!

Let's see another example. In this example, our application asks for an index from the user, and prints the Fibonacci number which has this index in the Fibonacci Sequence.

#include <stdio.h>

int fibonacci(int index){
    if (index == 0) {         // First stop condition
        return 0;
    } else if (index == 1) {  // Second stop condition
        return 1;
    } else {
        // The recursive call
        return (fibonacci(index - 1) + fibonacci(index - 2));
    }
}

int main() {
    int index;
    // Gets an index from the user
    printf("Enter the index\n");
    scanf("%d", &index);
    // Prints the number in the 
    printf("%d\n", fibonacci(index));
    // Success
    return 0;
}

The following flowchart explains what happens in this code for the index 4. Pay attention that each function has 2 recursive calls, and the first one is alway to the left:

In conclusion, each recursion function must have a stop condition and a recursive call (of course). If we don't have a stop condition, our recursive will be like an infinite loop - but in this case, our program will crash relatively fast, because its memory ends. Each function call creates new local variables and other things that the computer needs to save on its memory, and therefore, after a lot of recursive calls - our function may crash. Therefore, pay attention and always make sure there is a limit to your recursion.

Make sure you fully understand this subject - many interviewers like to give recursive questions in job interviews.

Always remember, it's much C-mpler than you thought!

Regards,
Gilad

Basic Sorting

Gilad Ri — Fri, 28 Jun 2019 10:35:32 +0000

Let's say we have the following code:

#include <stdio.h>
#include <limits.h>
#include <time.h>
#include <stdlib.h>

#define SIZE 10
#define SUCCESS 0
#define TRUE 1
#define FALSE 0

void swap(int* x, int* y) {
    *x += *y;
    *y = *x - *y;
    *x -= *y;
}

void printArray(int* arr, int size) {
    int i = 0;
    printf("%d", arr[0]);
    for (i = 1; i < size; i++) {
        printf(", %d", arr[i]);
    }
    printf("\n");
}

void buildRandomArray(int* arr, int size) {
    // Builds a random integers array which its elements are between 0 and 100
    for (int i = 0; i < size; i++) {
        arr[i] = rand() % 100;
    }
}

int main() {
    // Random seed
    srand(time(NULL));
    // Builds a random array
    int size = SIZE;
    int* arr = (int*)malloc(size * sizeof(int));
    buildRandomArray(arr, size);

    // TODO: Sort the array <-- INSERT THE FUNCTION CALL HERE

    // Prints the array
    printArray(arr, SIZE);
    // Success
    return SUCCESS;
}

which builds a random array of integers and then prints it. (Make sure you understand the code). However, we want to sort the array before it is printed. How can we do so?

We will see in this post 3 different basic algorithms that can perform the task:

Selection Sort

In each iteration i (starts from 0), the Selection Sort algorithm finds the minimum element and swaps it with the element which is in the i position of the array right now. The code:

void selectionSort(int* arr, int size) {
    int minValue, minIndex = 0;
    for (int i = 0; i < size; i++) {
        // Sets the minimum value to be the maximum int size at the beginning of each iteration
        minValue = INT_MAX;
        for (int j = i; j < size; j++) {
            if (arr[j] <= minValue) {
                // Saves the minimum value and its index
                minValue = arr[j];
                minIndex = j;
            }
        }
        // Swaps only if the indexes are different
        if (i != minIndex) {
            swap(&arr[i], &arr[minIndex]);
        }
    }
}

For example:

45, 87, 23, 11, 43, 23, 76, 28, 18, 7
7, 87, 23, 11, 43, 23, 76, 28, 18, 45
7, 11, 23, 87, 43, 23, 76, 28, 18, 45
7, 11, 18, 87, 43, 23, 76, 28, 23, 45
7, 11, 18, 23, 43, 23, 76, 28, 87, 45
7, 11, 18, 23, 23, 43, 76, 28, 87, 45
7, 11, 18, 23, 23, 28, 76, 43, 87, 45
7, 11, 18, 23, 23, 28, 43, 76, 87, 45
7, 11, 18, 23, 23, 28, 43, 45, 87, 76
7, 11, 18, 23, 23, 28, 43, 45, 76, 87
7, 11, 18, 23, 23, 28, 43, 45, 76, 87

As you can see, we first placed 7 at the beginning of the array, and then we placed 11 and then 23 and so on.

Insertion Sort

In each iteration i (starts from 0), the Insertion Sort choose the i'th element as a pivot and found its place. In this way, after two loops the array is sorted: the outer loop is for the selection of the pivot and the inner loop is for placing the chosen pivot at its location.

void insertionSort(int* arr, int size) {
    int pivot;
    for (int i = 1; i < size; i++) {
        // Prints the array in each iteration
        printArray(arr, size);
        // Chooses a pivot for this iteration
        pivot = arr[i];
        // Swaps until the pivot is bigger than the j'th element
        for (int j = i - 1; j >= 0; j--) {
            if (pivot > arr[j]) {
                break;
            }
            swap(&arr[j], &arr[j + 1]);
        }
    }
}

For example:

29, 49, 48, 21, 40, 17, 58, 61, 14, 60
29, 49, 48, 21, 40, 17, 58, 61, 14, 60
29, 48, 49, 21, 40, 17, 58, 61, 14, 60
21, 29, 48, 49, 40, 17, 58, 61, 14, 60
21, 29, 40, 48, 49, 17, 58, 61, 14, 60
17, 21, 29, 40, 48, 49, 58, 61, 14, 60
17, 21, 29, 40, 48, 49, 58, 61, 14, 60
17, 21, 29, 40, 48, 49, 58, 61, 14, 60
14, 17, 21, 29, 40, 48, 49, 58, 61, 60
14, 17, 21, 29, 40, 48, 49, 58, 60, 61

As you can see, the first and the second iteration in this example are trivial, 29 and 49 stayed in their places. But, the third and the fourth iteration are intersting because 48 found its place between 29 and 48 and than 21 found its place at the begining of the array and so on.

Bubble Sort

In each iteration, we just swap between two adjacent elements if they are in the wrong order. This way, because we have a loop inside a loop even if the minimum element is at the end of the array, the swapping will bring it to the beginning of the array.

void bubleSort(int* arr, int size) {
    int swapped;
    for (int i = 0; i < size; i++) {
        // Prints the array in each iteration
        printArray(arr, size);
        // Turn off the flag at the beginning of each iteration
        swapped = FALSE;
        for (int j = 0; j < size - 1; j++) {
            // Checks if the next element is bigger than the current one
            if (arr[j] > arr[j + 1]) {
                // Swaps between the two consecutive elements
                swap(&arr[j], &arr[j + 1]);
                // Turn on the flag
                swapped = TRUE;
            }
        }
        // Checks if there were any swaps in this iteration
        if (!swapped) {
            // No! the array is sorted - quits
            return;
        }
    }
}

For example:

52, 42, 91, 39, 10, 98, 68, 11, 50, 46
42, 52, 39, 10, 91, 68, 11, 50, 46, 98
42, 39, 10, 52, 68, 11, 50, 46, 91, 98
39, 10, 42, 52, 11, 50, 46, 68, 91, 98
10, 39, 42, 11, 50, 46, 52, 68, 91, 98
10, 39, 11, 42, 46, 50, 52, 68, 91, 98
10, 11, 39, 42, 46, 50, 52, 68, 91, 98
10, 11, 39, 42, 46, 50, 52, 68, 91, 98

As you can see, we swapped 52 with 42, and then 39 with 52 and then 10 with 52 and so on. Try to follow after this algorithm with a pen and a paper and make sure you fully understand it. Pay attention that because of the swapped flag we added to the basic algorithm, once the array is sorted - the algorithm stops. For example, if the array is sorted, the Buble Sort algorithm (with this flag) stops after one iteration - which is the best time for checking if the array is sorted. All the other algorithms above will fully run all of their iterations for nothing. That makes the Buble Sort algorithm the best algorithm if the array may be sorted with high probability.

Always remember, it's much C-mpler than you thought!

Regards,
Gilad

Memory Allocation & Dynamic Arrays

Gilad Ri — Thu, 27 Jun 2019 09:08:40 +0000

Let's begin with the solution to the challenge:

#include <stdio.h>

void swap(int * x, int * y) {
    *x += *y;     // x == 13
    *y = *x - *y; // y == 10
    *x -= *y;     // x == 3
}

int main() {
    int x = 10;
    int y = 3;
    swap(&x, &y);
    printf("x=%d, y=%d", x, y);
    // Success
    return 0;
}

Ok, now to our topic: Memory Allocation, and how to initialize dynamic arrays.

As you remember, in the previous post we learned about memory and pointers. In this post, we will go deeper into the subject of memory. The memory of our computer is divided into two types: Stack and Heap.

Stack

We already familiar with the Stack: any time we have created a variable or a function so far, we allocated it on the Stack. To be more accurate: on the Stack we can allocate things only if we know exactly how much space we will need to allocate before the compilation process. That means that the Stack is used only for static memory allocation. (remember what we said about Static Arrays?)

Spaces allocated on the Stack are freed ("cleared") when their block scope is ended. For example, function variables are deleted when the function ended - automatically. (To be more accurate, they are not actually deleted, but "the computer" just let our program to overwrite their spaces - "the computer stops keeping their positions and therefore future memory allocations can run over them").

Heap

The new memory type we will talk about it in this post. We can allocate spaces (for variables) on the Heap during run-time of any size we want, (as long that there is enough space left). Moreover, we can reallocate a space or free ("clear") a space at any time we want. Pay attention that this type of memory is not freed unless we make it do so. It's a good thing if we want to save a value of something for a long time (longer than a function scope, for example), but also a bad thing because we must remember to free these spaces, or we will be in trouble. At some point, we may run out of memory and our program will crash. In our case, it does not sound so threatening - "Oh no, our silly program may crash" - but when it comes to a program of a big bank, for example, which every second of downtime can cost the bank millions of dollars, it is really scary! So, please remember to free any space you allocate on the Heap, at the right time - neither too early nor too late.

Memory allocation

Ok, so let's see how we can allocate a variable on the Heap:

#include <malloc.h>

int * pointer = (int *) malloc(sizeof(int));

Or, in general:

#include <malloc.h>

[type] [pointer_name] = ([type]) malloc([number_of_bytes_we_want]);

Let's divide this into parts:
In the first part, [type] [pointer_name] we just initialize a pointer which points at the space we will allocate on the Heap. The next part, the part which after the '=' is the interesting part. At first, we just convert the type of what the malloc function outputs. In C, you can convert a type of variable if you put a type in brackets before it. For example:

int x = 10;
double y = (double) x;

The malloc function's output type is (void *). This type is like a joker type, you can convert it to whatever type you want. Therefore, because we wanted it to match the pointer we converted it to (int *). In other words, we just need to convert the output type so it will match the pointer type.

And the final part, the malloc input. The malloc function receives a size and returns a pointer to allocated space of this size. We can choose whatever size we want, but usually, we use the sizeof function which gets a type of variable (int, for example) and returns its size in bytes. Normally, the size of int is 4 bytes, but this may change as a result of the advancement of technology and may also vary between operating systems, compilers and various processors, and so on. Therefore, we prefer using sizeof, and in this way, we have no problem at all getting the size of a variable type.

Dynamic Arrays

Finally, let's see how we can initialize a dynamic array using the malloc function:

#include <stdio.h>
#include <malloc.h>

#define SIZE 10

int main() {
    // Allocates an array of size SIZE
    int * grades = (int *) malloc(SIZE * sizeof(int));
    // Frees the array
    free(grades);
    // Success
    return 0;
}

As you can see, we have just multiplied the size of the variable type in the number of elements we want for our array.

The free function in the example above is how we can free our allocated memory. We just have to send it the pointer to our memory allocation as input.

To summarize this post, let's rewrite the example from the Static Arrays post (an application which can save student's grades and calculates the average) in a better way:

#include <stdio.h>
#include <malloc.h>

#define START_SIZE 2

void getGrades(int * grades, int * index, int * size) {
    int grade;
    printf("Insert the grades. In order to stop, please enter -1\n");
    do {
        printf("Grade #%d: ", *index + 1);
        scanf("%d", &grade);
        // Checks the grade
        if (grade >= 0 && grade <= 100) {
            // Checks if there is enough space in the array
            if (*index >= *size) {
                // There isn't, doubles the size of the array
                *size *= 2;
                realloc(grades, *size * sizeof(int));
                printf("Re-allocated the array to size: %d\n", *size);
            }
            // Inserts the grade into the array and increases the index by 1
            grades[*index] = grade;
            *index += 1;
        } else if (grade == -1) {
            // Stops
            printf("Thank you!\n");
        } else {
            // Error
            printf("Invalid grade, please try again...\n");
        }
    } while (grade != -1);
}

double calcAverage(int * grades, int index) {
    int i;
    int sum = 0;
    for (i = 0; i < index; i++) {
        sum += grades[i];
    }
    return (double) sum / (double) index;
}

int main() {
    int index = 0;
    int size = START_SIZE;
    // Allocates an array of size 'START_SIZE'
    int * grades = (int *) malloc(size * sizeof(int));
    // Gets the grades from the user as input
    getGrades(grades, &index, &size);
    // Prints the average
    printf("Your average is: %.2f\n", calcAverage(grades, index));
    // Frees the array
    free(grades);
    // Success
    return 0;
}

Console example:

Insert the grades. In order to stop, please enter -1
Grade #1: 100
Grade #2: 90
Grade #3: 95
Re-allocated the array to size: 4
Grade #4: 100
Grade #5: 87
Re-allocated the array to size: 8
Grade #6: 94
Grade #7: 93
Grade #8: 86
Grade #9: 99
Re-allocated the array to size: 16
Grade #10: 88
Grade #11: -1
Thank you!
Your average is: 93.20

As you can see, we used the realloc function which gets a pointer and a new size and re-allocates a space of the new size we want (and copies all the values from the old space). If you want to know why we double the size each time and don't just add some more space (size + 10, for example) you can read this short post of Nicholas Nethercote from 2014.

Always remember, it's much C-mpler than you thought!

Regards,
Gilad

Memory Addresses & Pointers

Gilad Ri — Mon, 24 Jun 2019 16:19:23 +0000

Welcome to Memory street! In Memory street, there are 2^64 plots. Each plot has an address, starting from 0 to 2^64 - 1 (yeah, that's a long street, especially because all the plots are on the same side of the road). In some plots, there is a house, in others not. Some houses are built on several plots and others are built on only one. For example, the Charles's house (we will call it ch from now on) is built on only one plot, and there is only one person who lives in it. The address of this house is 100, Memory street.

If we translate this information to our language, we can say that the variable ch contains 1 as its value, and its address is 100. Also, its size is one Byte. A byte is the smallest unit of memory that can be accessed (like one plot in our theoretical street) and it contains 8 bits. A bit is the smallest unit of memory, which can be only 0 or 1.

Let's look now on the Interno's house (ih__ from now on), which contains 4 people and is built on 4 plots: 200, 201, 202 and 203. What means that its address is 200. Right next to this house, there is the Floaters' house (fh__ from now on), which its address is 204 and is also built on 4 plots. The number of people that live in this house is 10.5.

What can we say about all the houses we mentioned above? We can say that the addresses of the houses are 100, 200, and 204, respectively. Moreover, we can say that their values are 1, 4, and 10.5, respectively. We already know how to represent the values in our code:

char ch = '1';
int ih = 4;
float fh = 10.5;

But how do we represent the addresses?

Remember the '&' sign in the scanf function? That's the answer. If you put this operator before a variable, you get its address instead of its value. For example:

char * chAddress = &ch; // 100 in our example
int * ihAddress = &ih; // 200 in our example
float * fh fhAddress = &fh; // 204 in our example

Pay attention, the '*' here is not the multiplication operator but it's how we declare a pointer. A pointer is a variable in which we save addresses. That means that the value of a pointer is a memory address. A pointer also has its own address, what means we can also points to it with another pointer. If we want to declare a pointer we write:

<variable_type> * <pointer_name>;

For example:

int * pointer; // can  point at an integer variable

If we want to get the value of the variable the pointer points at, we can use again the asterisk ('*') operator this way:

#include <stdio.h>

int x = 10;
int * pointer = &x; // pointer now points at x
printf("The value of the variable which the pointer points at is: %d", *pointer); // we put '*' before a pointer in order to get the value of the variable/address it points at

In other words, if we want to declare a pointer we add a '*' after the type, and if we want to get the value of the variable/address the pointer points at, we also add '*' before the pointer name. It may be a little confusing, but you will get used to it soon.

"Why do we need pointers?" you probably ask. One answer is that we want to pass the addresses of variables to functions, and not their values. In other words, we want to tell the function where it can find the original box and gets what it contains, to prevent it from the need to create a new box in which it will only copy the value of the original box. For example, as we mentioned above, the scanf function:

#include <stdio.h>

int x;
printf("Enter a number:\n");
scanf("%d", &x);

In the example above, the scanf function gets the address of x and the reason is clear: the scanf function doesn't need the value of x, (to be more accurate: the value of x is "garbage" because we have never initialize it before), but it needs the address of x in order to know where to put the input from the user. The scanf function gets an address of a box and fills it with the input!

This passing variables method is called by reference (instead of by value).

Let's observe the next example:

#include <stdio.h>

void swapByValue(int x, int y) {
    int temp = x;
    x = y;
    y = temp;
}

void swapByReference(int * x, int * y) {
    int temp = *x;
    *x = *y;
    *y = temp;
}

int main() {
    // Initializes two variables
    int x = 5;
    int y = 3;
    printf("x=%d, y=%d\n", x, y);
    // Runs the first function and prints the values of x and y
    swapByValue(x, y);
    printf("x=%d, y=%d\n", x, y);
    // Runs the second function and prints the values of x and y
    swapByReference(&x, &y);
    printf("x=%d, y=%d\n", x, y);
    // Success
    return 0;
}

The output of the code in the example above is:

x=5, y=3
x=5, y=3
x=3, y=5

Why? The first printf output is trivial, it's just how we initialize our variables in main. The second output should also be trivial to the wise reader because actually the swapByValue function does nothing! This function creates two new variables, x and y which are completely different from the main's variables x and y ("other boxes"), but have the same values. What means that the swap happens, but on irrelevant variables that no longer exist at the end of the function (we will learn about scopes in the future). The last output is the output we want. The variables really swapped their values in the right scope (the code block of main). That's because the swapByReference function also creates two new variables, but this time the values of the variables are not just a copy of the values of the main_'s variables. The values of the new variables are the addresses of the main's variable, and therefore, the swap operation occurs on the main's variables! (Just as was the intention).

That's all for this post. This is a lot for one time, I know. Make sure you fully understand what we said before you continue to the next post, which is about Memory Allocation and Dynamic Arrays.

A nice challenge, which appears frequently in job interviews: can you write a swap function that doesn't initialize a new variable? (temp, in our case.)

Always remember, it's much C-mpler than you thought!

Regards,
Gilad

Practice #2

Gilad Ri — Thu, 20 Jun 2019 03:34:12 +0000

Some nice tricks you all should know:

// #1 - the modulo operator (just a reminder):
int x = 125;
int y = 7;
int z = 5;
int divisionRemainder = x % y; // 6
divisionRemainder = x % z; // 0

// #2 - how to get the last digit of a number:
int number = 12345;
int lastDigit = number % 10; // 5

// #3 - how to omit the last digit of a number:
int number2 = 12345;
int shorterNumber = number2 / 10; // 1234

And now, let's write down some code!

Exercise #1

Write a program which gets a number from the user and prints the sum of its digits. For example:

Enter a number:
123
The sum of the digits of the number 123 is 6

(Hint: use the tricks above).

Exercise #2

Write a program which gets an integer number from the user and checks if it's a prime number. If it's a prime number the program prints "Prime", and otherwise it prints "Not prime". (Hint: A number is prime if it is not divisible by any smaller number). For example:

Enter a number:
9
Not prime

Enter a number:
3
Prime

Exercise #3

Write a program which gets from the user an integer and builds a pyramid of asterisks ('*') with a base of this size. For example:

Insert the base size of the pyramid:
5
  *   
 *** 
*****

Insert the base size of the pyramid:
6
  **  
 **** 
******

Insert the base size of the pyramid
25
            *
           ***
          *****
         *******
        *********
       ***********
      *************
     ***************
    *****************
   *******************
  *********************
 ***********************
*************************

Pay attention that if the base size is an even number, the head of the pyramid should be "**" and not '*'.

Good luck!

Always remember, it's much C-mpler than you thought!

Regards,
Gilad

Static Arrays

Gilad Ri — Wed, 19 Jun 2019 05:55:31 +0000

Let's say we have to write an application which can save student's grades and calculate his/her average. How can we do so?

We can initialize a variable for each test, and keep the grade as its value. But, how can we know how many tests our client will have? We are almost certainly not able to know this in advance We need a better solution.

The better solution (and probably the best one) is to use arrays. An array is a sequence of elements such that each element is like a variable. The array format is:

<array_type> <array_name> [<array_size>];

For example:

int grades[100];

As you can see, the size of our array is limited, but it still much bigger and easier to use than:

int grade1, grade2, grade3,...;

and enough for our case (a student probably doesn't have more than 100 tests in one year...)

But, not only that the size of an array we declare in this way is limited, but also we cannot change its size later. Moreover, its constant size has to be known before the compilation! (What means it must be a macro or a raw integer). Therefore, this type of array is called: "Static Array". We will learn in the future how we can create an array with a dynamic size that we can choose during the run-time of our application. Some examples in order to summary what we just said:

// GOOD
char word[40];

// BETTER
#define SIZE 40
char word[SIZE];

// ERROR! the value of 'n' isn't known before the compilation process!
int n = 40;
char word[n];

(Make sure you understand the last example before you continue to the next topic).

You can enter to the i'th element in an array using "[i]", for example:

int grades[100];
grades[0] = 100;
grades[1] = 95;

The index of the first element of an array is always 0 (except in MatLab, for some reason). What means that the last element of array of size n is n-1. For example, in array of size 3 we have 3 elemnts with the indexes: [0][1][2].

One of the biggest advantages of using array (over variables) is that you can iterate over an array:

#include <stdio.h>
#define SIZE 3

void main() {
    // Initializes an array of grades
    int grades[SIZE];
    grades[0] = 100;
    grades[1] = 95;
    grades[2] = 98;
    // Iterates over the array
    for (int i; i < SIZE; i++) {
        printf("The grade of the %d'th test is %d\n", i+1, grades[i]);
    }
}

This code outputs:

The grade of the 1'th test is 100
The grade of the 2'th test is 95
The grade of the 3'th test is 98

When we iterate over an array we have to make sure we don't try to access to an element with an index that is out of range of the array size. For example, if we have an array of size 10, the indexes that are bigger or equal to 10 are out of range. It is a little confusing sometimes, and therefore it's really important for you, as a programmer, to be alert and to make sure that any access to the array's element is to a valid index. The compiler cannot exceed this error in advance, which can cause a serious error during the run-time of your application. Be careful!

Always remember, it's much C-mpler than you thought!

Regards,
Gilad

Compilation & Precompilation

Gilad Ri — Tue, 18 Jun 2019 07:35:28 +0000

You, as a human being, probably know how to read in English (otherwise, you couldn't read this sentence). But, the computer doesn't. The computer's language is composed out of 0 and 1 sequences. This language is called: "Binary" and code in this language is called: "Binary code". Because none of us can read or write that language we have to have a translator, which is called "Compiler". The compiler translates our C code (we write in English) into assembly code. Assembly, in short, it's a low-level language which directly converted into executable machine code (binary code), which is a program the computer can run.

You can compile your code (translate your code to binary code) by pressing the Build button in your IDE, by running the next command in your Command Prompt (calling for the GNU Compiler directly):

gcc <your_code_file>.c

or by using a makefile.

Anyway, it is an important thing to know, but not really our topic right now. In this post I want you to finally understand what the meaning of:

#include <stdio.h>

or in the general format:

// If it is an external library
#include <some_external_library_name.h>

// If it is your library
#include "your_library_name.h"

Remember the functions "printf" and "scanf"? Didn't you wonder how can you use them without to write their code down in your file? You can do that because we include their code when we wrote the command from above. This command tells the compiler to add to your code the code which is in the library . "stdio" stands for "Standart Input & Output". The ".h" suffix is a suffix of a header file. A file in which we have to write all of our function declarations. This process of adding the code from the other library happens before it's fully translated into binary code, and therefore it is called a precompilation process.

There is one more thing you can tell the compiler to do before the compilation. You can define macros (constant placeholders) that will be replaced in constant values. (As a convention, we name the macros using upper case letters, and an underline as a separator). The format for this is:

#define SOME_MACRO_IN_UPPER_CASE value

For example:

#include <stdio.h>
#define SIZE 3

for (int i = 1 i <= SIZE; i++) {
    prinf("%d/%d", i, SIZE);
}

This code outputs:

1/3
2/3
3/3

Notice! don't put a semicolon (';') after the value of the macro! The value will be replaced with the semicolon, which might cause an error. For example:

#define THREE 3;

int x = THREE + 3;

will be translated to:

int x = 3; + 3;

It is a good thing to don't have any hard coded value (for example: 10, "hi", 'q', etc) in your code if it is not a macro. For example, if we have a lot of loops which all run 10 iterations, but we now want them all to run 100 iterations we have to replace all the 10 with 100, what can be frustrating and even dangerous, if we forget to replace in some places. Instead, we can declare a macro SIZE with the value 10 and use it in all of our loops, and then change it to 100 when we want.

For more information about compilation, you can find here in Alexandra Williams post.

Always remember, it's much C-mpler than you thought!

Regards,
Gilad

Loops

Gilad Ri — Sun, 16 Jun 2019 19:50:56 +0000

After you wrote down some code, it's time to continue learning. This post question is: "how do we cause to something to happen as many times as we want?".

As you may remember, we saw an example of using a switch-case block of code in order to make a thing to happen as many times as we choose, but it demanded of us to write a lot of code lines. For each time we have to write a case and what to do when we enter this case. We don't want that. We want it simpler and shorter.

for

Ok, so simply let's use the for keyword. The for format is:

for ([initialize_area]; [condition_area]; [step_area]) {
    // The code we want to run a lot of times
}

For example:

#include <stdio.h>

for (int i = 0; i < 5; i++) {
    printf("Hi %d\n", i);
}

Outputs:

Hi 0
Hi 1
Hi 2
Hi 3
Hi 4

Explanation: in the initialize_area we can create and initialize the loop variable/s once before we start the loop. We usually name the loop variables as 'i', or 'j', or 'k' etc. We can initialize more than one variable by using a comma-separated list of variables. In the next are, the condition_area check the value of our loop variable/s and continue to run the loop only if the condition is met. This check is done before each iteration. After each iteration, we arrive at the step_area, where we usually increase (or decrease) the value/s of our loop variable/s.

In our example above, we start by initializing a variable named i with value 0 and then check if 0 < 5. Because 0 is indeed lower than 5, we execute the code in the for block and print "Hi 0". At the end of the iteration, the value of i increases by 1 (because of the "++" operator). And then at the beginning of the next iteration, we check if 1 < 5 and go on and on a few more times - until i's value is 5, and 5 is not lower than 5, and then the code stops.

The last thing you have to understand is that each "area" is optional. For example:

#include <stdio.h>

for (;;) {
    prinf("Hi\n");
}

Is completely legal and means an infinite loop (a loop which runs forever), because the empty condition is always met. This empty for trick appears a lot in job interview questions. You should remember that.

Let's see another trick:

#include <stdio.h>

for (int i = 5; i--; ) {
    printf("Hi %d\n", i);
}

Can you guess what this code will print? (Run it on your computer after you put it in a main function and check. Remember what we learn about if and when a condition is met.)

while

Let's talk about another type of loop, a while loop. A while loop format is shorter:

while ([condition_area]) {
    // loop's code
}

For example:

#include <stdio.h>

int main() {
    char c;
    printf("Enter a characther. Enter a 'q' in order to stop\n");
    scanf(" %c", &c);
    while (c != 'q') {
        printf("Got the character: %c\n", c);
        printf("Enter a characther. Enter a 'q' in order to stop\n");
        scanf(" %c", &c);
    }
    return 0;
}

The code above gets a character from the user in each iteration, and prints it until the user enters the character 'q' (a common shortcut to "quit").

But notice we have 2 duplicated lines: we have the prinf which informs the user the program is waiting for input and the scanf which gets the input both before the while loop and inside the loop. Can we write it in a shorter way? Fortunately, in C we can (in some languages, like Python, we can't). The solution is called: do-while loop. For example:

#include <stdio.h>

int main() {
    char c;
    // Does first, checks later
    do {
        printf("Enter a characther. Enter a 'q' in order to stop\n");
        scanf(" %c", &c);
        printf("Got the character: %c\n", c);
    } while (c != 'q');
    return 0;
}

Notice that in both of the examples we put a space before the "%c". That's because sometimes the "Enter" also insert a character '\n' and the scanf sometimes takes it as input. A space before the "%c" solves this problem.

As you can see, this code is shorter and prettier. Use do-while in cases like this, just make sure you really don't need to check something before entering the loop.

In conclusion, we will use for loop when we need to loop over a range of numbers (can be a fixed range but can also be a dynamic range) - in other words, when you need to do something for 'n' times. On the other hand, We will use while loop (and do-while loop) when we need to do something while some condition is met (for example: while the option is not "quit").

Always remember, it's much C-mpler than you thought!

Regards,
Gilad

Practice #1

Gilad Ri — Fri, 14 Jun 2019 10:17:44 +0000

First, we should have an environment where we can write and run ours code. This type of program is called: Integrated Development Environment (IDE).

A list of Recommended IDEs:

Visual Studio (Microsoft)
Clion (JetBrains)
Eclipse

In this tutorial, we will use Eclipse. But feel free to use any other IDE that you want. It completely depends on personal preferences. I don't teach here how to download and install an IDE on purpose, because the version of the IDE and the download and install instructions may be a little different when you read this post. Just follow the instructions on the website of the IDE you chose and it will be totally fine. (If you need any help, just send me an email about that).

Ok, so let's begin.

Open the IDE and then create new Console App project. After that, just make sure that the source file you are writing in has a ".c" suffix and not a ".cpp" suffix (if not, just rename the file).

Now, write your first code:

#include <stdio.h>

int main()
{
    printf("Hello World!\n");
}

And run it! (Usually, you can do that by pressing F5. Again, just follow the instructions of the IDE you chose). In a console, (which will be opened), you have to see "Hello world!". If you saw that, congratz - you wrote and ran your first code!

Let's write some more complicated code now:

#include <stdio.h>

int getUserInput() {
    int input;
    // Gets input from the user
    printf("Insert a number:\n");
    scanf("%d", &input);
    return input;
}

void isDivideWithoutRemaining(int x, int y) {
    // The '%' operator performs the modulo operation
    if (x % y == 0) {
        int z = x / y;
        printf("%d number can be divided without a remainder by %d and the result is %d", x, y, z);
    } else {
        printf("%d cannot be divided without a remainder by %d", x, y);
    }
}

int main()
{
    // Gets two numbers from the user
    int x = getUserInput();
    int y = getUserInput();
    // Checks if the first number can be divided without a remainder by the second number
    isDivideWithoutRemaining(x, y);
    // Success
    return 0;
}

For example:

Insert a number:
10
Insert a number:
2
10 number can be divided without a remainder by 2 and the result is 5

Read here about modulo, if you needed (The '%' operator in C).

If you are using Visual Studio, for now, just write above your code the follows:

#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif

any time you uses scanf. If you want to understand why just Google it. It's really not important. You can see another solution here.

Write this code and make sure you understand what it does.

That's all for today, Have fun keep practicing some C by yourself! (There is no better way, trust me. If you need an idea, try to write a code which gets 2 numbers from the user and then prints all the mathematics operations. For example, if our variables are x and y it will print: x+y, x-y, x*y, x/y with appropriate explanations and comments).

Always remember, it's much C-mpler than you thought!

Regards,
Gilad

Functions

Gilad Ri — Thu, 13 Jun 2019 18:31:08 +0000

Awesome, we get to talk about functions, and after that, we can finally start to write a real code!

In my notebook, I made a comparison between functions and factories. So, let's talk about factories. (Yes the real world things with machines and workers).

Let's imagine we have a coffee machines factory. That means that our lovely and successful factory buy cables, some metal, and plastic (and perhaps some more raw materials) and from all that it produces coffee machines. A lot of them.

Ok, so in other words, our factory gets some raw materials (cables, metal, plastic) as input and produces the coffee machine as output.

A coffee machine is a factory too. Its input is a coffee capsule, water, and milk (optional) and its output is coffee. And coffee is input for a programmer, who produces some code and a lot of bugs as output.

In conclusion, we understand that we surrounded by factories/functions on a daily basis. A function is just a block of code (so yeah, it's bounded by curly brackets) which can get variables as inputs (in the example above: raw materials) and returns output according to its type.

Simply put, the function format is:

[output_type] [function_name]([inputs]) {
    // some code
}

The inputs format is:

([type1] [variable1], [type2] [variable2], ...)

The function of our coffee machines factory may be:

coffeeMachine makeCoffeeMachine(cable c, metal m, plastic p) {
    coffeeMachine newMachine;
    build(&newMachine, c, m, p);
    return newMachine;
}

And you can see that our function calls another function: "build". This function builds the new coffee machine somehow (we don't really care how) and then we can return it as output.

Good, now let's talk about real functions. The first function we will talk about is "main". The main function it is the most important function in your code. If you don't have one (and only one) "the computer" won't let you to run your code. The readers who were curious enough probably already saw some main functions before. Let's write one by ourselves:

#include <stdio.h>

void main() {
    int x = 10;
    int y = 5;
    if (x > y) {
        printf("The max number is %d\n", x);
    } else {
        // y is equal or higher than x
        printf("The max number is %d\n", y);
    }
}

As you can see, our function initializes two variables and then prints the sum of them. Let's build some more function, which helps the main function to be more compact:

#include <stdio.h>

/*
* The function gets 2 integers and returns the max value
*/
int max(int a, int b) {
    if (a > b) {
        return a;
    } else {
        // b is bigger or equal
        return b;
    }
}

/*
* The main function
*/
void main() {
    int x = 10;
    int y = 5;
    printf("The max number is %d\n", max(x,y));
}

As you can see, our new function max gets two integers as input and returns the max value as output. Notice that we can name the variables of each function in any way we want. The only thing that's important it's the order of the variables. In the example above, the "box" we named 'x' in main copied its value to another "box", which we named 'a' in max. Notice, it's not the same "box" (variable) but it's the same value. We will explain it more clearly when we get to talk about passing variables the functions By Reference.

As you can see the main function above gets no inputs, but it can get arguments this way (we will not dwell on this now):

int main(int argc, char **argv) {
    // code

    // Success
    return 0;
}

Moreover, our main doesn't return any output, and there its output type is void. In general, if we want to write a function which returns nothing we declare it with a void at the beginning. That means that void function can be very useful as a printing function or as a reading data from the user (or from a file) function. In the near future, we will learn how a function can also manipulate variables, without a need to return them (Hint: the By Reference thing again).

Notice that the main function in the last example above returns an integer as output. This is in accordance with the convention that if the main function finishes successfully it returns 0. It can also return something else according to what we decide. For example, negative numbers are usually returned when an error has occurred and we don't want to proceed.

Always remember, it's much C-mpler than you thought!

Regards,
Gilad

Conditions

Gilad Ri — Wed, 12 Jun 2019 17:30:55 +0000

Ok, we already learned how to create some variables, and how to change their values (even in an interactive away). But, what if we want to check some conditions about their value?

For this case in most of the programming languages, we have the if statement:

if ([some_condition_statment]) {
    // The conditional statement proved true - do something about that
}

If we want to do something if the conditional statement proved, and something else if not, we have to use the else statement:

if ([some_condition_statment]) {
    // True - do something about that
} else {
    // False - do something else
}

But, what we can check? To answer this we need to learn about the comparison operators:

Comparison Operators

"==": checks if the two operands are equal.
">=": checks if the left operand is bigger or equal to the right operand.
"<=": checks if the left operand is smaller or equal to the right operand.
"!=": checks if the two operands are different.
">": checks if the left operand is bigger than the right operand.
"<": checks if the left operand is smaller than the right operand.

For example:

#include <stdio.h>
int option;
// Asks for an input from the user
printf("Choose an option:\n");
scanf("%d", &option);
// Operates according to the user choice
if (option == 1) {
    printf("Hello\n");
} else {
    printf("Bye bye\n");
}

Notice, in C, each comparison operator returns 1 if the condition met and 0 otherwise. Therefore, if we want we can (but don't do that):

int x = 5;
int y = 5;
int z = (x==y); // z == 1

That means that the if statement just checks if the value between the brackets is 0 or different than 0 (even a negative number!). For example:

if (5) {
   // We will always enter this code block because 5 != 0
}

We should remember this trick for later.

Let's talk now about logical operators. Logical operators allow us to check whether two or more conditions are met (the AND operator), if at least one condition is met (the OR operator) or if some condition isn't met (the NOT operator).

Logical Operators

"&&": the AND operator. Checks whether both conditions are met.
"||": the OR operator. Checks whether at least one condition is met (can be both).
'!': the NOT operator. Checks whether a condition isn't met.

AND example:

#include <stdio.h>

int number;
// Gets a number from the user
printf("Enter a number between 1-10\n");
scanf("%d", &number)
// Checks if the number if in the range 1 - 10
if (number >= 1 && number <=10) {
    printf("OK\n");
} else {
    printf("The number is out of range\n");
}

OR example:

#include <stdio.h>

char option;
// Gets a character from the user
printf("Choose: 'q' or 'w'\n");
scanf("%c", &option)
// Checks if the optin is legal
if (option == 'q' || option == 'w') {
    printf("OK!\n");
} else {
    printf("Invalid option!\n");
}

NOT example:

#include <stdio.h>

// Initializes a variable
int x = 10;

int a = !x; // a == 0 because '!' makes every number, (other than 0), to be 0
int b = !a; // b == 1 because '!' makes 0 to be 1

b = !b // b == 0

if (!b) {
    printf("b's value is 0\n"); // This will be printed!
}

The last example is a little weird, but you can learn a lot from it and it's probably the most important example of all three. We will see that the '!' operator is really useful when we want to check whether a variable's value is 0 (or NULL).

Switch-Case

Ok, now we go on to another topic: what if we want to check a lot of conditions? In this case, we can write a code like this:

#include <stdio.h>

int option;
// Asks for input from the user
printf("Choose an option:\n");
scanf("%d", &option);
// Operates according to the user choice
if(option == 1) {
    printf("You look awesome!\n");
} else if (option == 2) {
    printf("Have a nice day!\n");
} else if (option == 3) {
    printf("Nice to meet you!\n");
} else {
    printf("Invalid option\n");
}

But this is really ugly and difficult to change if we want to in the future. Therefore, in this case, we use the switch statement as follows:

switch([variable]) {
case [first_value]:
    // Code
    break;
case [second_value]:
    // Code
    break;
default:
    // The code which we want to run if no condition met until the end
    break;

For example:

#include <stdio.h>

int option;
// Asks for input from the user
printf("Choose an option:\n");
scanf("%d", &option);
// Operates according to the user choice
switch(option) {
case 3:
    printf("Nice to meet you!\n");
case 2:
    printf("Have a nice day!\n");
    break;
case 1:
    printf("You look awesome!\n");
    break;
default:
    printf("Invalid option\n");
    break;
}

This code does the same as the if-else code from above does, and it looks prettier and easier to understand. Each case is just like:

if ([variable] == [value])

Let's talk about the break keyword. This keyword means: "Get out from this block of code!". What is a block of code? Simply put, everything that is inside curly brackets. In this case, the code between the brackets is the switch-case, and therefore the break just makes us jump to the last row of our code.

"Why do we use break?" you suppose to ask. The answer is simple: because that how switch-case works. If we don't write a break, the code just goes on and run all the lines until the end of the switch-case - what means all the code lines that are for the cases which are below the case we entered.
This might sound odd, but it does have some use cases. (I admit that I can't think about many use cases, but I found some, I promise you). For example, if we don't know what is "loop" (as we really are, right now), we can still print a stuff a lot of times according to our choice (with a limit) using this trick:

#include <stdio.h>

int times;
// Asks for input from the user
printf("Choose the number of times:\n");
scanf("%d", &times);
// Operates according to the user choice
switch(times) {
case 5:
    printf("Hi\n");
case 4:
    printf("Hi\n");
case 3:
    printf("Hi\n");
case 2:
    printf("Hi\n");
case 1:
    printf("Hi\n");
default:
    break;
}

For the input 3 will be printed:

Hi
Hi
Hi

Thats because we enter to the case where times is 3, and then go on to the next line (the printf of the case for 2) and then to the next line (the printf of the case for 1) and then we breaks at the default case. To be clear: we ignore the "cases" lines, and just run the code lines which "inside" them (after we enter at least one case, or the default case).

Finally, to the default keyword: we enter this case if we enter none of the cases above. That's all for now, keep having fun.

Always remember, it's much C-mpler than you thought!

Regards,
Gilad

Intro to I/O

Gilad Ri — Wed, 12 Jun 2019 13:01:59 +0000

So, we already learned how to create variables and basic ways to manipulate their values (mathematics operations). But what if we don't want to create a variable and initialize it (insert the first value to it) by yourself? What if we want our program/application to be more interactive and fun and let the users/clients to make this choice?
Moreover, how do we show them information about what is happening? For now, there is nothing on the user's screen but a black console.

C developers asked exactly these two questions before (I guess), and fortunately, therefore we have the functions: printf and scanf.

printf("[text]", [variable/s]): this function gets a text (to be accurate, a string, but for now we call it "text") and variables and prints an output to the console, for the users.
scanf("[text]", &[variable/s]): this function does the opposite, it gets input from the user and inserts it to the variables.

(If you don't know what a "function" means it's OK for now. We will cover this subject soon. If you insist, think about what you learned in high school: function is a thing which gets input and returns an output. For example: if f(x)=x^2, then f(2) will give us 4 as an output)

For example:

#include <stdio.h>
int grade;
printf("Please enter the student's grade before the factor:\n");
scanf("%d", &grade);
grade += 10;
printf("The student's grade after the factor is: %d\n", grade);

The console, in this case, will be:

Please enter the student's grade before the factor:
90
The student's grade after the factor is: 100

As you can see, our program asks the user to insert input and then wait for one. Once it gets the input (in the example above the input we typed was "90"), it inserts it to the integer variable grade, increases its value by 10 (a pretty nice factor I wish for all of you) and then prints the new grade (in our case, "100").

"Good", you may say, "but what are all the "%d" and "\n" nonsense?"
The answer is that it that actually isn't as difficult as you might think:

%[type]: in our case, "%d", is just a placeholder for the variable value which comes after the comma. Each variable type (remember?) has %[letter] for himself. In our case, for integer, it's "%d" because it's a shortcut to "decimal". (For char is "%c" and for float is "%f").
\n: to keep it simple, that means "new line". In other words, if you want the next text you print to be in a new line, just put "\n" at the end of your previous printed text. You can also print a few lines at once with a single prinf. However, you should always use "\n", not just for this purpose, because "\n" also tells the computer to print your output right now. You have to understand, the printing operation is a really expensive and difficult operation for the computer (compared to mathematic operations, for example) and therefore the computer "prefers" collecting all the outputs in a buffer (a small storage place) and flushes it out only once the program explicitly demands it or when the buffer is "full enough". In order to avoid this frustrating situation, just use: "\n". It forces the computer to flush its buffer immediately. To be honest, you might not notice that in most of the modern IDEs because they simulate that for you in their console. However, it's a good habit for the "real life" to put a "\n" at the end of each printf.

Yes, I know that there is a '&' before the variable name in the scanf, and it's OK, it's not a typo (to be more accurate: you have to put this sign before the variable in scanf). This will be explained when we get to talk about Memory addresses.

Finally, the wise reader could already understand the meaning of the title. I/O stands for: "Input & Output".

Always remember, it's much C-mpler than you thought!

Regards,
Gilad