C Fundamentals

(By Dr. Leo Hu)


This handout is suitable for beginners to intermediate learners who study C systematically, and it can also be used as a reference tool for common knowledge points of C.

If you do not know C programming, please review C in 1 hour. 

This lecture introduces the elements of C programming language. You may quickly have an overview of the materials and refer back when coding with C. 

Please use this online C compiler IDE to test the programs in this handout and develop your own programs in learning. 

1.Tools for C programming 

When we prepare a C program, we must use an editor to write the program's source code. Since source code must be pure text (ASCII characters), the editor must be a pure text editor such as Notepad in Windows, and vi in Linux or Unix. 

Any program of source code written in a high-level programming language must be translated into machine code before it can be executed by a computer. There are two ways of translating source code into machine code: compiling and interpreting. 

Compiling is converting source code into machine code before the program is run. Interpreting is translating source code into machine code one line at a time as the program is running.  The tool for compiling is called a compiler, and the tool for interpreting is called an interpreter. 

C is a compiling language. Therefore, we need a C compiler to translate a C program into machine code. There are quite some C compilers available such as GCC (GNU Compiler Collection) and Clang. 

Since a C program source code may be written in multiple modules stored in a few files, and a program may need to use code in predefined libraries, a linker is usually needed to link the modules and libraries together to form an executable program. 

While we can use the independent editor, compiler, and linker in programming, we prefer to use an Integrated Development Environment (IDE) that has integrated the editor, the compiler, and the linker to work together. There are many IDEs available such as Code::Blocks, Eclipse, Microsoft Visual Studio, NetBeans, etc., and also many online IDEs such as programiz.com, CodeChef IDE, OnlineGDB, Repl.it, Paiza.io, and so on. 

In this lecture, we will use programiz.com for programming demos and hands-on practices. The programiz.com IDE in a browser looks like the figure below. 

Figure 1. The programiz.com IDE

It divides the programming space into two columns. The left column lists a few tool buttons on the top, including the Run button that is used to compile and execute the program, and a source code editor below. The right column is the Output space that shows the output result from the program execution.  A Clear button on the top-right corner of the Output space is used to clear the space of Output. 

We will enter the C program source code in the editor, click the button Run to compile and execute it, and read the output in the Output space. when necessary, click the Clear button to clear the Output space. 


2. Identifiers 

An identifier is a name used by the programmer to identify a variable, function, or any other user-defined item. Here are some rules for naming C identifiers:

Identifiers are used to name variables, named constants, functions, structs, etc.  These are things that have values of types of data. Therefore, before we discuss these identifiers, we should have an overview of data types in C. 

a. Data Types 

Identifiers can be of various data types. The data types determine how many memory bytes shall be allocated for a variable.  The table below lists the commonly used data types in C programming language:

Table 1. Common data types of C programming language

A Computer processes and stores data in binary format, which means the computer stores 0s and 1s. Any data must be converted to binary format before it can be processed and stored in a Computer. A 0 or 1 is called a bit, which means a binary digit. Computers organize 8 bits into a group, which is called a byte. Byte is the smallest unit in storage. 

The most frequently used data types are char, int, float, and double. The char type data are defined in the American Standard Coding Information Interchange (ASCII). A char (means character) needs 1 byte (that is 8 bits) of memory space. An int (means integer) needs 4 bytes (i.e., 32 bits) of memory space. A float (a fractional number that is stored with a floating point) needs 4 bytes (i.e., 32 bits) of memory space. A double (a float number with double precision) needs 8 bytes (i.e., 64 bits) of memory space. 

Hands-on: to show sizes of char, int, float, and double

Please enter the C program source code in the online C compiler (IDE), click the Run button to compile and run it. Observe the result in the Output pane. 

// Display the sizes of char, int, float, and double

#include <stdio.h>


int main() {


   printf("Size of char : %d\n",sizeof(char));

   printf("Size of int : %d\n",sizeof(int));

   printf("Size of float : %d\n",sizeof(float));

   printf("Size of double : %d\n",sizeof(double));


   return 0;


}

If there is no problem, the result should look like

Size of char : 1

Size of int : 4

Size of float : 4

Size of double : 8

This program shows the number of bytes used to store a char, an int, a float, and a double.  I will explain the detail of the program later. 

i. Signed vs. unsigned data 

Computers store data in either signed or unsigned format. When a data is stored in unsigned format, all bits are used to store the value of the data. For example, characters are generally stored in unsigned format. ASCII (American Standard Code for Information Interchange) assigned a value for every character. From the ASCII table, we find character '&' is represented by number 38, and its binary format is 0b00100110, and character '¦ ' is represented by number 166, and its binary format is 0b10100110. Please refer to this page for the method of converting a decimal number to its binary format. The prefix '0b' is used to differentiate a binary number from decimal numbers. 

Note: To differentiate numbers in different number systems, we use 0b- prefix for binary numbers, for example, 0b00100110; and 0x for hexadecimal numbers, for example, 0x26. Decimal numbers generally do not have a prefix, but sometimes we may use prefix 0d. 

Integers and float numbers are stored in unsigned format only when numbers in consideration consist of only 0 and positive numbers. For example, for unsigned int, all 4 bytes (that is, 32 bits) are used to store the value of an integer, so that the unsigned integers can be stored from 0b00000000 00000000 00000000 00000000 to 0b11111111 11111111 11111111 11111111, i.e., from 0 to 4,294,967,295.

However, generally, we process and store both negative and positive numbers. To store negative numbers, we must use signed format of storage. In signed format, the left-most bit (i.e., the highest bit) is used as the sign bit to store the sign. When the sign bit is 0, the number is 0 or positive; when the sign bit is 1, the number is negative. To shorten the writing, let's suppose 1 byte (i.e., 8 bits) is used to store an integer. For example, 0b00110011 is +51, while 0b10110011 is -51. This storage method has an issue, that is, 0b00000000 is +0, and 0b10000000 is -0. There will be two 0s in the number sequence. To avoid this issue, in practice, signed numbers are stored in Two's complement format. 

Note: In Two's complement, 0 and positive numbers are stored the same way as usual, but negative numbers are converted from its positive counterpart. For example, -51 is stored by converting from +51: 

step 1.  convert 51 to binary format 0b0011 0011. 

step 2. invert all bits of 0b0011 0011 and we get 0b1100 1100. 

step 3. plus 1 to 0b11001100 and we get 0b11001101, where the sign be it 1, means negative. So, -51 is stored as 0b11001101.  

When it is read out, the sign bit indicates that it is negative, and the value will be obtained by following the same steps: invert to 0b00110010, plus 1 to be 0b00110011, i.e., 51. So we know the stored number is -51. 

Using this method, -0 shall be converted from 0b0000 0000 to 0b1111 1111, then plus 1, we get 0b0000 0000 with a dropped carry. That means, either +0 or -0 is stored the same, 0b0000 0000. 

Considering 4 bytes of storage for an int, in two's complement format, signed integers can be stored from 0b10000000 00000000 00000000 00000000 to 0b01111111 11111111 11111111 11111111, that is, from -2,147,483,648 to 2,147,483,647. 

ii. Format specifiers

Format specifiers, as listed in table 1, are used to specify what type of data is to be accepted by the predefined function scanf(), and what type of data is to be displayed by the predefined function printf(). For example, in statement 

scanf("%d", &num);

an integer is to be accepted from the input because the input data format specifier is %d for int. And in statement

printf("%lf", num);

a double type of data is to be printed because the output data format specifier is %lf for double. 

For float and double data types, we may specify how many decimal places to be displayed. The method is

printf("%.nf", number);

where n tells how many decimal places to display. 

These data types in this table are all primitive data types. In computer science, primitive data types are a set of the most basic data types, or language built-in data types, such as int, char, float, double, and those in the table above. By contrast, some other data types such as string, enum, and struct are constructed data types. They are also called derived data types because they are derived from the primitive data types. Format specifier for string is "%s". 

Hands-on: to display data with format specifiers

Please enter the program in the Online C Compiler (programiz.com), run and observe the results:

#include <stdio.h>


int main() {

    int num = 123;

    char ch = 'a';

    float f = 3.14159;

    double d = 3.14159265358979323846;

    char str[] = "Hello World!";


    printf("Integer: %d\n", num);

    printf("Character: %c\n", ch);

    printf("Float: %.2f\n", f);

    printf("Double: %.10lf\n", d);

    printf("String: %s\n", str);


    return 0;

}

This program display various types of data using predefined function printf(). The first parameter of printf() is a string in double quotes, which is to be displayed. In the double quoted string, there may have one or more format specifiers that indicate what types of data are to be displayed. Look up format specifiers in table 1, we can see that %d is to display an int, %c is to display a char,  $.2f is to display a float number with 2 decimal places, %.10lf is to display a double with 10 decimal places, and %s is to display a string. Escape character \n indicates to  display followings to a new line. The second (and more, if any) parameter(s) is the variable to display.  

The execution result is 

Integer: 123

Character: a

Float: 3.14

Double: 3.1415926536

String: Hello World!

iii. Type casting

Type casting is an important topic about data types. Type casting (or type conversion) is a way to convert a variable from one data type to another data type. It is used when you want to treat a variable as another data type temporarily. There are two types of type casting operations: Implicit type casting and Explicit type casting. 

Implicit type casting in C performs the conversions without changing any values stored in the data variable. Conversion of lower data type to higher data type will happen automatically. Lower data type refers to the data type that occupies less memory space and has a smaller range of values than the higher data type. Higher data type refers to the data type that occupies more memory space and has a larger range of values than the lower data type. The level of data types from lower to higher is as follows: char, short int, int, long int, float, double and long double. For example, 

//implicit or automatic type casting: int to float

float my_float = 10;

printf("%f", my_float);

In this example, float variable my_float is assigned with an int value. C will implicitly (automatically) convert the int value to a float value and assign it to the float variable. 

However, implicit casting can be risky. For example, 

// implicit /automatic casting: float to int

int myInt = 9.99;

printf("%d", myInt);

In this example, implicit casting converts a float value to an int value. The value will lose its decimal digits.  For another example,

// implicit /automatic casting: float to int

float sum = 5 / 2;

printf("%f", sum);

In this example, 5/2 shall get 2 because the division operation is on integers. Implicit casting will convert 2 to 2.0 and assign it to sum. The result also loses its decimal digits. In these cases, you need to manually convert the integer values to floating-point values. 

Explicit casting is a way to force the conversion between data types. This type of casting is defined in the program explicitly. It is done by enclosing the name of the data type in a pair of parentheses before the expression to be converted.  For example,

// Explicit /manual casting: int to float

float sum = (float) 5 / 2;

printf("%f", sum);

In this example, the explicit casting converts int value to float value to force preserving the decimal digits. 

b. Variables 

A variable is a name of a memory location that stores a data whose value may be changed during the program execution.  The memory space size used to store a variable is determined by the data type of the variable.

From the above table of data types, for example, if we declare a variable of data type int (i.e., integer), we know it will be assigned with 4 bytes of memory. 

The C language syntax of declaring a variable is 

dataType variableName = initialValue;

or

dataType variableName;

For example, suppose we declare an integer and assign it with an initial value 5, the declaration statement should be 

int myInteger = 5;

Here the variable name is myInteger, its data type is int, and its initial value is 5. During the program execution, its value may be changed.  If there is no initial value, the declaration statement should be 

int myInteger;

Tip: Good programming practice suggests assigning an initial value to a variable at declaration to help avoid bugs and make your code more readable and maintainable. 

Note: A declaration statement may declare more than one variable, and separate them with comma (,). Some or all of them may be assigned with initial values. For example, we can declare two integer variables in one statement like

int myInt1 = 5, myInt2 = 0;

Note: C naming convention requires that variables start with a lower-case letter.

In a program, if a  variable is to accept an input from the user, we may use the predefined function scanf() in a statement like

scanf("%d", &myInt);

or 

scanf("%i", &myInt);

Here, %d or %i is the format specifier for an integer. The & symbol is used to get the address of the variable.  

The function scanf() can accept multiple variables in a statement. For example, statement

scanf("%d %d %d", &a, &b, &c);

is to accept three inputs for integer variables a, b, and c. 

Note: When you input multiple variables, you should use space to separate them.

Similarly, the predefined function printf() can be used to display an integer in a statement like

printf("The value of myInt is %d",  myInt);

the value of myInt will be displayed at the position of %d in the quoted string. The function printf() can output multiple variables in a statement. For example,  

printf("The input values are %d and %d",  myInt1, myInt2);

Hands-on: to run a C program using an integer

Enter the program below in the editor of the Online C Compiler (programiz.com) to test it. 

/*A C program with input/output */

#include <stdio.h>

int main()

 {

  // declare integer variable as myInteger

  int  myInteger = 0;


  // prompt the user

  printf("Enter your integer: ");


  // read input from the user

  scanf("%d", &myInteger);


  // display greetings with the first name

  printf("My integer is %d", myInteger);


  return 0;

}

If nothing runs awry, the screen should look like

Figure 2. A C program with input /output an integer

Question: Remove the & symbol in function scanf() and run it again. What message do you get?

Answer: in C programs, & is used to get the memory address of a variable so that function scanf() can accept a value and send it to the variable's memory address. 

Question: Why we need use & for a variable in scanf(), but not use & for a variable in printf()? 

Answer: Variables in scanf() should be given with their addresses, and & is the operator to get address of a variable, so that we need use & with variables in scanf(). On the contrary, variables in printf() should be given with their values, so that we should not use & with the variables in printf().  The difference has be defined by the function developers and we have to follow them when we use their predefined functions. 

Declaring and using variables of other primitive data types are about the same as those for int. For example, for a double variable:

double dbl_var = 0.0;

dbl_var = 123.45;

scanf("%lf", &dbl_var);

Note: the format specifier for double is %lf as shown in the table 1 above.

printf("The double value is %lf", dbl_var);

Note: In C, the default number of digits after the decimal point to print is 6. We can specify the number of digits to print using a dot (.) followed by a number that specifies the number of digits to print. For example, 

printf("The double value is %.2lf", dbl_var);

will print 2 digits after the decimal point. 

For a char variable:

char ch_var = ' ';

Note: a char is enclosed in a pair of single quotes ' '. 

ch_var = 'A';

scanf("%c", &ch_var);

printf("The char is %c", ch_var);

However, processing constructed data types are somewhat different. For example, string is constructed from char and is an array of chars. Declaring and processing string is as follows:

char str_var[20] = "";

Note: a string is not a primitive data type, but an array of chars. I will discuss array soon. 

Note: the length of a string is the number of chars in the string. Here the length is 20. The value of length is enclosed in a pair of square bracket [ and ]. 

Note: a string should be enclosed in double quotes. 

strcpy(str_var, "Hello");

Note: in C, string variable is not of a primitive data type and cannot be assigned simply with the assignment operator (=). 

Note: a literal string value can be assigned to a char array using the pre-defined function strcpy().  Since this function is defined in header file <string.h>, it must be included in the beginning of the program file before any code. 

scanf("%s", str_var);

Note: The address operator & can be omitted for a char array, because the name of char array is an address - the beginning address of the array.  

printf("%s", str_var);

I will discuss string in more depth soon. 

b. Named Constants 

A named constant is a name of a memory location that stores a data whose value cannot be changed once it is defined. A named constant can be used in much the same way as a variable, except that its value cannot be changed in program execution, so that it is also known as a "read-only" variable. 

To declare a named constant in C, you can use the keyword const before or after the type of the variable. For example, you can declare a constant float variable named pi with the value 3.1415 as follows:

const float pi = 3.1415;

or 

  float const pi = 3.1415;

As naming convention in programming, we use all upper-case letters in a named constant. So, pi is usually written as PI and the declaration statement looks like below:

const float PI = 3.1415;

or 

float const PI = 3.1415;

We prefer the format that has keyword const first. Some of the most common named constants include:

C provides another way to define constant. In C programming language, we can use preprocessor directive #define to define macros along with the source code present. Thus, we can define constant values that can be used globally throughout the code we have. Such a way is actually giving a name to a literal value. For example (please enter the program in the Online C Compiler (programiz.com) to test it. 

#include <stdio.h>

#define PI 3.1415  //Give name PI to the literal value 3.1415

#define ADMIN "John Doe"

#define STARTTIME 8


int main() {

    printf("The PI is: %f\n", PI);

    printf("The admin is: %s\n", ADMIN);

    printf("The start time is: %d\n", STARTTIME);

   return 0;

}

Tip: when we print multiple lines on the screen, we may use the special string "\n" at the end of a line of string. \n is an escape sequence that represents a newline character and force to print the following characters to the line below. Escape sequence will be discussed later in the topic of strings. 

C also supports to declare a set of constants, called enumeration constants. Enumeration (or enum) in C is a user-defined data type that consists of integral constants. It is mainly used to assign names to integral constants, which makes a program easy to read and maintain. 

To declare an enum in C, you must use the enum keyword along with the elements separated by commas. The basic syntax of enum is: 

enum enum_name {int_const1, int_const2, int_const3, .... int_constN};

Here, the default value of int_const1 is 0, int_const2 is 1, int_const3 is 2, and so on. You can change the default values of enum elements in declaration (if needed). For example, you may declare  enum constants with values other than the default ones:

enum suit {

    club = 0,

    diamonds = 10,

    hearts = 20,

    spades = 3,

};

Then we may declare a suit type enum variable that can have values only listed in suit:

  enum suit card;

Hands-on: to use const and enum

Please use the online C compiler to run the program below:

/*A C program with using const and enum */

#include <stdio.h>

enum suit {

    club = 0,

    diamonds = 10,

    hearts = 20,

    spades = 3

};

int main()

{

const int POKER_SET = 4;

enum suit card;

card = hearts;

printf("The Poker size is %d,and the card is %d.", POKER_SET, card);    

return 0;

}

If nothing goes awry, the result should look like

The Poker size is 4,and the card is 20.

Note: in this example, card is a variable of data type enum suit, and its value is limited in the set of values defined in enum suit. 

c. Functions

Functions are a critical part in C language because C programs are all written as functions. Functions allow you to break the code down into smaller, more manageable pieces that can be reused throughout a program and can even be used by other programs. Thus, the code readability and maintainability are improved. 

In C, a function name is an identifier for a named block that consists of a group of statements that together perform a task. Every C program must have function main(), together with other possible additional functions. A function always comes as a function name like main as the identifier followed by a pair of parentheses (). 

There are many pre-defined functions such as printf() and scanf() that are defined in libraries as resources for us to use in our programs. We can also define our own functions, called user-defined functions. The C syntax of defining a user-defined function is as follows:

type function_name(parameter list) {

   body of the function

}

Where 

int my_function();

For example, the function below is defined to add up two integers and to return the sum:

  int sum(int a, int b) {

     return a + b;

}

This function's return type is int, function name is sum, function parameter list consists of two integers, a and b, and its function body consists of a single return statement that returns a + b. 

Hands-on: A C program with a user-defined function

Please enter the program below in the online C compiler's editor. Run to see the result. 

//A C program with a user-defined function

#include <stdio.h>


int sum(int a, int b){

    return a + b;

}

int main()

{

    int a = 0, b = 0, c = 0; //declare three integral variables

    printf("Please enter two integers: ");//remind the user

    scanf("%d %d", &a, &b); //accept the user's input

    c = sum(a, b); //call function sum() to calculate

    printf("The sum is: %d", c);  //display the result

   

    return 0;

}

If nothing goes wrong, the screen should look like:

Please enter two integers: 11 22

The sum is: 33

This program has a user-defined function sum() that has two parameters a and b, and returns the sum of a and b to its caller. The program main() function declares integral variables a, b, and c. Then it reminds the user to enter two integers, accepts the user's inputs for a and b,  calls function sum() and assigns its returned value to c, and then displays the result. 

Tip: This program has inline comments at the ends of the first five statements. It is good practice to add comments wherever necessary to improve readability of the code. The comments can be placed before, inline, or after the targeted statements.  But avoid excessive comments when the code is clear and concise. 

Note: The user inputs of the two values for function scanf() are separated by a space. 

I will discuss more about functions later. 

d. Structs 

In C, a struct is a user-defined data type that groups related data together.  The C's syntax for defining a struct is as follows:

struct struct_name {

   member1;

   member2;

   ...

};

For example, 

struct person {

   char name[50];

   int age;

   float salary;

};

This defines a struct named person that contains three members of variables: name, age, and salary. 

Hands-on: A C program with using a struct

Please enter the program in the online compiler's editor and run it to see the effect. 

#include <stdio.h>

struct person {

   char name[50];

   int age;

   float salary;

};


int main() {

   struct person p; //use the user-defined struct to declare a person variable p.

   printf("Enter name: ");

   scanf("%s", p.name); //the struct member is accessed by the struct variable p concatenated the member with the dot operator.

   printf("Enter age: ");

   scanf("%d", &p.age);

   printf("Enter salary: ");

   scanf("%f", &p.salary);

   printf("Name: %s\nAge: %d\nSalary: %.2f", p.name, p.age, p.salary);

   return 0;

}

If nothing goes wrong, the execution result should look like:

Enter name: John

Enter age: 30

Enter salary: 3000

Name: John

Age: 30

Salary: 3000.00

Note:  A struct member such as the person's name is accessed by the struct variable (p) concatenating the member variable (name, in this case): p.name. Similarly, the person's age is accessed by p.age, and the person's salary is accessed by p.salary. 

Question: why is there no operator & before p.name in the first scanf() function? 

Note: struct person's member name is an array. The array name is not a value, but a memory address, that is, the address of the first array member.  Therefore, p.name does not need operator & to access the address.  But age and salary are variables of primitive data, int and float, so that the operator & must be applied before their name p.age and p.salary to get their address. 

e. Labels 

Labels are another type of identifiers that do not create values to be handled in the programs but are used to mark the positions of statements. 

In C programming language, a label is an identifier followed by a colon (:) that marks the beginning of a statement. 

Labels are used with goto statements. A goto statement transfers control to the statement labeled with the corresponding identifier. For example, 

start:

    printf("Hello World!");

    goto start;

In this example, “start” is the label and “goto start” transfers control back to the beginning of the statement labeled “start”. 

The use of goto statement ("goto start;" in this example) in C programming language is considered a harmful construct and a bad programming practice. It can be replaced in C programs with the use of break and continue statements, which I will discuss later.

f. Scope: Local vs. Global 

In C, an identifier can be either local or global. When we discuss this topic, most of the time we refer to variables. But other identifiers are covered under this topic the same way as variables. 

The scope of a variable determines whether or not you can access and modify it inside a specific block of code. 

A local variable is declared inside a function or block of code and can only be accessed within that function or block. 

Note: A block is anything enclosed in a pair of curly brackets ({ }). 

A global variable is declared outside of all other functions and can be accessed from anywhere in the program. 

Here is an example of a local variable in C:

#include <stdio.h>

int main() {

  int x = 5; // local variable

  printf("%d", x);

  return 0;

}

In this example, x is a local variable declared inside the main() function so that it can only be accessed from inside the main() function.

An example of a global variable is below:

#include <stdio.h>

int x = 5; // global variable

int main() {

  printf("%d", x);

  return 0;

}

In this example, x is a global variable declared outside of any function. It can be accessed from anywhere in the program, not only inside the main() function. 

3.Operators

Operators perform operations on operands such as variables and values. 

In terms of the number of operands an operator works on, C has unary operators, which has only one operand, such as increment (++), decrement (--), unary plus (+), unary minus (-), logical not (!), bit 1's complement(~), sizeof(), type casting operator (type), address operator (&), and pointer operator (*), etc., binary operators, which  has two operands, such as addition (+), subtraction (-), logical and (&&), assignment (=), etc., and a single ternary operator, the conditional operator (?:), which has three operands. This is very easy to see from the expressions that the operators are used. 

In terms of the associativity of operators, C has left-to-right and right-to-left operators. In C programming language, the associativity of an operator determines the direction in which an expression is evaluated. In C, the operators that have right to left associativity are assignment operators, unary operators, and the ternary operator. All other kinds of operators are left to right associative. 

In terms of an operator's function or performance, C divides the operators into the following six groups: arithmetic, relational, logical, bitwise, assignment, and other operators. I will discuss more on operators from this perspective. 

Finally, operator precedence is critical in determining the order in which operators are evaluated in an expression. Operators with higher precedence are evaluated first. I will list the operator precedence after discussing the operators' functions. 

a. Arithmetic Operators 

Arithmetic operators perform arithmetic/mathematical operations on operands. Arithmetic operators include addition, subtraction, multiplication, division, modulus, increment, decrement, unary plus, and unary minus. The first five operators perform exactly the same as in mathematics. Increment increases its operand's value by 1, and decrement decreases its operand's value by 1. Unary plus operator simply returns the value of its operand, while unary minus operator returns the negative value of its operand. Please see the arithmetic operators in the table below. 

Table 2. Arithmetic operators in C

Note: the increment operator and the decrement operator have two cases, pre- or post-.  pre-increment increments the value of the variable before it is used in an expression, whereas post-increment increments the value of the variable after it is used in an expression. For example, if a = 5, b = ++a is equivalent to a = a +1, then b = a so that the results are a = 6, b = 6. Whereas if a = 5, b = a++ is equivalent to b = a, then a = a+1 so that the results are a = 6, b = 5. 

The pre-decrement and post-decrement have similar difference. For example, if a = 5, b = --a is equivalent to a = a-1, then b = a so that the results are a = 4, b = 4.  Whereas if a = 5, b = a-- is equivalent to b = a, then a = a - 1 so that the results are a = 4, b = 5. 

Hands-on: arithmetic operators

Please enter the program below in the Online C Compiler (programiz.com), run and think of the results. Do the results make sense?

#include <stdio.h>

int main() {

    //declare a few variables

    int a = 30, b = 3, c = 0;

    //Test arithmetic operators

    printf("If we suppose a = %d, b = %d, then we have a + b = %d \n", a, b, a + b);

    printf("If we suppose a = %d, b = %d, then we have a - b = %d \n", a, b, a - b);  

    printf("If we suppose a = %d, b = %d, then we have a * b = %d \n", a, b, a * b);

    printf("If we suppose a = %d, b = %d, then we have a / b = %d \n", a, b, a / b);

    printf("If we suppose a = %d, b = %d, then we have a % b = %d \n", a, b, a % b);

    a = 30;

    c = ++a;

    printf("suppose a = 30, c = ++a, we obtain a = %d, c = %d \n", a, c);  

    a = 30;

    c = a++;

    printf("suppose a = 30, c = a++, then we'll get a = %d, c = %d \n", a, c);  

    a = 30;

    c = --a;

    printf("suppose a = 30, c = --a, we obtain a = %d, c = %d \n", a, c);  

    a = 30;

    c = a--;

    printf("suppose a = 30, c = a--,  then we'll get a = %d, c = %d \n", a, c);  

   

    return 0;

}


If nothing goes wrong, the screen should look like:

If we suppose a = 30, b = 3, then we have a + b = 33 

If we suppose a = 30, b = 3, then we have a - b = 27 

If we suppose a = 30, b = 3, then we have a * b = 90 

If we suppose a = 30, b = 3, then we have a / b = 10 

If we suppose a = 30, b = 3, then we have a % b = 0 

suppose a = 30, c = ++a, we obtain a = 31, c = 31 

suppose a = 30, c = a++, then we'll get a = 31, c = 30 

suppose a = 30, c = --a, we obtain a = 29, c = 29 

suppose a = 30, c = a--,  then we'll get a = 29, c = 30 

b. Relational Operators

Relational operators are used to compare two operands for their values. They are also called comparison operators. The return value of a comparison is either 1 or 0, which means true (for 1) or false(for 0).  These values are known as Boolean values. There are 6 relational operators as listed in the table below. 

Table 3. Relational (or comparison) operators in C

Relational operators are critical in C to construct conditional expressions for making decision. Their meanings are the same as in mathematics. 

c. Logical Operators 

Logical Operators combine two or more conditions/constraints or to complement the evaluation of the original condition in consideration. There are a total of 3 logical operators in C programming language and they are listed in the table below:

Table 4. Logical operators in C

Logical operators are also critical in C to construct conditional expressions for making decisions. Their meanings are the same as in mathematics. 

d. Bitwise Operators 

The Bitwise operators perform bit-level operations on the operands. There are 6 bitwise operators as listed in the table below:

Table 5. Bitwise operators in C

The examples in the table above assume character int variable A holds 60, that is binary 0b00111100, and variable B holds 13, that is binary 0b00001101. 

In A & B, A is 0b00111100, B is 0b00001101, the result's bits from left to right will be 

0 & 0 = 0

0 & 0 = 0

1 & 0 = 0

1 & 0 = 0

1 & 1 = 1

1 & 1 = 1

0 & 0 = 0

0 & 1 = 0

so the result is 0b00001100, or 12. 

In ~A, the result's bits from left to right are flipped from those in A, that is, 

~0 = 1

~0 = 1

~1 = 0

~1 = 0

~1 = 0

~1 = 0

~0 = 1

~0 = 1

so the result is 0b11000011, or -61.

In A << 2, the result's bits from left to right are left shifting two positions from A, that is,

0b00111100 << 2 is 0b111100, or 240.

In A >> 2, the result's bits from left to right are right shifting two positions from A, that is,  0b00111100 >> 2 is 0b00001111, or 15. 

Let's run a lab to better understand these bitwise operators. 

Hands-on: Test bitwise operators

Please enter the program below in the online C compiler, run and think of the results. 

/*Test bitwise operators*/

#include <stdio.h>

int main() {


   unsigned int a = 50; /* 50 = 0011 0010 */  

   unsigned int b = 11; /* 11 = 0000 1011 */

   int c = 0;          


   printf("if a = %d and b = %d\n", a, b);

   

   c = a & b;       /* 2 = 0000 0010 */

   printf("then a & b equates %d\n", c );


   c = a | b;       /* 59 = 0011 1011 */

   printf("then a | b equates %d\n", c );


   c = a ^ b;       /* 57 = 0011 1001 */

   printf("then a ^ b equates %d\n", c );


   c = ~a;          /*-51 = 1100 1101 */

   printf("then ~a equates %d\n", c );


   c = a << 2;     /* 200 = 1100 1000 */

   printf("then if c = a << 2,  that means, c is equal to %d\n", c );


   c = a >> 2;     /* 12 = 0000 1100 */

   printf("then if c = a >> 2,  that means, c is equal to %d\n", c );

    return 0;

}



If nothing goes wrong, the screen should look like:

if a = 50 and b = 11

then a & b equates 2

then a | b equates 59

then a ^ b equates 57

then ~a equates -51

then if c = a << 2,  that means, c is equal to 200

then if c = a >> 2,  that means, c is equal to 12

e. Assignment Operators 

These operators assign values to variables. They are all binary operators. All C's assignment operators are listed in the table below:

Table 6. Assignment operators in C

The basic assignment operator (=) is different from the equal sign (=) in mathematics. It assigns the value on the right side to the left side. For example, 

int a = 21;

This statement assigns the value 21 to the variable a so that a will hold 21. Later, a can be assigned with other values. 

Beside the basic assignment operator, C provides many compound assignment operators which combine other operations with the basic assignment operation. For example, +=, -=, *=, /=, and % combine arithmetic operations with assignment. >>= , <<= &=, ^=, and |= combine bitwise operations with assignment.  These compound assignment operators work in the same sequence - the value of the variable on the left side of the operator works with the value on the right side of the operator, and then assign the result to the variable on the left side. For example, 

int a = 21;

a += 5;

The operation of a += 5 is equivalent to 

a = a + 5.

Similarly, a <<= 2 is similar to a = a << 2, where the right side works first, then assigns the result to the left side because assignment operator has a lower-level precedence than the bitwise operators. 

To better understand these assignment operators, let's work on a lab. 

Hands-on: Test assignment operators

Please enter the program below in the Online C Compiler (programiz.com), run and think of the results. Do they make sense to you? 

/*Test assignment operators*/

#include <stdio.h>


int main() {

   int a = 51;

   int c ;

   printf("originally, a = 51\n");

   c =  a;

   printf("if c = a, then c is %d\n", c );

   c +=  a; //c = c + a = 51 + 51 = 102

   printf("if c += a, then  c  must change to %d\n", c );

   c -=  a; //c = c - a = 102 - 51 = 51

   printf("if c -= a, then  c must equate  %d\n", c );

   c *=  a; // c = c * a = 51 * 51 = 2601

   printf("if c *=  a, then  c must equate  %d\n", c );

   c /=  a; // c = c/a = 2601/51 = 51

   printf("if c /=  a,  then c equates    %d\n", c );

   c = 100; 

   c %= a; // c = c%a = 100%51 = 49

   printf("if c = 100, c%= a,  then c must equate  %d\n", c);

   c <<= 2; // c = 49 = 0b00110001, c <<= 2 is c = c<<2 = 0b11000100 = 196

   printf("if c <<= 2, then  c must equate %d\n", c);

   c >>= 2; //c = 196 = 0b11000100, c>>=2 is c= c>>2 = 0b00110001 =49

   printf("if c >>= 2,  then c equates  %d\n", c);

   c &= 2; //c = c&2 = 0b00110001 & 0b00000010 = 0b00000000 = 0

   printf("if c &= 2, then  c shall equate %d\n", c);

   c ^= 2; //c = c^2 = 0b00000000 ^ 0b00000010 = 0b00000010 = 2

   printf("if c ^= 2, then  c must equate    %d\n", c);

   c |= 2; // c = c|2 = 0b00000010 | 0b00000010 = 0b00000010 = 2

   printf("if c |=  2; then c  equates  %d\n", c);

   

   return 0;

}

If nothing goes wrong, the result should look like:

originally, a = 51

if c = a, then c is 51

if c += a, then  c  must change to 102

if c -= a, then  c must equate  51

if c *=  a, then  c must equate  2601

if c /=  a,  then c equates    51

if c = 100, c%= a,  then c must equate  49

if c <<= 2, then  c must equate 196

if c >>= 2,  then c equates  49

if c &= 2, then  c shall equate 0

if c ^= 2, then  c must equate    2

if c |=  2; then c  equates  2

f. Other Operators 

Operators that are not categorized in the above groups are discussed here. These include type casting operator, sizeof operator, conditional operator, address operator, pointer operator, comma operator, structure pointer operator, subscript operator, function call operator, etc.

In C programming, the type casting operator is used to convert a variable from one data type to another data type. It was discussed in type casting earlier. It is viewed as a whole thing with its operand, so it is regarded as a right to left operator. 

In C programming language, the sizeof operator is a compile-time unary operator that can be used to compute the size of its operand. It returns the size of the data type of a variable in bytes. For example, 

int x = 10;

printf("%lu", sizeof(x)); // prints 4

The output is 4 because an integer takes 4 bytes of memory in C. 

The sizeof operator can be applied to any data type, including primitive types such as integer and floating-point types, pointer types, or compound datatypes such as Structure, union, etc.

sizeof operator is a unary operator and is considered a right to left operator.

In C programming language, the conditional operator is a ternary operator that works on three operands. It works similarly to the if-else statement (I will discuss soon) and executes the code based on the specified condition. The syntax of conditional operator is: 

testCondition ? expression1 : expression2;

The testCondition is a Boolean expression that shall conclude either true or false. If the condition is true - expression1 (before the colon) is executed; if it’s false - expression2 (after the colon) is executed. The conditional operator takes 3 operands (testCondition, expression1 and expression2). Hence, the name ternary operator.  Since it is viewed as a whole with its operands, it is also regarded as right to left operator. 

For example, 

int x = 10;

int  y = 5;

int z = (x > y) ? x : y; // z is now 10

z should be 10 because x > y is true, x is assigned to z. 

In C programming language, the address operator is a unary operator that returns the memory address of its operand. The address operator is denoted by the ampersand symbol (&). For example:

int x = 10;

printf("%p", &x); // prints the memory address of x

The output is the memory address of x in hexadecimal format.

The address operator can be used with any variable or array element in C.

The address operator is viewed as a whole thing with its operand, so that it is regarded as a right to left operator. 

A pointer is to store the memory address of another variable. When we declare a pointer variable, we use the pointer operator, asterisk (*) symbol, before the variable name. For example, 

int *p;

declares a pointer variable named p that can store the memory address of an integer variable. 

The pointer operator is also used to deference a pointer variable. To dereference a pointer variable means to access the value stored in the memory address pointed by the pointer. We use the asterisk (*) symbol before the pointer variable name to dereference it. For example, if p points to an integer variable, then *p is the value stored in that integer variable. 

Pointer operator is viewed as a whole thing with its operand, so that it is regarded as a right to left operator. 

I will specifically discuss pointer soon. 

In C programming language, the comma operator is a binary operator that evaluates its first operand and discards the result, and then evaluates the second operand and returns this value (and type). In C, the comma operator has the lowest precedence and should work after other operators are done. For example: 

int x = 10, y = 5;

int z = (x++, y++, x + y); // z is 17 because z = x + y = x++ + y++ = 11 + 6 = 17

z should be 17. In this example, the comma operator is used to increment x and y before adding them together. 

Comma operator is a left to right operator. 

In C programming, the structure pointer operator (->) is used to access a member of a structure or union through a pointer. It is a binary operator and has left to right associativity.

In C programming, the subscript operator ([ ])is used to access an element of an array. It is a binary operator and has left to right associativity. 

In C programming, the function call operator (( ))is used to call a function. It is a unary operator and has left to right associativity (the only left to right in unary operators). 

g. Operator Precedence

In C programming, operator precedence refers to the order in which operators are evaluated in an expression. It is very important in evaluate an expression's value. Operator precedence is listed in the table below:

Table 6. Operator precedence

From the above table, it is easy to see that comma operator has the lowest precedence, and postfix operators such as the function call operator, the subscript operator, the structure pointer operator, the post-increment operator, and the post-decrement operator have the highest precedence. 

Let's work on a lab to better understand operator precedence in C. 

Hands-on: Operator precedence

Please enter the following program in the Online C Compiler (programiz.com), run and observe the results. 

//Test operator precedence

#include <stdio.h>


main() {


   int a = 45;

   int  b = 35;

   int  c = 10;

   int d = 5;

   int e;

 

   e = (a + b) * c / d;      // 80 * 10 / 5 = 160

   printf("(a + b) * c / d shall equate : %d\n",  e );


   e = (a + (b * c)) / d;    // (45 + 350 ) / 5 = 79

   printf("(a + (b * c)) / d shall equate : %d\n" ,  e );


   e = (a + b) * (c / d);   // (80) * (10/5) = 80 * 2 = 160

   printf("(a + b) * (c / d) shall equate  : %d\n",  e );


   e = a + b * c / d;     //  45 + 350/5 = 45 + 70 = 115

   printf("a + b * c / d shall equate: %d\n" ,  e );

 

   return 0;

}

If there is nothing going wrong, the result should look like;

(a + b) * c / d shall equate : 160

(a + (b * c)) / d shall equate : 79

(a + b) * (c / d) shall equate  : 160

a + b * c / d shall equate: 115

4.Expressions 

In C programming language, an expression is anything that gives a value, such as an operand, or a combination of operand(s) and operator(s) that can be evaluated to a value. The operand can be a literal value, variable, constant, function, or another expression. The operator can be any of the operators as discussed above. 

Expressions may be categorized into a few types such as primary expressions, arithmetic expressions, logical expressions, conditional expressions, relational expressions, pointer expressions, and bitwise expressions. 

A primary expression is a building block of more complex expressions. It may be a literal value, named constant, variable, function, generic selection, keywords, or an expression in parentheses. A generic selection is an expression that selects one of several possible values based on the type of an expression. An expression in parentheses is an expression enclosed in parentheses. 

An arithmetic expression consists of arithmetic operators (+, -, *, /, %) and computes values of int, float, or double type. 

A relational expression consists of comparison operators (==, >, <, >=, <=) and computes the answer in the bool type, i.e., true (1) or false (0).

A logical expression consists of logical operators (&&, ||, !)  and combines relational expressions to compute answers in the bool type. 

A conditional expression consists of conditional statements (?:) that return true if the condition is met and false otherwise. 

A pointer expression may consist of an address operator (&) and returns address values. 

A bitwise expression consists of bitwise operators (>>, <<, ~, &, |, ^) and performs operations at the bit level. 

Let's work on a lab to better understand the types of expressions. 

Hands-on: C Expressions

Please enter the program below in the Online C Compiler (programiz.com). Run and observe the results. 

//Test C expressions

#include <stdio.h>


int main(){


  //Arithmetic Expression

  int a = (6 * 2) + 7 - 9;

  printf("The arithmetic expression returns: %d\n", a);


  //Relational Expression

  int b = 10;

  printf("The relational expression returns: %d\n", b % 2 == 0);


  //Logical Expression

  int c = (7 > 9) && ( 5 <= 9);

  printf("The logical expression returns: %d\n", c);


  //Conditional Expression

  int d = (34 > 7) ? 1 : 0;

  printf("The conditional expression returns: %d\n", d);


  //Pointer Expression

  int e = 20;

  int *addr = &e;

  printf("The pointer expression returns: %p\n", addr);


  //Bitwise Expression

  int f = 10;

  int shift = 10 >> 1;

  printf("The bitwise expression returns: %d\n", shift);


  return 0;

}


If nothing wrong, the result should look like:

The arithmetic expression returns: 10

The relational expression returns: 1

The logical expression returns: 0

The conditional expression returns: 1

The pointer expression returns: 0x7ffedc786e2c

The bitwise expression returns: 5

5. Statements and Blocks 

A statement in a program is like a sentence in English. It is the smallest complete executable unit. A statement consists of expressions and /or keywords and ends with a semicolon (;). 

There are five types of statements in C programming language:

i. Declaration statements

ii. Expression statements

iii. Jump statements

iv. Selection statements

v. Iteration statements

vi. Compound statements

a. Declaration statements 

In C programming language, a declaration statement is a statement formed from a primary expression of declaration that introduces one or more identifiers into the program and specifies their meaning and properties.

In C programming language, a declaration statement is used to declare a variable, a named constant, or a function. The syntax of a declaration statement looks like:

data_type variable_name; //declare a variable

or

data_type variable_name = initial_value; //declare a variable with initial value

or 

data_type function_name(parameter_list); //declare a function prototype

For example,

int my_var = 0;

In this example, variable my_var is declared with initial value 0. 

b. Expression statements 

In C programming language, an expression statement is a statement that consists of an expression followed by a semicolon. The execution of such a statement will get an evaluated result of the expression. Most C programs' statements are expression statements. 

Here are some examples of expression statements in C: 

a = 5; // assignment statement formed from assignment expression

printf("Hello World!"); // function call statement from a function call expression

x++; // increment statement from arithmetic expression

c. Jump statements 

In C programming language, a jump statement is a statement that causes the program to transfer control to another part of the program. 

The four types of jump statements in C are:

The goto statement in C is a jump statement that is used to jump from one part of the code to any other part of the code in C. It helps in altering the normal flow of the program according to our needs. The goto statement can be used to jump from anywhere to a specified place in a function. When the C compiler reaches the goto statement, it will jump unconditionally (both forward and backward) to the location specified in it (we called it as a label). However, it is highly discouraged as the goto statement makes the program logic very complex and makes tracing the flow of the program very difficult. The use of goto makes it hard to analyze and verify the correctness of programs. The use of goto can be simply avoided by using break and continue statements. 

The goto statement is formed from goto primary expression. For example (please test it in the Online C Compiler (programiz.com)),

#include <stdio.h>


int main() {

   int i = 0;


   loop:  //label

      printf("%d\n", i);

      i++;

      if (i < 10) {

         goto loop; //goto statement

      }


   return 0;

}

In this example, the goto statement transfers control back to the beginning of the statement labeled “loop”. 

The break statement is used to stop continuing to execute a loop. The break statement is formed from break primary expression. For example (please test it in the Online C Compiler (programiz.com)), 

#include <stdio.h>


int main() {

   for (int i = 0; i < 15; i++) {

      if (i == 5) {

         break;  //break statement

      }

      printf("%d\n", i);

   }


   return 0;

}

In this example, the break statement is used to exit the loop when the value of i is equal to 5. The result should be 

0

1

2

3

4

The continue statement is used to skip the current iteration of a loop and move on to the next iteration. It is formed from continue primary expression. For example (please test it in the Online C Compiler (programiz.com)),

#include <stdio.h>


int main() {


   for (int i = 0; i < 15; i++) {

      if (i == 5) {

         continue; //continue statement

      }

      printf("%d\n", i);

   }


   return 0;  //return statement

}

In this example, the continue statement is used to skip the loop when the value of i is equal to 5, and continue the next cycle of the loop. The result should be 

0

1

2

3

4

6

7

8

9

10

11

12

13

14

The return statement returns a value from inside a function. The return statement is formed from a return primary expression as we can see from the above example. 

The goto statement is harmful and should not be applied in programming practice. The other three jump statements are used in loops and functions to control the flow of execution. We will see more of their usage and examples when we discuss loops and functions. 

d. Selection or conditional statements 

In C programming language, selection statements are used to control the flow of execution based on the value of an expression.

The two types of selection statements in C are if- statement and switch statement:

i. if statement

An if statement is a selection statement that allows for conditional execution of code based on the value of an expression. For example (please test it in the Online C Compiler (programiz.com)),

#include <stdio.h>


int main() {

   int x = 5;

      //the statement below is an example of if-statement

   if (x == 5) {

      printf("x is equal to 5\n");

   }


   return 0;

}

As shown in the example, if statement consists of three parts:

1) the if keyword.

2) the conditional expression enclosed in a pair of parentheses.

3) the if statement body enclosed in a pair of curly brackets. When the if statement body consists of only a single statement, the curly brackets can be omitted such as 

if(x==5) printf("x is equal to 5\n");

Often, keywords if and else combine to form multiple branches or nested if statements, which we will see more examples when we discuss control structures later. 

ii. switch statement

In C programming language, switch statements are used to control the flow of execution based on the value of an expression. For example (please test it in the Online C Compiler (programiz.com)),

#include <stdio.h>


int main() {

   int x = 2;

   //Example of a switch statement

   switch (x) {

      case 1:

         printf("x is equal to 1\n");

         break;

      case 2:

         printf("x is equal to 2\n");

         break;

      default:

         printf("x's value is not 1 or 2\n");

   }


   return 0;

}


As shown in the example, the switch statement consists of three parts:

1) the switch keyword.

2) the conditional expression enclosed in a pair of parentheses.

3) the switch statement body enclosed in a pair of curly brackets. The switch statement body consists of one or more case branches and end with a default branch. A case branch consists of a case header and  a case body. The case header is in the form of 

case value:

It consists of keyword case and a possible value of the conditional expression in the parentheses. In this example, 1 and 2 are the possible values of x. The case header ends with colon (:).

The case body consists of a few statements, which can be any types of statements. In this example, there is only a printf() statement in a case. The case body ends with a break statement, which stop continuing to execute the other branches below. 

The default branch is the last branch in the switch body, which shall be executed once no case branch meets the condition. 

The main difference between if statements and switch statements is that if  statements are used when there are only two conditions to check, whereas switch statements are used when there are multiple conditions to check. 

e. Loop or iterative statements 

Iterative statements in C are used to execute a block of code repeatedly for a specified number of times or until a condition is met. They change the control flow of the program so that they can also be classified as control statements in C . There are three types of iterative statements in C: For Loop, While Loop and Do-while loop. A loop consists of three parts: conditional value initialization, test expression of condition, and increment/decrement or update the conditional value. For different types of loops, the conditional expressions might be at various places of the loop. 

i. For loop

The For Loop is one of the three types of iterative statements in C. It is the most commonly used loop because it has all the three parts of the loop in the one line. The syntax of a for loop look like: 

for(initialization; test expression; update expression) {

//body of loop

}

A for loop consists of three parts:

1) the keyword for.

2) the condition enclosed in a pair of parentheses.

3) the for loop body enclosed in a pair of curly brackets.

The condition consists of three parts: the initialization, the test expression, and the update expression. 

The initialization part is executed only once at the beginning of the loop. It is the entry condition to enter the loop. 

The test expression is evaluated at the beginning of each iteration. If it is true, then the body of the loop is executed. otherwise, the program execution moves on to the next statement following this for loop. 

After each iteration, the update expression is executed before evaluating the test expression again. 

The for-loop body consists of a number of other statements. When there is zero or one statement in the for loop, the curly brackets can be omitted. 

Here's an example of a for loop:

#include <stdio.h>


int main() {

   int i;

   //for loop

   for (i = 1; i <= 5; i++) {

      printf("%d\n", i);

   }

   return 0;

}

This program initializes the variable i to 1, then tests whether i is less than or equal to 5. If it is, it executes the body of the loop (which prints the value of i), then increments i by 1. It repeats this process until i is no longer less than or equal to 5. 

ii. While loop

The while loop is another type of iterative statement in C. It executes the statement(s) in the loop body as long as a given condition is true. The syntax of a while loop in C looks like:

while (condition) {

   statement(s);

}

A while loop consists of three parts:

1) the keyword while.

2) the condition enclosed in a pair of parentheses.

3) the while loop body enclosed in a pair of curly brackets.

The condition is of expression that produces a Boolean result, true or false. In C, false is 0, true is any nonzero value. 

The while loop body, statement(s), may be a single statement or multiple statements. Below is an example of while loop:

#include <stdio.h>


int main() {

   int i = 1;

  //while loop statement

   while (i <= 5) {

      printf("%d\n", i);

      ++i;

   }

   return 0;

}

This program initializes the variable i to 1, then tests whether i is less than or equal to 5. If it is, it executes the body of the loop (which prints the value of i), then increments i by 1. It repeats this process until i is no longer less than or equal to 5.

iii. Do-while loop

The do-while loop is another one of the three iterative statements in C. It is popularly used to traverse arrays, vectors, and some other data structures. The do-while loop is similar to the while loop but the body of do-while loop is executed at least once and then, the test expression is evaluated. The syntax of the do...while loop looks like:

do {

   statement(s);

} while (condition);

Do-while loop consists of three parts:

1) the keyword do.

2) the loop body enclosed in the curly brackets.

3) the while condition with the keyword while and condition enclosed in a pair of parentheses. 

Please note that the conditional expression is at the end of the loop, so the statement(s) in the loop executes once before the condition is tested. 

Here's an example of a do-while loop that prompts the user to enter a number (please test it in the Online C Compiler (programiz.com)):

#include <stdio.h>

int main() {

   double number, sum = 0;

   

   do {// The loop body is executed first

      printf("Enter a number: ");

      scanf("%lf", &number);

      sum += number;

   } while(number != 0.0); // The test expression is evaluated

   printf("Sum = %.2lf",sum);

   return 0;

}

This program prompts the user to enter a number, then it tests the conditional expression. The loop shall work until the input number is 0. The do-while loop executes at least once because the first iteration executes without checking the condition. 

f. Compound statements 

A compound statement is a group of statements that are enclosed in curly braces `{}`. It is used where multiple statements are required. The compound statement is treated as a single statement by the compiler. The syntax of a compound statement looks like:

{

   statement1;

   statement2;

   .

   .

   .

   statementN;

}

That is, a group of statements enclosed in a pair of curly brackets. Here, statement1, statement2, ..., statementN are any valid C statements as discussed above. The compound statements can be nested in another compound statements. 

The compound statements are usually used as a structure body, function body, loop body, selection statement body, and so on. 

g. Blocks 

A block in C is a set of statements written within a pair of curly braces ({}). A block may contain other blocks within itself, that is, nested blocks. A variable declared inside a block has a block scope and is accessible inside the block and its inner blocks.

A compound statement is actually a block. 

6. Arrays 

An array in C is a collection of similar data items stored in contiguous memory locations. The data items in an array can be of primitive data types such as int, char, float, etc., and also derived and user-defined data types such as pointers, structures, and so on. The elements of an array are accessed by their index number. The index number starts from 0 and goes up to (size of the array - 1). The size of an array must be specified at the time of declaration.

Arrays are used in C for a variety of reasons. They are used to store a collection of similar data items. They are also used to store the collection of derived and user-defined data types such as pointers, structures, etc. Arrays are also used to pass a large number of arguments to functions. They are also used to implement other data structures such as stacks, queues, and trees.

The syntax of declaring an array in C is:

type arrayName[arraySize];

Here, type is the type of data that the array will hold. arrayName is the name of the array, and arraySize is the number of elements that the array can hold. For example, 

int numbers[5];

This declares an array called numbers that can hold 5 integers. 

Once an array is declared, its elements  are accessed by their index numbers. The index number starts from 0 and goes up to (size of the array - 1). For example,

int numbers[7] = {1, 2, 3, 4, 5, 6, 7};// An array of 7 int items is declared and initialized

printf("%d", numbers[0]);// The first item is printed

This prints the first element of the array, which is `1`.

We can easily loop through an array with a for loop. For example, 

int numbers[7] = {1, 2, 3, 4, 5, 6, 7};

for (int in = 0; in < 7; in++) {

   printf("%d\n", numbers[in]);

}

This program shall print all the seven elements of the array. 

Arrays are popularly used in processing a group of same type of data. For example, we want to sum up a group of integers, we can use array to easily implement it. 

#include <stdio.h>

int main() {

  int numbers[7] = {1, 2, 3, 4, 5, 6, 7};

  int sum = 0;

  for(int in = 0; in < 7; in++) {

    sum += numbers[in];

  }

  printf("The sum of all the elements of the array is %d", sum);

}

This program creates an array of integers called numbers with five elements and initializes them with values from 1 to 5. It then uses a for loop to iterate over the array and add up all the values. Finally, it prints out the sum of the array. 

In C programming, we can create an array of arrays, which is known as multidimensional arrays. For example, 

float x[2][3];

Here, x is a two-dimensional (2d) array. The array can hold 6 elements. You can regard this array as a table that has 2 rows and has3 columns in a row, which looks like

x[0][0] x[0][1] x[0][2]

x[1][1] x[1][2] x[1][2]

To access an element from the multidimensional array, add the index for the element you want. For example, x[1][2] will access the element at the second row and the third column of the array. You can also use a for loop or for each loop to access multiple elements in a multidimensional array.

We can use a nested for loops (one for loop inside another for loop) to access elements of a multidimensional array in C. Here is an example of how to use a for loop to initialize each member of a 2D array one by one:

int x [2] [3];

for (int ind1 = 0; ind1 < 2; ind1++) {

  for (int ind2 = 0; ind2 < 3; ind2++) {

    x [ind1] [ind2] = ind1 + ind2;

  }

}

This method is useful when the value of each element has some sequential relation. 

7. Strings

Strings are used in C programming language to represent text such as words and sentences. They are also used to manipulate text data. For example, you can use strings to store user input or read data from a file. Strings are also used in functions such as printf() and scanf(). 

In C programming language, a string is an array of characters that is terminated by a null character \0 (this character is viewable in the text). A string can be declared as an array of characters (V, 2019) . For example:

char str[] = "Hello World!";

Here, str is an array of 13 characters. The null character `\0` automatically gets added at the end of the string.

We can process strings in C using various string functions such as strlen(), strcpy(), strcat(), and strcmp(). These functions are defined in the string.h header file. You can also use loops to iterate over the characters in a string and perform operations on them.  For example:

#include <stdio.h>

#include <string.h>

int main() {

  char str[100];

  int len;

  printf("Enter a string: ");

  scanf("%s", str);

  len = strlen(str);

  printf("The string length is %d.\n", len);

  return 0;

}

This program reads a string from the user using scanf() and then uses the strlen() function to find the length of the string. The length of the string is then printed to the console.

Here is another example about processing string: 

#include <stdio.h>

#include <string.h>

int main() {

  char str1[100] = "Hello ";

  char str2[] = "World!";

  strcat(str1, str2);

  printf("%s", str1);

  return 0;

}

This program concatenates two strings using strcat(): "Hello " and "World!". The result is stored in the first string str1. The output of this program is "Hello World!". 

8. Math's 

The advantages of math processing in C include the ability to perform complex mathematical calculations and operations quickly and accurately. This is especially useful in scientific and engineering applications where precise calculations are required. C also provides a wide range of math functions that can be used to perform various mathematical tasks such as calculating square roots, exponents, and trigonometric functions. 

Besides arithmetic operators such as +, -, *, /, and % to perform basic math operations, C provides various math functions such as sqrt(), pow(), sin(), cos(), tan(),floor(), ceil(), fabs(), rand(), srand(), etc.. These functions are defined in the math.h header file. 

Here is an example of how to use math processing in C (please test it in the Online C Compiler (programiz.com)):

#include <stdio.h>

#include <math.h>

int main() {

  double x = 2.0;

  double y = sqrt(x);

  printf("The square root of %f is %f.\n", x, y);// Display a string that contains two float variables. 

  return 0;

}

This program calculates the square root of a number using the sqrt() function from the math.h header file. The output of this program shall be "The square root of 2.000000 is 1.414214."

Here is an example of how to use the floor() and ceil() functions in C (please test it in the Online C Compiler (programiz.com)): 

#include <stdio.h>

#include <math.h>


int main() {

    double num = 8.33;

    int myCeiling, myFloor;


    myCeiling= ceil(num);

    printf("Ceiling integer of %.2f = %d\n", num, myCeiling);


    myFloor= floor(num);

    printf("Floor integer of %.2f = %d\n", num, myFloor);


    return 0;

}

This program uses the ceil() and floor() functions to find the ceiling and floor integers of a given floating-point number. 

Here is an example of how to use the rand() function in C: 

#include <stdio.h>

#include <stdlib.h>

#include <time.h>


int main() {

    printf("%d ", rand());

    printf("%d", rand());

    return 0;

}

This program generates two random numbers using the rand() function. 

9. Input/Output 

C programming language provides several functions for input and output operations. The functions used for standard input and output are present in the stdio.h header file. To use those functions, we need to include the stdio.h header file in our program. The following two streams are used while dealing with input-output operations in C: 

i. Standard Input (stdin)

ii. Standard Output (stdout)

Standard input or stdin is used for taking input while standard output or stdout is used for giving output. 

The printf() function is one of the main output functions in C programming language. The function prints formatted text to the screen. The syntax of printf() function in C programming language is:

printf("format string", argument_list);

Here, "format string"  is a string that contains text to the output and may contain format specifiers for variables to display. The argument_list are the variable names corresponding to the format specifiers. For example, 

printf("Ceiling integer of %.2f = %d\n", num, myCeiling);

This statement applies printf() function to display a string with format specifiers %.2f for a float num and %d for an integer myCeiling.  

The scanf() is a function used to receive input from the user. The scanf() function reads formatted input from the standard input, generally, the keyboard.  The syntax of scanf() function in C programming language is: 

scanf("format string", &argument_list);

Here, "format string" is a string that contains the format specifier(s), and &argument_list is a list of addresses of the specified variables. 

Format specifiers used in both printf() and scanf() are special operators that define the type of data to be printed on standard output with printf() function. They start with a percent (%) character and may have arguments of their own. A complete list of format specifiers is in table 1 above. 

Some of the commonly used format specifiers in C are listed below:

i. `%d` - integer

ii. `%f` - float

iii. `%c` - character

iv. `%s` - string

v. `%p` - pointer

For example, if you want to print an integer value using printf() function, you can use the `%d` format specifier. Similarly, if you want to read an integer value using scanf() function, you can use the `%d` format specifier. 


To limit the decimal digits printed with printf(), we can specify the precision field in the format specifiers. The precision field specifies the maximum number of characters to be printed for the corresponding argument. For example, 

printf("%.2f", 3.14159);


This will print the value with only two decimal places. 


scanf() reads characters from the input stream until it encounters a whitespace character (space, tab, newline) or until it reaches the end of the input stream. 

Here is an example of using scanf() and printf() functions in C programming language:

#include <stdio.h>

int main() {

   float num;

   printf("Enter a number: ");

   scanf("%f", &num);

   printf("The number is: %.3f", num);

   return 0;

}

This program reads in a float value from the user and displays it with 3 decimal places on the screen.

Beside printf() and scanf(), C provides two other popularly used functions for input and output: putchar() and getchar(). 

The putchar() function writes a single character to the standard output stream. It takes a single argument of type int which represents the character to be written. While getchar() reads a single character from the standard input stream and returns it as an integer value.  

Here is an example of using getchar() and putchar() input and output in C programming language:

#include <stdio.h>

int main() {

   int c;

   printf("Enter a value: ");

   c = getchar();

   printf("\nYou entered: ");

   putchar(c);

   return 0;

}

This program takes an input from the user and displays it on the screen. 

10. Control Structures 

In programming, control structures are used to specify the flow of control in a program. They are used to analyze and choose in which direction a program flows based on certain parameters or conditions. There are three fundamental types of flow of control, or logic, known as:

- Sequence logic, or sequential flow

- Selection logic, or conditional flow

- Iteration logic, or repetitive flow

In C programming language, sequential flow is the default flow of execution. The program executes one statement after another in their order as in the source code of a function. 

Conditional flow and repetitive flow change the default sequential flow in a program. 

C provides three main control structures to implement the conditional flow and the repetitive flow: decision-making control structure, looping control structure, and unconditional control structure. 

Decision-making control structure allows you to execute one set of statements when an expression is true and another set of statements when the expression is false. This control structure implements conditional flow using conditional statements such as if, if-else, nested if-else, and switch statements. If there is some condition for a block of statements, the execution flow may change according to the evaluated result of the conditional expression. An example of an if-else statement is below:

#include<stdio.h>

int main(){

   int num = 10;

    if(num > 0) {

      printf("%d is a positive number\n", num);

   }

   else{

      printf("%d is a negative number\n", num);

   }

    return0;

}

In this example, the program checks whether the variable num is greater than zero. If it is, the program prints a string saying that number is a positive number. Otherwise, it prints another string saying that number is a negative number (programiz.com).

Looping control structure allows you to execute a set of statements repeatedly while a condition is true. This control structure implements repetitive flow using looping statements such as for loop, while loop and do-while loop. For examples of looping control structure, please refer to section 5.e. Loop or iterative statements. 

Unconditional control structure allows you to jump to another part of the program. This control structure is implemented using jump statements such as goto, break, continue, and return. While break, continue, and return are very useful in helping make conditional flow and repetitive flow, goto statements bring much negative effects in programming because they make the code harder to read and understand and can also make the code more difficult to maintain and debug. For these reasons, it is generally recommended to avoid using goto statements. For examples of unconditional control structure, please refer to section 5.c. Jump statements. 

11. Pointers 

In C programming language, a pointer is a variable that stores the memory address of another variable. Pointers are used in C programming language for a variety of purposes such as:

The * operator is used to declare a pointer:

int *ptr;

This declares a pointer variable called ptr that can point to an integer value. 

To use the pointer, you can assign it the address of another variable using the & operator. Here is an example: 

int var = 5;

int *ptr = &var;

This assigns the address of var to the pointer variable ptr. You can then use the pointer to access the value stored in var using the * operator. Here is an example: 

printf("%d", *ptr);

This prints the value stored in var, which is 5. 

Here is an example of how to use a pointer to process an array in C: 

int arr[3] = {1, 2, 3};

int *ptr = arr;

for(int index = 0; index < 3; index++) {

    printf("%d ", *(ptr + index));

}

This assigns the address of the first element of the array arr to the pointer variable ptr and then prints all the elements of the array using the * operator. 

12. Memory Handling

Memory handling in C refers to the process of allocating and deallocating memory during program execution. This is typically done using functions such as malloc(), calloc(), realloc(), and free() in header file stdlib.h. 

In C programming language, the heap and stack are two regions of memory used for memory allocation. The heap is used for dynamic memory allocation and the stack is used for static memory allocation. 

The stack is a region of memory used to store local variables and function call information. When a function is called, the stack is used to store the return address and the values of the function’s parameters and local variables. For example, 

#include <stdio.h>

int main() {

    int x = 5;

    printf("%d\n", x);

    return 0;

}

This program automatically uses the stack to store the value of the variable x. 

In C programming language, the stack is organized as a LIFO (Last In First Out) data structure. Data stored in an Array can mimic the LIFO operation on a stack by incrementing the index to store a data in the array or decrementing the index to fetch a data from the array. For example (please test it in the Online C Compiler (programiz.com)), 

#include <stdio.h>

#include <stdlib.h>


int main() {

    int stack[5];

    int top = -1;


    // Push operation

    stack[++top] = 5;


    // Pop operation

    int item = stack[top--];


    return 0;

}

However, we can define functions, push() and pop(), to implement operations on a stack. Function push() is used to store a data on to a stack, and function pop() is used to fetch a data from the stack. For example (please test it in the Online C Compiler (programiz.com)),

#include <stdio.h>


// Define a struct for stack elements

typedef struct stack_element {

  int data; // The data stored in the element

  struct stack_element *next; // A pointer to the next element in the stack

} stack_element;


// Define a struct for stack

typedef struct stack {

  int size; // The number of elements stored in the stack

  stack_element *top; // A pointer to the top element of the stack

} stack;


// Initialize an empty stack

stack *create_stack() {

  stack *s = malloc(sizeof(stack)); // Allocate memory for the stack

  s->size = 0; // Set the size to zero

  s->top = NULL; // Set the top to NULL

  return s; // Return the stack

}


// Defining function push*() that stores an element to the top of the stack

void push(stack *s, int data) {

  stack_element *e = malloc(sizeof(stack_element)); // Allocate memory for the element

  e->data = data; // Set the data of the element

  e->next = s->top; // Set the next of the element to the current top of the stack

  s->top = e; // Set the top of the stack to the new element

  s->size++; // Increment the size of the stack

}


// Defining function pop() that removes an element from the top of the stack and return its data

int pop(stack *s) {

  if (s->size == 0) { // If the stack is empty, return -1 as an error code

    return -1;

  }

  int data = s->top->data; // Get the data of the top element

  stack_element *e = s->top; // Get a pointer to the top element

  s->top = s->top->next; // Set the top of the stack to the next element

  free(e); // Free the memory of the popped element

  s->size--; // Decrement the size of the stack

  return data; // Return the data of the popped element

}


int main(){

    printf("To create a stack\n");

   

    stack *myStack = create_stack();

   

    push(myStack, 1);

    push(myStack, 2);

   

    int top1 = pop(myStack);

    printf("The top value is %d\n", top1);

   

    int top2 = pop(myStack);

    printf("The second top value is %d\n", top2);

   

    return 0;

   

}

The output shall be:

To create a stack

The top value is 2

The second top value is 1


This program shows how to build the structure of a stack, and how to define functions push() and pop(). In the main() function, a stack called myStack is declared, and then pushed 1 and 2 onto myStack by using function push(). After that, it uses function pop() to pop the two data from the stack. Since 2 is on top of 1, the result show the sequence 2 and 1. From this example, we can see the FILO sequence of data in a stack. 

In C programming language, the heap is a region of memory used for dynamic memory allocation, which allocates memory during program execution.  Heap is useful when it is necessary to repeatedly remove the object with the highest (or lowest) priority, or when insertions need to be interspersed with removals of the root node, which are the cases of dynamically allocate and deallocate memory for multiple programs to run in an operating system. 

In C, malloc() is used for dynamic memory allocation. It is useful when you don’t know the amount of memory needed during compile time. calloc() is also used for dynamic memory allocation. It is similar to malloc() but it initializes the allocated memory with zeros. realloc() is used to resize the previously allocated memory.  free() is used to deallocate memory that was previously allocated by malloc(), calloc(), or realloc(). 

Here is an example of using calloc() in C (please test it in the Online C Compiler (programiz.com)): 

#include <stdio.h>

#include <stdlib.h>


int main() {

  int *ptr;

  int n = 5;

  ptr = (int*)calloc(n, sizeof(int));

  if (ptr == NULL) {

    printf("Memory not allocated.\n");

    exit(0);

  } else {

    printf("Memory successfully allocated using calloc.\n");

    for (int seq= 0; seq< n; ++seq) {

      ptr[seq] = seq+ 1;

    }

    printf("The stored elements of the array are: ");

    for (int seq= 0; seq< n; ++seq) {

      printf("%d, ", ptr[seq]);

    }

  }

  free(ptr);

  return 0;

}

Here is an example of multiple memory allocations in C (please test it in the Online C Compiler (programiz.com)): 

#include <stdio.h>

#include <stdlib.h>


int main() {

  int *ptr1, *ptr2;

  int num1 = 13, num2 = 17;

  ptr1 = (int*)calloc(num1, sizeof(int));

  ptr2 = (int*)calloc(num2, sizeof(int));

  printf("Memory successfully allocated using calloc.\n");

  free(ptr1);

  free(ptr2);

  return 0;

}

13. Files

a. General introduction of files 

In C, files are needed to store data on secondary drives. Memory stores data temporarily and loses data when a program terminates. Files stores data permanently even if the program terminates because files are stored on secondary drives such as hard drive, CD/DVD, SSD, etc. 

From the perspective of what file content is stored, there are text files and binary files.  A text file contains data in the form of ASCII characters. Each line in a text file ends with a new line character (‘\n’). It can be read or written by any text editor. A binary file contains data in binary form (i.e. 0’s and 1’s) instead of ASCII characters. They contain data that is stored in a similar manner to how it is stored in the main memory. The binary files can be created only from within a program and their contents can only be read by a program (www.geeksforgeeks.org, 2023) .

From the perspective of how a file content is read/write, there are sequential access and random access. With sequential access, the file has to be rewound to the beginning and data is read from or written to a location count from the beginning in a manner like using a tape. With random access, the data can be read from any were and written to anywhere in the file.

The general steps in processing a file are: 

i. Declare a file pointer variable.

ii. Open a file using fopen() function.

iii. Process the file using the suitable function.

iv. Close the file using fclose() function.

C provides multiple file handling functions like file creation, opening and reading files, writing to the file, searching inside of the file, and closing a file.  These operations can be performed using different functions such as fopen(), fwrite(), fread(), fseek(), fprintf(), fclose(), etc. They are all defined in <stdio.h> header file. Before I give examples of how to process files in C, I'd like to list the prototypes of these functions for reference. 

Note: A function prototype is a statement that tells the compiler about the function’s name, its return type, numbers and data types of its parameters. By using this information, the compiler cross-checks function parameters and their data type with function definition and function call. 

You can skip to the next section about handling sequential files if you are not interested in the syntax right now. You can refer them back when you need. 

The prototype of fopen()function in C is:

FILE *fopen(const char *filename, const char *mode);

This function opens a file and returns a pointer to the file. Here is what each parameter means:

i. "r": Open for reading. The file must exist.

ii. "w": Open for writing. If the file exists, its contents shall be over-written. Otherwise, it shall be created.

iii. "a": Open for appending. If the file exists, the data shall be written at the end of the file. Otherwise, it shall be created.

iv. "r+": Open for reading and writing. The file must exist.

v. "w+": Open for reading and writing. If the file exists, its contents shall be over-written. Otherwise, it shall be created.

vi. "a+": Open for reading and appending. If the file exists, the data shall be written at the end of the file. Otherwise, it shall be created.

The fopen() function shall return a pointer to the file stream. A null pointer is returned if the file cannot be opened.

The prototype of fwrite() function in C is:

size_t fwrite(const void *ptr, size_t size, size_t count, FILE *stream);  (fwrite C Library Function (techcrashcourse.com) ) 

This function writes data to a file. Here is what each parameter means:

The total number of elements successfully returned are returned as a size_t object, which is an integral data type.

The prototype of fread() function in C is as follows: 

size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);  (www.tutorialspoint.com) 

This function read data from a file. Here is what each parameter means:

The prototype of fseek() function in C is as follows:

int fseek(FILE *stream, long int offset, int whence); (www.tutorialspoint.com)

The fseek() function in C is used to move the file pointer position to a specific location within the file. Here is what each parameter means:

The function returns 0 if successful.

The prototype of fprintf() function in C is as follows: 

int fprintf(FILE *stream, const char *format, ...);

The function returns the number of characters written to the output stream. Here is what each parameter means:

The prototype of fclose() function in C is as follows: 

int fclose(FILE *stream);

This function closes the currently opened file. Here is what the parameter means:

The function returns 0 if successful.

b. Handling sequential files 

Here is an example code snippet that reads and prints the contents of a sequential file:

#include <stdio.h>

int main() {

    FILE *fp;

    char ch;


    fp = fopen("file.txt", "r"); //open file.txt for reading

    if (fp == NULL) {//if the file pointer points to null, print error and return 1

        printf("Error opening file\n");

        return 1;

    }


    while ((ch = fgetc(fp)) != EOF) {//read file using fgetc() until end of file

        printf("%c", ch);//print the char

    }


    fclose(fp); //close the file

    return 0;

}

This code opens the file "file.txt" in read mode using fopen()function. It then reads the contents of the file using fgetc() function and prints them to the console using printf() function. Finally, it closes the file using fclose() function.()

Note: in order to correctly run this program, you should run it on your locally installed C compiler (or IDE such as Microsoft Visual Studio Code) and create a file named file.txt. The online C compiler shall not point to a local file without a path to point to. 

Note: Standard C library function fopen() is used to open a file. It returns a pointer to a FILE structure so that the file variable fp should be a pointer. 

Note: In C, EOF is a constant integer value that means "End of File".

c. Handling random access files

Here is an example code snippet that reads and prints the contents of a random-access file:

#include <stdio.h>


int main() {

    FILE *fp;

    char ch;


    fp = fopen("myFile.txt", "r+"); //open a file for reading and writing

    if (fp == NULL) {//if the file pointer is null, print error and return 1

        printf("Error opening file\n");

        return 1;

    }


    fseek(fp, 5, SEEK_SET); //moves the file pointer to the 5th byte from the beginning of the file.  

    ch = fgetc(fp); //reads a single character from the file  pointed to by fp

    printf("%c\n", ch); //print the character


    fseek(fp, -2, SEEK_CUR); //moves the file pointer 2 bytes back from the current position.  

    ch = fgetc(fp); //reads a single character from the file

    printf("%c\n", ch); //print the character


    fclose(fp); //close the file

    return 0;

}

This code opens the file "myFile.txt" in read/write mode using fopen()function. It then uses fseek() function to move the file pointer to a specific location within the file. It then reads the contents of the file using fgetc() function and prints them to the console using printf() function. Finally, it closes the file using fclose() function.

Note: in order to correctly run this program, you should run it on your locally installed C compiler (or IDE such as Microsoft Visual Studio Code) and create a file named myFile.txt. The online C compiler shall not point to a local file without a path to point to. 

Note: please refer back to section "General introduction of files" above for constants SEEK_SET, SEEK_CUR, and SEEK_END.  They are the third argument to the function fseek() to specify the reference position in the file. 

14. Functions 

Functions in C are self-contained blocks of code that perform a specific task. They are application of "divide and conquer" technique in programming that break down a large program into smaller and more manageable pieces. They make the code more modular and easier to read and maintain. Functions can also be reused in different parts of the program or in different programs altogether.

a. The Syntax 

Here is the syntax of how a function is defined in C:

type function_name(parameter list) {

   // function body

}

Here is what each part means:

Here is an example of a function that returns an integer in C:

#include <stdio.h>


int add(int a, int b) {

    return a + b;

}


int main() {

    int sum = add(3, 5); //call the user defined function add(), assign its value to sum.

    printf("The sum is %d\n", sum);

    return 0;

}

This code defines a function called add() that takes two integer arguments and returns their sum. The function is then called from the main()function and the result is printed to the console.

Here is an example of a void function in C:

#include <stdio.h>

void add(int i, int j) //this function does not return a value, so it is void

{

   printf("%d + %d = %d", i, j , (i+j));

}

int main()

 {

     int i,j;

     i = 1;

     j=2;

     add( i, j); //call the function add(). Since it is void, it cannot be assigned to a variable

     return 0;

 }

This function takes two integer arguments and returns nothing. It simply prints the sum of the two integers passed to it. 

b. Function prototype 

In C programming language, a function prototype is a declaration of a function that specifies the function's name and type signature (arity and types of arguments) but omits the function body.  The syntax of function prototype in C programming is as follows: 

type function_name (type argument1, type argument2,...);

Here, type is the data type of the value returned by the function. function_name is the name of the function. type is the data type of the arguments passed to the function. The arguments are optional. If there are no arguments, then an empty pair of parentheses is used. If there are multiple arguments, commas are applied to separate them.  The semicolon at the end of the prototype is required. 

It is used to tell the compiler about the existence of a function before it is actually defined. This is useful when a program calls a function before its definition. The prototype serves as an agreement between the caller and the callee about what the function will do and what arguments it will take, helps in detecting errors at compile-time rather than at runtime. Using function prototype allows declaration of functions being placed in header files, so that they can be compiled separately from programs and be called by programs as a library. 

Here is an example of using function prototype in C programming language (please test it in the Online C Compiler (programiz.com)):

#include <stdio.h>


// Function prototype

int add(int x, int y);


int main() {

    int a = 10;

    int b = 20;

    int sum = add(a, b);

    printf("The sum of values %d and %d is %d\n", a, b, sum);

    return 0;

}


// Function definition

int add(int x, int y) {

    return x + y;

}


In this example, we have declared a function prototype for the add() function before the main() function. The prototype tells the compiler that the add() function takes two integer arguments and returns an integer value. The add() function definition is actually placed after the main() function.

c. Pass by value vs. pass by reference 

In C programming language, there are two ways to pass arguments to a function: pass by value and pass by reference.

Pass by value means that the function receives a copy of the argument’s value. Any changes made to the parameter inside the function have no effect on the original argument.

Pass by reference means that the function receives a reference to the original argument. Any changes made to the parameter inside the function shall affect the original argument.

In C, pass by value is used by default. To pass an argument by reference, you should use a pointer.

Note: an argument is a value that is passed to a function when the function is called, while a parameter is a variable in the declaration of a function. The parameter is used to receive the argument that are passed during a function call. 

For example, the above program is an example of pass by value: arguments a and b are passed to parameters x and y in function add(int x, int y). Values of a and b are copied to function add() so that any change on x and y in the function definition shall not have effects on a or b. 

Here is an example of pass by reference in C programming language(please test it in the Online C Compiler (programiz.com)): 

#include <stdio.h>


void swap(int *x, int *y) {

    int temp = *x;

    *x = *y;

    *y = temp;

}


int main() {

    int a = 10;

    int b = 20;

    printf("Before swapping: the values a = %d and b = %d\n", a, b);

    swap(&a, &b);

    printf("After swapping: the values a = %d and b = %d\n", a, b);

    return 0;

}

In this example, we have defined a function swap() that takes two integer pointers as arguments. The function swaps the values of the two integers using pointers. Inside the main() function, we declare two integer variables a and b. We then call the swap() function with the addresses of these variables using the & operator. This allows us to pass the variables by reference rather than by value.  In pass by reference, any changes on x or y shall affect the values of a and b. 

d. Recursions 

Recursion is a technique in C programming language where a function calls itself repeatedly until a certain condition is met. A function that calls itself is called as a recursive function and the technique is called as recursion.

Recursion is used when a problem can be broken down into smaller subproblems that are similar in nature to the original problem. The function calls itself with a smaller version of the problem until it reaches the base case, which is the smallest version of the problem that can be solved without recursion. So that the base case is to stop the recursion.

Here is an example of recursion in C programming language (please test it in the Online C Compiler (programiz.com)):

#include <stdio.h>


int factorial(int n) {

    if (n == 0) {

        return 1;

    } else {

        return n * factorial(n - 1);

    }

}


int main() {

    int m = 5;

    int fac = factorial(n);

    printf("The result of factorial of %d is %d\n", m, fac);

    return 0;

}


In this example, we have defined a function factorial() that takes an integer argument (n). The function calculates the factorial of n using recursion. In the main() function, we declare an integer variable n and assign it the value 5. We then call the factorial() function with n as an argument. The function calculates the factorial of 5 using recursion and returns the result.

Recursion has its advantages and disadvantages in C programming language.

Advantages:

Disadvantages:

Resources 

(Referred in July ~ September 2023)