In this course, you’ll create a fully functional match-3 puzzle game using C and the Raylib graphics library. It’s a hands-on project that covers everything from setting up a game window to adding smooth animations, sound effects, and scoring. If you’ve ever played games like Bejeweled or Candy Crush, this course walks you through making your own version of that, with a retro-style twist using ASCII tiles.

The course is taught by Erik Yuzwa, a developer with deep experience in both C programming and game development. Erik walks through the process clearly and step-by-step, so you don’t need to be a game dev expert to follow along. As long as you have some basic C knowledge, you’ll be able to keep up.

Here’s what the course covers:

• Intro and setup: Get your project environment ready and learn what tools you'll be using

• New project structure: Create the base for your game files and organize your code

• Main game loop: Set up the logic that will run the game frame by frame

• Drawing and centering the tile board: Display the game grid and align it neatly on the screen

• Adding a background image: Give your game some visual polish

• Displaying the score: Keep track of points and show them to the player

• Loading a custom TTF font: Improve your game’s UI with better text

• Mouse input: Detect player clicks and connect them to gameplay actions

• Finding and removing tile matches: Build the core logic of the match-3 mechanic

• Animating tiles: Make the game feel smooth and responsive

• Swapping tiles and managing states: Handle player interactions and animations cleanly

• Adding sound and music: Use audio to give feedback and create atmosphere

• Score popups and burst effects: Make the game feel more dynamic with visual and point feedback

• Wrapping up: Final polish and review of what you built

By the end of the course, you’ll have a complete game with real gameplay mechanics, not just a demo or prototype. You’ll also come away with a better understanding of how a game engine works at a basic level, how to structure C projects, and how to make a game feel smooth and fun.

The course is available for free on the freeCodeCamp.org YouTube channel (1-hour watch).

In this article, you will learn some of the different techniques to print strings in C.

What is a String in C?

A string is a sequence of characters, like letters, numbers, or symbols, that are grouped together. It is used to represent text in programs.

Strings are not a built-in data type in C. Instead, they are represented as arrays of characters, terminated with a special character called the null terminator, \0.

Here is an example of how to create a string in C:

char greeting[] = "Hello world!";

In the code above, I declared a character array named greeting, and initialized it with the string Hello world! enclosed within double quotes, " ".

The C compiler automatically includes the null terminator, \0, at the end of Hello world!.

How to Print a String in C Using the printf() Function

The printf() function is one of the most commonly used ways of printing strings in C.

It stands for "print formatted", and belongs to the standard input/output library, stdio.h. So, in order to use it, you need to first include the stdio.h header file at the beginning of your program.

Let’s take the following example:

#include <stdio.h>

int main(void) {
  char greeting[] = "Hello world!";

  printf("%s\n", greeting);
}

// Output:
// Hello world!

In the example above, I first included the stdio.h header file at the beginning of my program, which contains the declaration of the printf() function.

Next, I declared a character array named greeting and initialized it with the text Hello world! wrapped in double quotes.

Lastly, I used the printf() function to print the text Hello world!.

When printing a string using the printf() function, you need to use a format specifier.

A format specifier acts as a placeholder that tells the printf() function how to format and print specific types of data. They begin with a percent sign %, followed by a character that specifies the type of data to be formatted. The format specifier for strings is %s.

So, in the line printf("%s\n", greeting);, the %s format specifier tells printf() to print the string stored in the greeting variable followed by a newline character, \n.

Note that the %s format specifier doesn’t include the null terminator, \0, when printing strings. It prints the characters in the string until it encounters it.

How to Print a String in C Using the puts() Function

Another function used for printing strings is puts().

Let’s take the following example:

#include <stdio.h>

int main(void) {
  char greeting[] = "Hello world!";

  puts(greeting);
}

// Output
// Hello world!

In the example above, I first included the stdio.h header file which contains the puts() declaration.

Then, I declared a character array and initialized it with the text Hello world!. The string automatically ends with the null terminator, \0.

Lastly, I used the puts() function to print the string to the console and passed the string variable greeting as an argument.

The puts() function automatically adds a newline character, \n, at the end of the string.

Note that the puts() function is used to print null-terminated strings. A null-terminated string is a sequence of characters stored in memory followed by a character called the null terminator \0.

So far, all the examples have used only null-terminated strings, such as char greeting[] = "Hello world!";. In memory, it would be represented as ['H', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd', '!', '\0'].

Creating non-null-terminated strings intentionally is not common in C.

Here is an example of a non-null-terminated string: char greeting[] = {'H', 'e', 'l', 'l', 'o'};This array of characters does not include the null terminator, \0, so it is a non-null-terminated string.

If you try to print a non-null-terminated string using puts(), you will end up getting undefined behavior, such as garbage characters at the end of the string:

#include <stdio.h>

int main(void) {
  char greeting[] = {'H', 'e', 'l', 'l', 'o'};

  puts(greeting);
}

// Ouput when I run the code the first time:
// Helloq

// Ouput when I run the code a second time:
// Hellop

// Ouput when I run the code a thrid time:
// Hellow

The printf() Function VS the puts() Function – What's the Difference?

You may be wondering what the difference is between printf() and puts().

The puts() function prints the text as it is, without any formatting. It also automatically adds a newline character at the end of the string.

The printf() function doesn’t automatically add a new line - you have to do it explicitly.

However, it allows for formatted output, and gives you more control and flexibility over where and how you insert different data types into the format string:

#include <stdio.h>

int main(void) {
    char name[] = "John";
    int age = 30;

    // Printing strings using puts()
    puts("Using puts():");
    puts("My name is John and I'm 30 years old.");

    // Printing strings usingprintf()
    printf("\nUsing printf():\n");
    printf("My name is %s and I'm %d years old. \n", name, age);
}

In the example above, the puts() function prints a simple string without any formatting. It also automatically adds a newline character, \n, at the end of the string.

On the other hand, the printf() function formats the string and embeds two variable values. It uses format specifiers, such as %s for strings and %d for integers, to specify the type of data the variables hold, and where the variables should be inserted into the string. It also adds a newline character at the end.

Conclusion

In this article, you learned about the two most commonly used functions in C for printing strings.

The printf() function is commonly used for printing formatted text to the console. It allows you to format your output and print strings, numbers and characters.

The puts() function is more simple compared to printf(). It is great for basic text output and automatically adds a newline character, \n, to the printed string.

Thank you for reading, and happy coding!

Finding the length of a string in C is essential for many reasons.

You may need to perform string manipulation, and many string manipulation functions require the length of the string as an argument. You may also need to validate user input, compare two strings, or manage and allocate memory dynamically.

In this this article, you will learn different ways to find the length of a string in C.

What are Strings in C?

Unlike other programming languages, C doesn’t have a built-in string data type.

Instead, strings in C are arrays of characters that have a character called the null terminator \0 at the end.

There are many ways to create a string in C. Here is an example of one way:

char greeting[] = "Hello";

In the code above, I created a character array named greeting using the char data type followed by square brackets, [].

I then assigned the the string Hello which is surrounded by double quotes to greeting.

In this example, the size of the array is not specified explicitly – the size is determined by the size of the string assigned to it. Also, the null terminator, \0, is automatically added to the end of the string.

What is the string.h header file in C?

The string.h header file provides functions for manipulating and working with strings.

It contains functions that complete tasks such as copying and concatenating. It also provides functions for finding the length of a string, such as strlen() which you will learn how to use in the following section.

To use functions from string.h, you need to include it at the beginning of your file like this:

#include <stdio.h>
#include <string.h>

int main(void) {
  // Your code goes here
}

How to Find the Length of a String in C Using the strlen() Function

The strlen() function is defined in the string.h header file, and is used to find the length of a string.

Let’s take the following example:

#include <stdio.h>
#include <string.h>

int main(void) {
  char greeting[] = "Hello";

  int length = strlen(greeting);

  printf("The length is: %d\n", length);
}

// Output: 
// The length is: 5

In the example above, I first included the stdio.h header file to be able to use input/output functions such as printf(). I also included the string.h header file so I could use the strlen() function.

Inside the main() function, I created a greeting array and stored the string Hello.

Then, I called the strlen() function and passed greeting as the argument – this is the string I want to find the length of.

Lastly, I used the value returned in length and printed it using the printf() function.

Note that the strlen() function returns the number of characters in the string excluding the null terminator (\0).

How to Find the Length of a String in C Using the sizeof() Operator

Another way to find the length of a string in C is using the sizeof() operator.

The sizeof() operator returns the total size in bytes of a string.

Let's take the following example:

#include <stdio.h>

int main(void) {
  char greeting[] = "Hello";

  int size = sizeof(greeting);

  printf("The size is %d bytes \n", size);
}

// Output:
// The size is 6 bytes

In the following example, sizeof(greeting) returns the entire size of the greeting array in bytes – including the null operator, \0.

This is not always very helpful.

To exclude this character, you need to subtract one from the total size:

#include <stdio.h>

int main(void) {
  char greeting[] = "Hello";

  int length = sizeof(greeting) - 1;

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

// Output:
// The length is 5

Although the sizeof() operator doesn’t require you to include the string.h header file like strlen() does, it returns the total size of the array and not the length of the string.

The total size of the array includes the null terminator, \0, whereas the length of the string is the number of characters before the null terminator.

How to Find the Length of a String in C Using a while Loop

Another way to find the length of a string is C is using a while loop.

The way this works is you keep iterating over the characters in a string until you reach the end of it and encounter the null terminator \0.

Let's look at the following example:

#include <stdio.h>

int main(void) {
  char greeting[] = "Hello";
  int length = 0;

while (greeting[length] != '\0') {
    length++;
}
    printf("The length is %d", length );
}

// Output:
// The length is 5

Let’s break down how the loop works.

I initialized a counter variable, length, to 0. This variable will store the length of the string.

The condition of the while loop, greeting[length] != '\0', checks if the character at index length of the string is not equal to the null terminator \0.

If it is not, the length variable is incremented and the loop continues and moves on to the next character in greeting.

The while loop iterates over greeting until it encounters \0 and then the iteration stops.

Conclusion

In this article, you learned how to find the length of a string in C.

You learned how to use the strlen() function, which returns the number of characters in the string excluding the null terminator.

You also learned how to use the sizeof() operator which does not always return the desired result as it includes the null terminator in the length.

Lastly, you learned how to use a while loop to find the length of a string. A loop counts the characters in the string until it reaches the null terminator.

Thank you for reading, and happy coding!

In this article, you'll learn the basics of defining functions in C.

What is a Function in C?

In programming, a function is a block of code that performs a specific task.

Functions take inputs, process them, perform operations, and produce an output.

Functions are important because they organize your code and promote code reusability.

Instead of writing the same code again and again and repeating yourself, you write code once and then can use it whenever you want to perform that specific task.

In C, there are generally two types of functions:

• Standard library functions. Standard library functions are provided by the C standard library and defined in header files. Examples of standard library functions include printf() for printing formatted output to the console and scanf() for reading formatted input from the user. Both are defined in the stdio.h header file.

• User-defined functions. User-defined functions are defined by you, the programmer. These functions are tailored to your program’s needs and requirements. For example, a user-defined function may calculate the sum of two numbers or check if a number is even or odd.

In this article, you will learn how to create user-defined functions.

Syntax of Functions in C

Here is the general syntax of a function in C:

return_type function_name(parameter) {
  // function body with the code to be executed
  return value;
}

Let’s break it down:

• The return_type lets the C compiler know the type of data of the value the function will return after its execution. It can be any valid C data type such as int, float, char, or void if the function doesn’t return a value.

• The function_name is the name you give the function. It should be meaningful and accurately describe what the function does. You will later use this to call the function.

• The parameter is optional. A parameter is a variable a function accepts as input inside parentheses. A function can receive zero or more parameters. If the function accepts multiple parameters, they are separated by commas. Each parameter consists of the data type followed by a name.

• Inside the curly braces, {}, is the function’s body. Here is the actual code, the instructions that perform a specific task.

• Inside the function body, there can be an optional return value. You use the return keyword followed by the value you want to return. If the function has a voidreturn_type, you don't need to specify a return value.

How to Call a Function in C

Here is the syntax for calling a function in C:

function_name(arguments);

Let's break it down:

• function_name is the name of the function you want to call. It should be the same name you used to define your function.

• arguments are the values you pass to the function. If the function accepts any parameters, you pass the arguments in parentheses when you call the function. Each argument is separated by a comma.

If the function returns a value, you can store it in a variable for later use:

data_type result = function_name(arguments);

How to Define and Call a Function in C Example

Let's look at a simple function that adds two numbers:

#include <stdio.h>
int add(int num1, int num2) {
    return num1 + num2;
}

int main(void) {
    int num1, num2, result;

    printf("Enter first number: ");
    scanf("%d", &num1);

    printf("Enter second number: ");
    scanf("%d", &num2);

    result = add(num1, num2);

    printf("The sum of %d and %d is %d\n", num1, num2, result);

    return 0;
}

// Output: 

// Enter first number: 2
// Enter second number: 3
// The sum of 2 and 3 is 5

Let’s break down the code step by step.

Include the Header File

I first included the library stdio.h with the line #include <stdio.h>.

This line includes the standard input-output library (<stdio.h>), which gives you access to the printf() and scanf() functions. Now, you can receive user input and print text to the console.

Define the add Function

Next, I defined the following function:

int add(int num1, int num2) {
    return num1 + num2;
}

This function has an int return type, which indicates that it will return an integer value after execution.

The function is named add, and inside parentheses, it accepts the integer parameters num1 and num2.

Within the curly braces, the function body contains the function code. In this case, the function code consists of only the return statement return num1 + num2;. This code calculates the sum of num1 and num2 using the + operator, and returns the result.

The add() function is defined before being used in the main() function later on. In C, functions must be defined before they are used. By placing the add() function definition above the main() function, the compiler knows about it when it encounters the function call in main().

Define the main() Function

Next, I defined the main() function, which is the starting point of every C program:

int main(void) {
    int num1, num2, result;

    printf("Enter first number: ");
    scanf("%d", &num1);

    printf("Enter second number: ");
    scanf("%d", &num2);

    result = add(num1, num2);

    printf("The sum of %d and %d is %d\n", num1, num2, result);

    return 0;
}

Inside the main() function, I first declared the integer variables num1, num2, and result.

Note that num1 and num2 variables are different from the num1 and num2 parameters that the add() function receives. These two variables will store the numbers that the user will enter.

Then, I prompted the user to enter the first number using the printf() function, and used the scanf() function to read the input and store it in the variable num1. The %d format specifier is used to indicate that scanf() should expect an integer input.

I followed the exact same procedure for receiving and storing the second number.

Next, I called the add() function with the num1 and num2 as arguments. The add() function will add the two numbers together. The result of the calculation is then stored in the result variable.

Following that, I used the printf() function to print the num1, num2 and result variables to the console. The format specifier %d is used to print integer values.

Lastly, the line return 0; is a statement that indicates that the program executed successfully. When a C program terminates, it returns an exit status to the operating system, with 0 typically indicating the program executed without any errors.

Execute the Program

When the program is executed, the main() function is called first.

You first see the prompt Enter first number:. In my case, I entered 2 as the first number.

Once you enter a number, you will see the second prompt: Enter second number:. I entered the number 3 as the second number.

Then, the add() function is called, which adds the numbers 2 and 3.

Lastly, the line The sum of 2 and 3 is 5 is printed to the console.

Conclusion

In this article, you learned the very basics of defining functions in C.

Specifically, you learned about the two different types of functions in C, and the general syntax for defining your own functions.

Lastly, you saw an example of a simple function that added two numbers and returned the result.

Thanks for reading, and happy coding!

It is used in many industries because it is a highly flexible and powerful language.

Learning C is a worthwhile endeavor – no matter your starting point or aspirations – because it builds a solid foundation in the skills you will need for the rest of your programming career.

It helps you understand how a computer works underneath the hood, such as how it stores and retrieves information and what the internal architecture looks like.

With that said, C can be a difficult language to learn, especially for beginners, as it can be cryptic.

This handbook aims to teach you C programming fundamentals and is written with the beginner programmer in mind.

There are no prerequisites, and no previous knowledge of any programming concepts is assumed.

If you have never programmed before and are a complete beginner, you have come to the right place.

Here is what you are going to learn in this handbook:

• Chapter 1: Introduction to C Programming

• Chapter 2: Variables and Data Types in C

• Chapter 3: Operators in C

• Chapter 4: Conditional Statements in C

• Chapter 5: Loops in C

• Chapter 6: Arrays in C

• Chapter 7: Strings in C

• Further learning: Advanced C Topics

Without further ado, let’s get started with learning C!

Chapter 1: Introduction to C Programming

In this introductory chapter, you will learn the main characteristics and use cases of the C programming language.

You will also learn the basics of C syntax and familiarize yourself with the general structure of all C programs.

By the end of the chapter, you will have set up a development environment for C programming so you can follow along with the coding examples in this book on your local machine.

You will have successfully written, compiled, and executed your first simple C program that prints the text "Hello, world!" to the screen.

You will have also learned some core C language features, such as comments for documenting and explaining your code and escape sequences for representing nonprintable characters in text.

What Is Programming?

Computers are not that smart.

Even though they can process data tirelessly and can perform operations at a very high speed, they cannot think for themselves. They need someone to tell them what to do next.

Humans tell computers what to do and exactly how to do it by giving them detailed and step-by-step instructions to follow.

A collection of detailed instructions is known as a program.

Programming is the process of writing the collection of instructions that a computer can understand and execute to perform a specific task and solve a particular problem.

A programming language is used to write the instructions.

And the humans who write the instructions and supply them to the computer are known as programmers.

Low-level VS High-Level VS Middle-level Programming Languages – What's The Difference?

There are three types of programming languages: low-level languages, high-level languages, and middle-level languages.

Low-level languages include machine language (also known as binary) and assembly language.

Both languages provide little to no abstraction from the computer's hardware. The language instructions are closely related to or correspond directly to specific machine instructions.

This 'closeness to the machine' allows for speed, efficiency, less consumption of memory, and fine-grained control over the computer's hardware.

Machine language is the lowest level of programming languages.

The instructions consist of series of 0s and 1s that correspond directly to a particular computer’s instructions and locations memory.

Instructions are also directly executed by the computer’s processor.

Even though machine language was the language of choice for writing programs in the early days of computing, it is not a human-readable language and is time-consuming to write.

Assembly language allows the programmer to work closely with the machine on a slightly higher level.

It uses mnemonics and symbols that correspond directly to a particular machine’s instruction set instead of using sequences of 0s and 1s.

Next, high-level languages, like Python and JavaScript, are far removed from the instruction set of a particular machine architecture.

Their syntax resembles the English language, making them easier to work with and understand.

Programs written in high-level languages are also portable and machine-independent. That is, a program can run on any system that supports that language.

With that said, they tend to be slower, consume more memory, and make it harder to work with low-level hardware and systems because of how abstract they are.

Lastly, middle-level languages, like C and C++, act as a bridge between low-level and high-level programming languages.

They allow for closeness and a level of control over computer hardware. At the same time, they also offer a level of abstraction with instructions that are more human-readable and understandable for programmers to write.

What Is the C Programming Language?

C is a general-purpose and procedural programming language.

A procedural language is a type of programming language that follows a step-by-step approach to solving a problem.

It uses a series of instructions, otherwise known as procedures or functions, that are executed in a specific order to perform tasks and accomplish goals. These intructions tell the computer step by step what to do and in what order.

So, C programs are divided into smaller, more specific functions that accomplish a certain task and get executed sequentially, one after another, following a top-down approach.

This promotes code readability and maintainability.

A Brief History of the C Programming Language

C was developed in the early 1970s by Dennis Ritchie at AT&T Bell Laboratories.

The development of C was closely tied to the development of the Unix operating system at Bell Labs.

Historically, operating systems were typically written in Assembly language and without portability in mind.

During the development of Unix, there was a need for a more efficient and portable programming language for writing operating systems.

Dennis Ritchie went on to create a language called B, which was an evolution from an earlier language called BCPL (Basic Combined Programming Language).

It aimed to bridge the gap between the low-level capabilities of Assembly and the high-level languages used at the time, such as Fortran.

B was not powerful enough to support Unix development, so Dennis Ritchie developed a new language that took inspiration from B and BCPL and had some additional features. He named this language C.

C’s simple design, speed, efficiency, performance, and close relationship with a computer’s hardware made it an attractive choice for systems programming. This led to the Unix operating system being rewritten in C.

C Language Characteristics and Use Cases

Despite C being a relatively old language (compared to other, more modern, programming languages in use today), it has stood the test of time and still remains popular.

According to the TIOBE index, which measures the popularity of programming languages each month, C is the second most popular programming language as of August 2023.

This is because C is considered the "mother of programming languages" and is one of the most foundational languages of computer science.

Most modern and popular languages used today either use C under the hood or are inspired by it.

For example, Python’s default implementation and interpreter, CPython, is written in C. And languages such as C++ and C# are extensions of C and provide additional functionality.

Even though C was originally designed with systems programming in mind, it is widely used in many other areas of computing.

C programs are portable and easy to implement, meaning they can be executed across different platforms with minimal changes.

C also allows for efficient and direct memory manipulation and management, making it an ideal language for performance-critical applications.

And C provides higher-level abstractions along with low-level capabilities, which allows programmers to have fine-grained control over hardware resources when they need to.

These characteristics make C an ideal language for creating operating systems, embedded systems, system utilities, Internet of things (IoT) devices, database systems, and various other applications.

C is used pretty much everywhere today.

How to Set Up a Development Environment for C Programming on Your Local Machine

To start writing C programs on your local machine, you will need the following:

• A C Compiler

• An Integrated Development Environment (IDE)

C is a compiled programming language, like Go, Java, Swift, and Rust.

Compiled languages are different from interpeted languages, such as PHP, Ruby, Python, and JavaScript.

The difference between compiled and interpeted languages is that a compiled language is directly translated to machine code all at once.

This process is done by a special program called a compiler.

The compiler reads the entire source code, checks it for errors, and then translates the entire program into machine code. This is a language the computer can understand and it's directly associated with the particular instructions of the computer.

This process creates a standalone binary executable file containing sequences of 0s and 1s which is a more computer-friendly form of the initial source code. This file contains instructions that the computer can understand and run directly.

An interpeted language, on the other hand, doesn’t get translated into machine code all at once and doesn’t produce a binary executable file.

Instead, an interpreter reads and executes the source code one instruction at a time, line by line. The interpreter reads each line, translates it into machine code, and then immediately runs it.

If you are using a Unix or a Unix-like system such as macOS or Linux, you probably have the popular GNU Compiler Collection (GCC) already installed on your machine.

If you are running either of those operating systems, open the terminal application and type the following command:

gcc --version

If you're using macOS and have not installed the command line developer tools, a dialog box will pop-up asking you to install them – so if you see that, go ahead and do so.

If you have already installed the command line tools, you will see an output with the version of the compiler, which will look similar to the following:

Apple clang version 14.0.0 (clang-1400.0.29.202)

If you are using Windows, you can check out Code::Blocks or look into installing Linux on Windows with WSL. Feel free to pick whatever programming environment works best for you.

An IDE is where you write, edit, save, run, and debug your C programs. You can think of it like a word processor but for writing code.

Visual Studio Code is a great editor for writing code, and offers many IDE-like features.

It is free, open-source, supports many programming languages, and is available for all operating systems.

Once you have downloaded Visual Studio Code, install the C/C++ extension.

It’s also a good idea to enable auto-saving by selecting: "File" -> "Auto Save".

If you want to learn more, you can look through the Visual Studio Code documentation for C/C++.

With your local machine all set up, you are ready to write your first C program!

How to Write Your First C Program

To get started, open Visual Studio Code and create a new folder for your C program by navigating to "File" -> "Open" -> "New Folder".

Give this folder a name, for example, c-practice, and then select "Create" -> “Open".

You should now have the c-practice folder open in Visual Studio Code.

Inside the folder you just created, create a new C file.

Hold down the Command key and press N on macOS or hold down the Control and press N for Windows/Linux to create an Untitled-1 file.

Hold down the Command key and press S on macOS or hold down the Control key and press S for Windows/Linux, and save the file as a main.c file.

Finally, click "Save".

Make sure that you save the file you created with a .c extension, or it won’t be a valid C file.

You should now have the main.c file you just created open in Visual Studio Code.

Next, add the following code:

#include <stdio.h>

int main(void) {

  // output 'Hello, world!' to the console

  printf("Hello, world!\n");
}

Let’s go over each line and explain what is happening in the program.

What Are Header Files in C?

Let’s start with the first line, #include <stdio.h>.

The #include part of #include <stdio.h> is a preprocessor command that tells the C compiler to include a file.

Specifically, it tells the compiler to include the stdio.h header file.

Header files are external libraries.

This means that some developers have written some functionality and features that are not included at the core of the C language.

By adding header files to your code, you get additional functionality that you can use in your programs without having to write the code from scratch.

The stdio.h header file stands for standard input-output.

It contains function definitions for input and output operations, such as functions for gathering user data and printing data to the console.

Specifically, it provides functions such as printf() and scanf().

So, this line is necessary for the function we have later on in our program, printf(), to work.

If you don't include the stdio.h file at the top of your code, the compiler will not understand what the printf() function is.

What is the main() function in C?

Next, int main(void) {} is the main function and starting point of every C program.

It is the first thing that is called when the program is executed.

Every C program must include a main() function.

The int keyword in int main(void) {} indicates the return value of the main() function.

In this case, the function will return an integer number.

And the void keyword inside the main() function indicates that the function receives no arguments.

Anything inside the curly braces, {}, is considered the body of the function – here is where you include the code you want to write. Any code written here will always run first.

This line acts as a boilerplate and starting point for all C programs. It lets the computer know where to begin reading the code when it executes your programs.

What Are Comments in C?

In C programming, comments are lines of text that get ignored by the compiler.

Writing comments is a way to provide additional information and describe the logic, purpose, and functionality of your code.

Comments provide a way to document your code and make it more readable and understandable for anyone who will read and work with it.

Having comments in your source code is also helpful for your future self. So when you come back to the code in a few months and don't remember how the code works, these comments can help.

Comments are also helpful for debugging and troubleshooting. You can temporarily comment out lines of code to isolate problems.

This will allow you to ignore a section of code and concentrate on the piece of code you are testing and working on without having to delete anything.

There are two types of comments in C:

• Single-line comments

• Multi-line comments

Single-line comments start with two forward slashes, //, and continue until the end of the line.

Here is the syntax for creating a single-line comment in C:

// I am a single-line comment

Any text written after the forward slashes and on the same line gets ignored by the compiler.

Multi-line comments start with a forward slash, /, followed by an asterisk, *, and end with an asterisk, followed by a forward slash.

As the name suggests, they span multiple lines.

They offer a way to write slightly longer explanations or notes within your code and explain in more detail how it works.

Here is the syntax for creating a multi-line comment in C:

/*
This is
a multi-line
comment
*/

What is the printf() function in C?

Inside the function's body, the line printf("Hello, World!\n"); prints the text Hello, World! to the console (this text is also known as a string).

Whenever you want to display something, use the printf() function.

Surround the text you want to display in double quotation marks, "", and make sure it is inside the parentheses of the printf() function.

The semicolon, ;, terminates the statement. All statements need to end with a semicolon in C, as it identifies the end of the statement.

You can think of a semicolon similar to how a full stop/period ends a sentence.

What Are Escape Sequences in C?

Did you notice the \n at the end of printf("Hello, World!\n");?

It's called an escape sequence, which means that it is a character that creates a newline and tells the cursor to move to the next line when it sees it.

In programming, an escape sequence is a combination of characters that represents a special character within a string.

They provide a way to include special characters that are difficult to represent directly in a string.

They consist of a backslash, \, also known as the escape character, followed by one or more additional characters.

The escape sequence for a newline character is \n.

Another escape sequence is \t. The \t represrents a tab character, and will insert a space within a string.

How to Compile and Run Your first C Program

In the previous section, you wrote your first C program:

#include <stdio.h>

int main(void) {

  // output 'Hello, world!' to the console

  printf("Hello, world!\n");
}

Any code you write in the C programming language is called source code.

Your computer doesn’t understand any of the C statements you have written, so this source code needs to be translated into a different format that the computer can understand. Here is where the compiler you installed earlier comes in handy.

The compiler will read the program and translate it into a format closer to the computer’s native language and make your program suitable for execution.

You will be able to see the output of your program, which should be Hello, world!.

The compilation of a C program consists of four steps: preprocessing, compilation, assembling, and linking.

The first step is preprocessing.

The preprocessor scans through the source code to find preprocessor directives, which are any lines that start with a # symbol, such as #include .

Once the preprocessor finds these lines, it substitutes them with something else.

For example, when the preprocessor finds the line #include <stdio.h>, the #include tells the preprocessor to include all the code from the stdio.h header file.

So, it replaces the #include <stdio.h> line with the actual contents of the stdio.h file.

The output of this phase is a modified version of the source code.

After preprocessing, the next step is the compilation phase, where the modified source code gets translated into the corresponding assembly code.

If there are any errors, compilation will fail, and you will need to fix the errors to continue.

The next step is the assembly phase, where the assembler converts the generated assembly code statements into machine code instructions.

The output of this phase is an object file, which contains the machine code instructions.

The last step is the linking phase.

Linking is the process of combining the object file generated from the assembly phase with any necessary libraries to create the final executable binary file.

Now, let’s go over the commands you need to enter to compile your main.c file.

In Visual Studio Code, open the built-in terminal by selecting "Terminal" -> "New Terminal".

Inside the terminal, enter the following command:

gcc main.c

The gcc part of the command refers to the C compiler, and main.c is the file that contains the C code that you want to compile.

Next, enter the following command:

ls

The ls command lists the contents of the current directory.

a.out  main.c

The output of this command shows an a.out file – this is the executable file containing the source code statements in their corresponding binary instructions.

The a.out is the default name of the executable file created during the compilation process.

To run this file, enter the following command:

./a.out

This command tells the computer to look in the current directory, ./, for a file named a.out.

The above command generates the following output:

Hello, world!

You also have the option to name the executable file instead of leaving it with the default a.out name.

Say you wanted to name the executable file helloWorld.

If you wanted to do this, you would need to enter the following command:

gcc -o helloWorld main.c

This command with the -o option (which stands for output) tells the gcc compiler to create an executable file named helloWorld.

To run the new executable file that you just created, enter the following command:

./helloWorld

This is the output of the above command:

Hello, world!

Note that whenever you make a change to your source code file, you have to repeat the process of compiling and running your program from the beginning to see the changes you made.

Chapter 2: Variables and Data Types

In this chapter, you will learn the basics of variables and data types – the fundamental storage units that allow you to preserve and manipulate data in your programs.

By the end of this chapter, you will know how to declare and initialize variables.

You will also have learned about various data types available in C, such as integers, floating-point numbers, and characters, which dictate how information is processed and stored within a program's memory.

Finally, you'll have learned how to receive user input in your programs, and how to use constants to store values that you don't want to be changed.

What Is a Variable in C?

Variables store different kind of data in the computer's memory, and take up a certain amount of space.

By storing information in a variable, you can retrieve and manipule it, perform various calculations, or even use it to make decisions in your program.

The stored data is given a name, and that is how you are able to access it when you need it.

How to Declare Variables in C

Before you can use a variable, you need to declare it – this step lets the compiler know that it should allocate some memory for it.

C is a strongly typed language, so to declare a variable in C, you first need to specify the type of data the variable will hold, such as an integer to store a whole number, a floating-point number for numbers with decimal places, or a char for a single character.

That way, during compilation time, the compiler knows if the variable is able to perform the actions it was set out to do.

Once you have specified the data type, you give the variable a name.

The general syntax for declaring variables looks something like this:

data_type variable_name;

Let's take the following example:

#include <stdio.h>

int main(void) {

    int age;
}

In the example above, I declared a variable named age that will hold integer values.

What Are the Naming Conventions for Variables in C?

When it comes to variable names, they must begin either with a letter or an underscore.

For example, age and _age are valid variable names.

Also, they can contain any uppercase or lowercase letters, numbers, or an underscore character. There can be no other special symbols besides an underscore.

Lastly, variable names are case-sensitive. For example, age is different from Age.

How to Initialize Variables in C

Once you've declared a variable, it is a good practice to intialize it, which involves assigning an initial value to the variable.

The general syntax for initialzing a variable looks like this:

data_type variable_name = value;

The assignment operator, =, is used to assign the value to the variable_name.

Let's take the previous example and assign age a value:

#include <stdio.h>

int main(void) {

    int age;

    age = 29;
}

I initialized the variable age by assigning it an integer value of 29.

With that said, you can combine the initialization and declaration steps instead of performing them separately:

#include <stdio.h>

int main(void) {

    // declaration + initialization
    int age = 29;
}

How to Update Variable Values in C

The values of variables can change.

For example, you can change the value of age without having to specify its type again.

Here is how you would change its value from 29 to 30:

#include <stdio.h>

int main(void) {

    // the variable age with its original value
    int age = 29;

    // changing the value of age
    // the new value will be 30
    age = 30;
}

Note that the data type of the new value being assigned must match the declared data type of the variable.

If it doesn't, the program will not run as expected. The compiler will raise an error during compilation time.

#include <stdio.h>

int main(void) {

    int age = 29;

    /*
    trying to assign a floating-point value
    to a variable with type int
    will cause an error in your program
    */
    age = 29.5;
}

What Are the Basic Data Types in C?

Data types specify the type of form that information can have in C programs. And they determine what kind of operations can be performed on that information.

There are various built-in data types in C such as char, int, and float.

Each of the data types requires different allocation of memory.

Before exploring each one in more detail, let’s first go over the difference between signed and unsigned data types in C.

Signed data types can represent both positive and negative values.

On the other hand, unsigned data types can represent only non-negative values (zero and positive values).

Wondering when to use signed and when to use unsigned data types?

Use signed data types when you need to represent both positive and negative values, such as when working with numbers that can have positive and negative variations.

And use unsigned data types when you want to ensure that a variable can only hold non-negative values, such as when dealing with quantities.

Now, let's look at C data types in more detail.

What Is the char Data Type in C?

The most basic data type in C is char.

It stands for "character" and it is one of the simplest and most fundamental data types in the C programming language.

You use it to store a single individual character such as an uppercase and lowercase letter of the ASCII (American Standard Code for Information Interchange) chart.

Some examples of chars are 'a' and 'Z'.

It can also store symbols such as '!', and digits such as '7'.

Here is an example of how to create a variable that will hold a char value:

#include <stdio.h>

int main(void) {

    char initial = 'D';

 }

Notice how I used single quotation marks around the single character.

This is because you can't use double quotes when working with chars.

Double quotes are used for strings.

Regarding memory allocation, a signed char lets you store numbers ranging from [-128 to 127], and uses at least 1 byte (or 8 bits) of memory.

An unsigned char stores numbers ranging from [0 to 255].

What Is the int Data Type in C?

An int is a an integer, which is also known as a whole number.

It can hold a positive or negative value or 0, but it can't hold numbers that contain decimal points (like 3.5).

Some examples of integers are 0, -3,and 9.

Here is how you create a variable that will hold an int value:

#include <stdio.h>

int main(void) {

    int age = 29;
 }

When you declare an int, the computer allocates at least 2 bytes (or 16 bits) of memory.

With that said, on most modern systems, an int typically allocates 4 bytes (or 32 bits) of memory.

The range of available numbers for a signed int is [-32,768 to 32,767] when it takes up 2 bytes and [-2,147,483,648 to 2,147,483,647] when it takes up 4 bytes of memory.

The range of numbers for an unsigned int doesn't include any of the negative numbers in the range mentioned for signed ints.

So, the range of numbers for unsigned ints that take up 2 bytes of memory is [0 to 65,535] and the range is [0 to 4,294,967,295] for those that take up 4 bytes.

To represent smaller numbers, you can use another data type – the short int. It typically takes up 2 bytes (or 16 bits) of memory.

A signed short int allows for numbers in a range from [-32,768 to 32,767].

An unsigned short int allows for numbers in a range from [0 to 65,535].

Use a short when you want to work with smaller integers, or when memory optimisation is critically important.

If you need to work with larger integers, you can also use other data types like long int or long long int, which provide a larger range and higher precision.

A long int typically takes up at least 4 bytes of memory (or 32 bits).

The values for a signed long int range from [-2,147,483,648 to 2,147,483,647].

And the values for an unsigned long int range from [0 to 4,294,967,295].

The long long int data type is able to use even larger numbers than a long int. It usually takes up 8 bytes (or 64 bits) of memory.

A signed long long int allows for a range from [-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807]

And an unsigned long long int has a range of numbers from [0 to 18,446,744,073,709,551,615].

What Is The float Data Type in C?

The float data type is used to hold numbers with a decimal value (which are also known as real numbers).

It holds 4 bytes (or 32 bits) of memory and it is a single-precision floating-point type.

Here is how you create a variable that will hold a float value:

#include <stdio.h>

int main(void) {

   float temperature = 68.5;
 }

A double is a floating point value and is the most commonly used floating-point data type in C.

It holds 8 bytes (or 64 bits) of memory, and it is a double-precision floating-point type.

Here is how you create a variable that will hold a double value:

#include <stdio.h>

int main(void) {

    double number = 3.14159;
 }

When choosing which floating-point data type to use, consider the trade-off between memory usage and precision.

A float has less precision that a double but consumes less memory.

Use a float when memory usage is a concern (such as when working with a system with limited resources) or when you need to perform calculations where high precision is not critical.

If you require higher precision and accuracy for your calculations and memory usage is not critical, you can use a double.

What Are Format Codes in C?

Format codes are used in input and output functions, such as scanf() and printf(), respectively.

They act as placeholders and substitutes for variables.

Specifically, they specify the expected format of input and output.

They tell the program how to format or interpret the data being passed to or read from the scanf() and printf() functions.

The syntax for format codes is the % character and the format specifier for the data type of the variable.

Let's take the following example:

#include<stdio.h>

int main(void)
{
    int age = 29;

    printf("My age is %i\n", age);  // My age is 29
}

In the example above, age is the variable in the program. It is of type int.

The format code – or placeholder – for integer values is %i. This indicates that an integer should be printed.

In the program's output, %i is replaced with the value of age, which is 29.

Here is a table with the format specifiers for each data type:

How to Recieve User Input Using the scanf() Function

Earlier you saw how to print something to the console using the printf() function.

But what happens when you want to receive user input? This is where the scanf() function comes in.

The scanf() function reads user input, which is typically entered via a keyboard.

The user enters a value, presses the Enter key, and the value is saved in a variable.

The general syntax for using scanf() looks something similar to the following:

scanf("format_string", &variable);

Let's break it down:

• format_string is the string that lets the computer know what to expect. It specifies the expected format of the input. For example, is it a word, a number, or something else?

• &variable is the pointer to the variable where you want to store the value gathered from the user input.

Let's take a look at an example of scanf() in action:

#include <stdio.h>

int main(void) {

  int number;

  printf("Please enter your age: ");

  scanf("%i", &number);

  printf("Your age is %i\n", number);
}

In the example above, I first have to include the stdio.h header file, which provides input and output functions in C.

Then, in the main() function, I declare a variable named number that will hold integer values. This variable will store the user input.

Then, I prompt the user to enter a number using the printf() function.

Next, I use scanf() to read and save the value that the user enters.

The format specifier %i lets the computer known that it should expect an integer input.

Note also the & symbol before the variable name. Forgetting to add it will cause an error.

Lastly, after receiving the input, I display the received value to the console using another printf() function.

What are Constants in C?

As you saw earlier on, variable values can be changed throughout the life of a program.

With that said, there may be times when you don’t want a value to be changed. This is where constants come in handy.

In C, a constant is a variable with a value that cannot be changed after declaration and during the program's execution.

You can create a constant in a similar way to how you create variables.

The differences between constants and variables is that with constants you have to use the const keyword before mentioning the data type.

And when working with constants, you should always specify a value.

The general syntax for declaring constants in C looks like this:

const data_type constant_name = value;

Here, data_type represents the data type of the constant, constant_name is the name you choose for the constant, and value is the value of the constant.

It is also best practice to use all upper case letters when declaring a constant’s name.

Let’s see an example of how to create a constant in C:

#include <stdio.h>

int main(void) {

    const int LUCKY_NUM = 7;

    printf("My lucky number is: %i\n", LUCKY_NUM);
}

In this example, LUCKY_NUM is defined as a constant with a value of 7.

The constant's name, LUCKY_NUM, is in uppercase letters, as this is a best practice and convention that improves the readability of your code and distinguishes constants from variables.

Once defined, it cannot be modified in the program.

If you try to change its value, the C compiler will generate an error indicating that you are attempting to modify a constant.

#include <stdio.h>

int main(void) {

    const int LUCKY_NUM = 7;

    printf("My lucky number is: %i\n", LUCKY_NUM);

    LUCKY_NUM = 13; // this will cause an error

}

Chapter 3: Operators

Operators are essential building blocks in all programming languages.

They let you perform various operations on variables and values using symbols.

And they let you compare variables and values against each other for decision-making computatons.

In this chapter, you will learn about the most common operators in C programming.

You will first learn about arithmetic operators, which allow you to perform basic mathematical calculations.

You will then learn about relational (also known as comparisson operators), which help you compare values.

And you will learn about logical operators, which allow you to make decisions based on conditions.

After understanding these fundamental operators, you'll learn about some additional operators, such as assignment operators, and increment and decrement operators.

By the end of this chapter, you will have a solid grasp of how to use different operators to manipulate data.

What Are the Arithmetic Operators in C?

Arithmetic operators are used to perform basic arithmetic operations on numeric data types.

Operations include addition, subtraction, multiplication, division, and calculating the remainder after division.

These are the main arithmetic operators in C:

Let's see examples of each one in action.

How to Use the Addition (+) Operator

The addition operator adds two operands together and returns their sum.

#include <stdio.h>

int main(void) {

    int a = 5;

    int b = 3;

    int sum = a + b;

    printf("Sum: %i\n", sum); // Output: Sum: 8
}

How to Use the Subtraction (-) Operator

The subtraction operator subtracts the second operand from the first operand and returns their difference.

#include <stdio.h>

int main(void) {

    int a = 10; 

    int b = 5;

    int difference = a - b;

    printf("Difference: %i\n", difference); // Output: Difference: 5
}

How to Use the Multiplication (*) Operator

The multiplication operator multiplies two operands and returns their product.

#include <stdio.h>

int main(void) {

    int a = 4;

    int b = 3;

    int product = a * b;

    printf("Product: %i\n", product); // Output: Product: 12
}

How to Use the Division (/) Operator

The division operator divides the first operand by the second operand and returns their quotient.

#include <stdio.h>

int main(void) {

    int a = 10;

    int b = 2;

    int quotient = a / b;

    printf("Quotient: %i\n", quotient); // Output: Quotient: 5
}

How to Use the Modulo (%) Operator

The modulo operator returns the remainder of the first operand when divided by the second operand.

#include <stdio.h>

int main(void) {

    int a = 10;

    int b = 3;

    int remainder = a % b;

    printf("Remainder: %i\n", remainder); // Output: Remainder: 1
}

The modulo operator is commonly used to determine whether an integer is even or odd.

If the remainder of the operation is 1, then the integer is odd. If there is no remainder, then the integer is even.

What Are The Relational Operators in C?

Relational operators are used to compare values and return a result.

The result is a Boolean value. A Boolean value is either true (represented by 1) or false (represented by 0).

These operators are commonly used in decision-making statements such as if statements, and while loops.

These are the relational operators in C:

Let’s see an example of each one in action.

How to Use the Equal to (==) Operator

The equal to operator checks if two values are equal.

It essentially asks the question, "Are these two values equal?"

Note that you use the comparisson operator (two equal signs – ==) and not the assignment operator (=) which is used for assigning a value to a variable.

#include <stdio.h>

int main(void) {

    int a = 5;

    int b = 5;

    int result = (a == b);

    printf("Result: %i\n", result); // Output: Result: 1
}

The result is 1 (true), because a and b are equal.

How to Use the Not equal to (!=) Operator

The not equal to operator checks if two values are NOT equal.

#include <stdio.h>

int main(void) {

    int a = 5; 

    int b = 3;

    int result = (a != b);

    printf("Result: %i\n", result); // Output: Result: 1
}

The result is 1 (true), because a and b are not equal.

How to Use the Greater than (>) Operator

This operator compares two values to check if one is greater than the other.

#include <stdio.h>

int main(void) {

    int a = 10;

    int  b = 5;

    int result = (a > b);

    printf("Result: %i\n", result); // Output: Result: 1
}

The result is 1 (true), because a is greater than b.

How to Use the Less than (<) Operator

This operator compares two values to check if one is less than the other.

#include <stdio.h>

int main(void) {

    int a = 10;

    int b = 5;

    int result = (a < b);

    printf("Result: %i\n", result); // Output: Result: 0
}

The result is 0 (false), because a is not less than b.

How to Use the Greater than or Equal to (>=) Operator

This operator compares two values to check if one is greater than or equal to the other.

#include <stdio.h>

int main(void) {

    int a = 5;

    int  b = 5;

    int result = (a >= b);

    printf("Result: %i\n", result); // Output: Result: 1
}

The result is 1 (true), because a is equal to b.

How to Use the Less than or equal to (<=) Operator

This operator compares two values to check if one is less than or equal the other.

#include <stdio.h>

int main(void) {

    int a = 1;

    int b = 5;

    int result = (a <= b);

    printf("Result: %i\n", result); // Output: Result: 1
}

The result is 1 (true), because a is less than b.

Logical Operators

Logical operators operate on Boolean values and return a Boolean value.

Here are the logical operators used in C:

Let's go into more detail on each one in the following sections.

How to Use the AND (&&) Operator

The logical AND (&&) operator checks whether all operands are true.

The result is true only when all operands are true.

Here is the truth table for the AND (&&) operator when you are working with two operands:

Let's take the following example:

The result of (10 == 10) && (20 == 20) is true because both operands are true.

Let's look at another example:

The result of (10 == 20) && (20 == 20) is false because one of the operands is false.

When the first operand is false, the second operand is not evaluated (since there's no point - it's already determined that the first operand is false, so the result can only be false).

How to Use the OR (||) Operator

The logical OR (||) operator checks if at least one of the operands is true.

The result is true only when at least one of the operands is true.

Here is the truth table for the OR (||) operator when you are working with two operands:

Let's look at an example:

The result of (10 == 20) || (20 == 20) is true because one of the operands is true.

Let's look at another example:

The result of (20 == 20) || (10 == 20) is true because one of the operands is true

If the first operand is true, then the second operator is not evaluated.

How to Use the NOT (!) Operator

The logical NOT (!) operator negates the operand.

If the operand is true, it returns false.

And if it is false, it returns true.

You may want to use the NOT operator when when you want to flip the value of a condition and return the opposite of what the condition evaluates to.

Here is the truth table for the NOT(!) operator:

Let's look at an example:

The result of !(10 == 10) is false.

The condition 10 == 10 is true, but the ! operator negates it so the result is false.

And let's look at another example:

The result of !(10 == 20) is true.

The condition 10 == 20 is false, but the ! operator negates it.

What Is the Assignement Operator in C?

The assignment operator is used to assign a value to a variable.

#include <stdio.h>

int main(void) {

    // declare an integer variable named num
    int num;

    // assign the value 10 to num
    num = 10;

    printf("num: %i\n", num); // Output: num: 10

}

In the example above, the value 10 is assigned to the variable num using the assignment operator.

The assignment operator works by evaluating the expression on the right-hand side and then storing its result in the variable on the left-hand side.

The type of data assigned should match the data type of the variable.

How to Use Compound Assignment Operators

Compound assignment operators are shorthand notations.

They allow you to modify a variable by performing an operation on it and then storing the result of the operation back into the same variable in a single step.

This can make your code more concise and easier to read.

Some common compound assignment operators in C include:

• +=: Addition and assignment

• =: Subtraction and assignment

• =: Multiplication and assignment

• /=: Division and assignment

• %=: Modulo and assignment

Let’s see an example of how the += operator works:

#include <stdio.h>

int main(void) {

  int num = 10;

  num += 5; 

  printf("Num: %i\n", num); // Num: 15
}

In the example above, I created a variable named num and assigned it an initial value of 10.

I then wanted to increment the variable by 5. To do this, I used the += compound operator.

The line num += 5 increments the value of num by 5, and the result (15) is stored back into num in one step.

Note that the num += 5; line works exactly the same as doing num = num + 5, which would mean num = 10 + 5, but with fewer lines of code.

What Are the Increment and Decrement Operators in C?

The increment ++ and decrement -- operators increment and decrement a variable by one, respectively.

Let’s look at an example of how to use the ++ operator:

#include <stdio.h>

int main(void) {

  int num = 10;
  num++;

  printf("Num: %i\n", num); // Num: 11

}

The initial value of the variable num is 10.

By using the ++ increment operator, the value of num is set to 11.

This is like perfoming num = num + 1 but with less code.

The shorthand for decrementing a variable by one is --.

If you wanted to decrement num by one, you would do the following:

#include <stdio.h>

int main(void) {

  int num = 10;
  num--;

  printf("Num: %i\n", num); // Num: 9

}

The initial value of the variable num is 10.

By using the -- increment operator, the value of num is now set to 9.
This is like perfoming num = num - 1.

Chapter 4: Conditional Statements

The examples you have seen so far all execute line by line, from top to bottom.

They are not flexible and dynamic and do not adapt according to user behavior or specific situations.

In this chapter, you will learn how to make decisions and control the flow of a program.

You get to set the rules on what happens next in your programs by setting conditions using conditional statements.

Conditional statements take a specific action based on the result of a comparisson that takes place.

The program will decide what the next steps should be based on whether the conditions are met or not.

Certain parts of the program may not run depending on the results or depending on certain user input. The user can go down different paths depending on the various forks in the road that come up during a program's life.

First, you will learn about the if statement – the foundational building block of decision-making in C.

You will also learn about the else if and else statements that are added to the if statement to provide additional flexibility to the program.

You will then learn about the ternary operator which allows you to condense decision-making logic into a single line of code and improve the readability of your program.

How to Create an if statement in C

The most basic conditional statement in C is the if statement.

It makes a decision based on a condition.

If the given condition evaluates to true only then is the code inside the if block executed.

If the given condition evaluates to false, the code inside the if block is ignored and skipped.

The general syntax for an if statement in C is the following:

if (condition) {
  // run this code if condition is true
}

Let's look at an example:

#include <stdio.h>

int main(void) {

    // variable age
   int age;

   // prompt user to enter their age
   printf("Please enter your age: ");

   // store user's answer in the variable
   scanf("%i", &age);

    // check if age is less than 18
    // if it is, then and only then, print a message to the console

   if (age < 18) {
       printf("You need to be over 18 years old to continue\\n");
   }
}

In the above code, I created a variable named age that holds an integer value.

I then prompted the user to enter their age and stored the answer in the variable age.

Then, I created a condition that checks whether the value contained in the variable age is less than 18.

If so, I want a message printed to the console letting the user know that to proceed, the user should be at least 18 years of age.

When asked for my age and I enter 16, I'd get the following output:

#output

Please enter your age: 16
You need to be over 18 years old to continue

The condition (age < 18) evaluates to true so the code in the if block executes.

Then, I re-compile and re-run the program.

This time, when asked for my age, say I enter 28, but I don't get any output:

#output

Please enter your age: 28

This is because the condition evaluates to false and therefore the body of the if block is skipped.

I have also not specified what should happen in the case that the user's age is greater than 18.

To specify what happens in case the user's age is greater than 18, I can use an if else statement.

How to Create an if else statement in C

You can add an else clause to an if statement to provide code that will execute only when the if statement evaluates to false.

The if else statement essentially means that "if this condition is true do the following thing, else do this thing instead".

If the condition inside the parentheses evaluates to true, the code inside the if block will execute.

But if that condition evaluates to false, the code inside the else block will execute.

The else keyword is the solution for when the if condition is false and the code inside the if block doesn't run. It provides an alternative.

The general syntax looks like this:

if (condition) {
  // run this code if condition is true
} else {
  // if the condition above is false, run this code
}

Now, let's revisit the example from the previous section, and specify what should happen if the user's age is greater than 18:

#include <stdio.h>

int main(void) {
   int age;

   printf("Please enter your age: ");

   scanf("%i", &age);


    // if the condition in the parentheses is true the code inside the curly braces will execute
    // otherwise it is skipped
    // and the code in the else block will execute

   if (age < 18) {
       printf("You need to be over 18 years old to continue\n");
   } else {
      printf("You are over 18 so you can continue \n");
  }

   }

If the condition is true the code in the if block runs:

#output

Please enter your age: 14
You need to be over 18 years old to continue

If the condition is false the code in the if block is skipped and the code in the else block runs instead:

#output

Please enter your age: 45
You are over 18 so you can continue

How to Create an else if statement in C

But what happens when you want to have more than one condition to choose from?

If you wish to chose between more than one option you can introduce an else if statement.

An else if statement essentially means that "If this condition is true, do the following. If it isn't, do this instead. However, if none of the above are true and all else fails, finally do this."

The general syntax looks something like the following:

if (condition) {
   // if condition is true run this code
} else if(another_condition) {
   // if the above condition was false and this condition is true,
   // run the code in this block
} else {
   // if the two above conditions are false run this code
}

Let's see how an else if statement works.

Say you have the following example:

#include <stdio.h>

int main(void) {
   int age;

   printf("Please enter your age: ");

   scanf("%i", &age);

   if (age < 18) {
       printf("You need to be over 18 years old to continue\n");
   }  else if (age < 21) {
       printf("You need to be over 21\n");
   } else {
      printf("You are over 18 and older than 21 so you can continue \n");
  }

   }

If the first if statement is true, the rest of the block will not run:

#output

Please enter your age: 17
You need to be over 18 years old to continue

If the first if statement is false, then the program moves on to the next condition.

If that is true the code inside the else if block executes and the rest of the block doesn't run:

#output

Please enter your age: 20
You are need to be over 21

If both of the previous conditions are all false, then the last resort is the else block which is the one to execute:

#output

Please enter your age: 22
You are over 18 and older than 21 so you can continue

How to Use the Ternary Operator in C

The ternary operator (also known as the conditional operator) allows you to write an if else statement with fewer lines of code.

It can provide a way of writing more readable and concise code and comes in handy when writing simple conditional expressions.

You would want to use it when you are making making simple decisions and want to keep your code concise and on one line.

However, it's best to stick to a regular if-else statement when you are dealing with more complex decisions as the ternary operator could make your code hard to read.

The general syntax for the ternary operator looks something similar to the following:

condition ? expression_if_true : expression_if_false;

Let's break it down:

• condition is the condition you want to evaluate. This condition will evaluate to either true of false

• ? separates the condition from the two possible expressions

• expression_if_true is executed if the condition evaluates to true

• : separates the expression_if_true from the expression_if_false

• expression_if_false is executed if the condition evaluates to false.

Let's take a look at an example:

#include <stdio.h>

int main(void) {

    int x = 10;

    int y = (x > 5) ? 100 : 200;

    printf("x: %i\n", x); // x: 10

    printf("y: %i\n", y);  // y: 100
   }

In the example above, the condition is (x > 5).

If x is greater than 5, the condition evaluates to true. And when the condition is true, the value assigned to y will be 100.

If the condition evaluates to false, the value assigned to y will be 200.

So, since x is greater than 5 (x = 10), y is assigned the value 100.

Chapter 5: Loops

In this chapter you will learn about loops, which are essential for automating repetitive tasks without having to write the same code multiple times.

Loops allow you to execute a specific block of code instructions repeatedly over and over again until a certain condition is met.

You will learn about the different types of loops, such as the for , while and do-while loops, and understand their syntax and when you should use each one.

You will also learn about the break statement, which allows you to control the execution flow within loops in specific ways.

How to Create a for Loop in C

A for loop allows you to execute a block of code repeatedly based on a specified condition.

It's useful when you know how many times you want to repeat a certain action.

The general syntax for a for loop looks like this:

for (initialization; condition; increment/decrement) {
    // Code to be executed in each iteration
}

Let's break it down:

• initialization is the step where you initialize a loop control variable. It's typically used to set the starting point for your loop.

• condition is the condition that is evaluated before each iteration. If the condition is true, the loop continues. If it's false, the loop terminates. The loop will run as long as the condition remains true.

• increment/decrement is the part responsible for changing the loop control variable after each iteration. It can be an increment (++), a decrement (--), or any other modification.

• Code to be executed in each iteration is the block of code inside the for loop's body that gets executed in each iteration if the condition is true.

Let's see an example of how a for loop works.

Say you want to print the numbers from 1 to 5 to the console:

#include <stdio.h>

int main() {

    for (int i = 1; i <= 5; i++) {
        printf("Iteration %i\n", i);
    }

}

Output:

Iteration 1
Iteration 2
Iteration 3
Iteration 4
Iteration 5

In the example above, I first initialize the loop control variable i with a value of 1.

The condition i <= 5 is true, so the loop's body is executed and "Iteration 1" is printed.

After each iteration, the value of i is incremented by 1. So, i is incremented to 2.

The condition is still true, so "Iteration 2" is printed.

The loop will continue as long as i is less than or equal to 5.

When i becomes 6, the condition evaluates to false and the loop terminates.

How to Create a while Loop in C

As you saw in the previous section, a for loop is used when you know the exact number of iterations you want the loop to perform.

The while loop is useful when you want to repeat an action based on a condition but don't know the exact number of iterations beforehand.

Here is the general syntax of a while loop:

while (condition) {
    // Code to be executed in each iteration
}

With a while loop, the condition is evaluated before each iteration. If the condition is true, the loop continues. If it's false, the loop terminates.

The while loop will continue as long as the condition evaluates to true.

Something to note with while loops is that the code in the loop's body is not guaranteed to run even at least one time if a condition is not met.

Let's see an example of how a while loop works:

#include <stdio.h>

int main() {

    int count = 1;

    while (count <= 5) {

        printf("Iteration %i\n", count);

        count++;
    }

}

Output:

Iteration 1
Iteration 2
Iteration 3
Iteration 4
Iteration 5

In the example above, I first initialize a variable count with a value of 1.

Before it runs any code, the while loop checks a condition.

The condition count <= 5 is true because count is initially 1. So, the loop's body is executed and "Iteration 1" is printed.

Then, count is incremented to 2.

The condition is still true, so "Iteration 2" is printed.

The loop will continue as long as count is less than or equal to 5.

This process continues until count becomes 6, at which point the condition becomes false, and the loop terminates.

Something to be aware of when working with while loops is accidentally creating an infinite loop:

#include <stdio.h> 

int main(void)
{

    while(true)
    {
        printf("Hello world");
    }
}

In this case the condition always evaluates to true.

After printing the line of code inside the curly braces, it continuously checks wether it should run the code again.

As the answer is always yes (since the condition it needs to check is always true each and every time), it runs the code again and again and again.

The way to stop the program and escape from the endless loop is running Ctrl C in the terminal.

How to Create a do-while Loop in C

As mentioned in the previous section, the code in the while loop's body is not guaranteed to run even at least one time if the condition is not met.

A do-while loop executes a block of code repeatedly for as long as a condition remains true.

However, in contrast to a while loop, it is guaranteed to run at least once, regardless of whether the condition is true or false from the beginning.

So, the do-while loop is useful when you want to ensure that the loop's body is executed at least once before the condition is checked.

The general syntax for a do-while loop looks like this:

do {
    // Code to be executed in each iteration
} while (condition);

Let's take a look at an example that demonstrates how a do-while loop works:

#include <stdio.h>

int main() {

    int count = 1;

    do {
        printf("Iteration %i\n", count);

        count++;

    } while (count <= 5);

}

Output:

Iteration 1
Iteration 2
Iteration 3
Iteration 4
Iteration 5

In the example above I initialize a variable count with a value of 1.

A do-while loop first does something and then checks a condition.

So, the block of code inside the loop is executed at least one time.

The string "Iteration 1" is printed and then count is incremented to 2.

The condition count <= 5 is then checked and it evaluates to true, so the loop continues.

The loop will continue as long as count is less than or equal to 5.

After the iteration where count is 6, the condition becomes false, and the loop terminates.

How to Use the break Statement in C

The break statement is used to immediately exit a loop and terminate its execution.

It's a control flow statement that allows you to interrupt the normal loop execution and move on to the code after the loop.

The break statement is especially useful when you want to exit a loop under specific conditions, even if the loop's termination condition hasn't been met.

You might use it when you encounter a certain value, or when a specific condition is met.

Here's how to use a break statement in a loop:

#include <stdio.h>

int main() {
    int target = 5;

    for (int i = 1; i <= 10; i++) {
        printf("Current value: %i\n", i);

        if (i == target) {
            printf("Target value reached. Exiting loop.\n");
            break; // Exit the loop
        }
    }

}

Output:

Current value: 1
Current value: 2
Current value: 3
Current value: 4
Current value: 5
Target value reached. Exiting loop.

In the example above, a for loop is set to iterate from 1 to 10.

Inside the loop, the current value of i is printed on each iteration.

There is also an if statement that checks if the current value of i matches the target value, which is set to 5.

If i matches the target value, the if statement is triggered and a message is printed.

As a result, the break statement exits the current loop immediately and prematurely.

The program will continue executing the code that is after the loop.

Chapter 6: Arrays

Arrays offer a versatile and organized way to store multiple pieces of related data that are arranged in an ordered sequence.

They allow you to store multiple values of the same data type under a single identifier and perform repetitive tasks on each element.

In this chapter, you will learn how to declare and initialize arrays. You will also learn how to access individual elements within an array using index notation and modify them.

In addition, you will learn how to use loops to iterate through array elements and perform operations on each element.

How to Declare and Initialize an Array in C

To declare an array in C, you first specify the data type of the elements the array will store.

This means you can create arrays of type int, float, char, and so on.

You then specify the array's name, followed by the array's size in square brackets.

The size of the array is the number of elements that it can hold. This number must be a positive integer.

Keep in mind that arrays have a fixed size, and once declared, you cannot change it later on.

Here is the general syntax for declaring an array:

data_type array_name[array_size];

Here is how to declare an array of integers:

#include <stdio.h>

int main() {

   int grades[5];
}

In the example above, I created an array named grades that can store 5 int numbers.

After declaring an array, you can initialize it with initial values.

To do this, use the assignment operator, =, followed by curly braces, {}.

The curly braces will enclose the values, and each value needs to be separated by a comma.

Here is how to initialize the grades array:

#include <stdio.h>

int main() {

   int grades[5] = {50, 75, 100, 67, 90};
}

Keep in mind that the number of values should match the array size, otherwise you will encounter errors.

Something to note here is that you can also partially initialize the array:

#include <stdio.h>

int main() {

   int grades[5] = {50, 75, 100};
}

In this case, the remaining two elements will be set to 0.

Another way to initialize arrays is to omit the array's length inside the square brackets and only assign the initial values, like so:

#include <stdio.h>

int main() {

   int grades[] = {50, 75, 100, 67, 90};
}

In this example, the array's size is 5 because I assigned it 5 values.

How to Find the Length of an Array in C Using the sizeof() Operator

The sizeof operator comes in handy when you need to calculate the size of an array.

Let's see an example of the sizeof operator in action:

#include <stdio.h>

int main() {

    int grades[] = {50, 75, 100, 67, 90};

    // calculate the size of the array
    int array_size = sizeof(grades);

    printf("Size of array: %i bytes\n", array_size);
}

Output:

Size of array: 20 bytes

In the example above, sizeof(grades) calculates the total size of the array in bytes.

In this case, the array has five integers.

As mentioned in a previous chapter, on most modern systems an int typically occupies 4 bytes of memory. Therefore, the total size is 5 x 4 = 20 bytes of memory for the entire array.

Here is how you can check how much memory each int occupies using the sizeof operator:

#include <stdio.h>

int main() {

    int grades[] = {50, 75, 100, 67, 90};

    // calculate the size of a single array element
    int element_size = sizeof(grades[0]);

    printf("Size of a single element: %i bytes\n", element_size);

}

Output:

Size of a single element: 4 bytes

The sizeof(grades[0]) calculates the size of a single element in bytes.

By dividing the total size of the array by the size of a single element, you can calculate the number of elements in the array, which is equal to the array's length:

#include <stdio.h>

int main() {

    int grades[] = {50, 75, 100, 67, 90};

     int array_size = sizeof(grades);

     int element_size = sizeof(grades[0]);

     // calculate the length of the array
     int length = array_size / element_size;

    printf("Length of the array: %i elements\n", length);

}

Output:

Length of the array: 5 elements

How to Access Array Elements in C

You can access each element in an array by specifying its index or its position in the array.

Note that in C, indexing starts at 0 instead of 1.

So, the index of the first element is 0, the index of the second element is 1, and so on.

The last element in an array has an index of array_size - 1.

To access individual elements in the array, you specify the array's name followed by the element's index number inside square brackets ([]).

array_name[index];

Let's take a look at the following example:

#include <stdio.h>

int main() {

   int grades[] = {50, 75, 100, 67, 90};

   // Access each array element using index notation

   printf("Element at index 0: %i\n", grades[0]);  

   printf("Element at index 1: %i\n", grades[1]);  

   printf("Element at index 2: %i\n", grades[2]); 

   printf("Element at index 3: %i\n", grades[3]); 

   printf("Element at index 4: %i\n", grades[4]); 
}

Output:

Element at index 0: 50
Element at index 1: 75
Element at index 2: 100
Element at index 3: 67
Element at index 4: 90

In the example above, to access each item from the integer array grades, I have to specify the array's name along with the item's position in the array inside square brackets.

Remember that the index starts from 0, so grades[0] gives you the first element, grades[1] gives you the second element, and so on.

Note that if you try to access an element with an index number that is higher than array_size - 1, the compiler will return a random number:

#include <stdio.h>

int main() {

    int grades[] = {50, 75, 100, 67, 90};


    printf("Element at index 5: %d\n", grades[5]);  

}

Output:

Element at index 5: 220312136

How to Modify Array Elements in C

Once you know how to access array elements, you can then modify them.

The general syntax for modifying an array element looks like this:

array_name[index] = new_value;

You can change the value of an element by assigning a new value to it using its index.

Let's take the grades array from earlier on:

#include <stdio.h>

int main() {

   int grades[] = {50, 75, 100, 67, 90};
}

Here is how you would change the value 75 to 85:

#include <stdio.h>

int main() {

   int grades[] = {50, 75, 100, 67, 90};

   grades[1] = 85; // changing the value at index 1 to 85

   printf("Element at index 1: %i\n", grades[1]); 
}

Output:

Element at index 1: 85

When modifying arrays, keep in mind that the new value must match the declared data type of the array.

How to Loop Through an Array in C

By looping through an array, you can access and perform operations on each element sequentially.

The for loop is commonly used to iterate through arrays.

#include <stdio.h>

int main() {

    int grades[] = {50, 75, 100, 67, 90};

    for (int i = 0; i < 5; i++) {
        printf("Element at index %i: %i\n", i, grades[i]);
    }
}

Output:

Element at index 0: 50
Element at index 1: 75
Element at index 2: 100
Element at index 3: 67
Element at index 4: 90

When using a for loop to loop through an array, you have to specify the index as the loop variable, and then use the index to access each array element.

The %i placeholders are replaced with the current index i and the value at that index in the grades array, respectively.

You can also use a while loop to iterate through an array:

#include <stdio.h>

int main() {

    int grades[] = {50, 75, 100, 67, 90};

    int i = 0;

    while (i < 5) {

        printf("Element at index %i: %i\n", i, grades[i]);
        i++;
    }
}

Output:

Element at index 0: 50
Element at index 1: 75
Element at index 2: 100
Element at index 3: 67
Element at index 4: 90

When using a while loop to loop through an array, you will need an index variable, int i = 0, to keep track of the current position in the array.

The loop checks the condition (i < 5) and prints the index of the grade as well as the actual grade value.

After each grade is shown, the variable i is increased by one, and the loop continues until it has shown all the grades in the list.

A do-while works in a similar way to the while loop, but it is useful when you want to ensure that the loop body is executed at least once before checking the condition:

#include <stdio.h>

int main() {

     int grades[] = {50, 75, 100, 67, 90};

    int i = 0;

    do {
        printf("Element at index %i: %i\n", i, grades[i]);

        i++;
    } while (i < 5);
}

You can also use the sizeof operator to loop through an array.

This method is particularly useful to ensure your loop doesn't exceed the array's length:

#include <stdio.h>

int main() {

    int grades[] = {50, 75, 100, 67, 90};

    int length = sizeof(grades) / sizeof(grades[0]);

    for (int i = 0; i < length; i++) {
        printf("Element at index %i: %i\n", i, grades[i]);
    }

}

The line int length = sizeof(grades) / sizeof(grades[0]); calculates the length of the grades array.

The length is calculated by dividing the total size (in bytes) of the array by the size of a single element grades[0]. The result is stored in the length variable.

The loop then iterates through the array using this length value.

For each iteration, it prints the index i and the value of the grade at that index grades[i].

Chapter 7: Strings

In the previous chapter, you learned the basics of arrays in C.

Now, it's time to learn about strings – a special kind of array.

Strings are everywhere in programming. They are used to represent names, messages, passwords, and more.

In this chapter, you will learn about strings in C and how they are stored as arrays of characters.

You'll also learn the fundamentals of string manipulation.

Specifically, you will learn how to find a string's length and how to copy, concatenate, and compare strings in C.

What Are Strings in C?

A string is a sequence of characters, like letters, numbers, or symbols, that are used to represent text.

In C, strings are actually arrays of characters. And each character in the string has a specific position within the array.

Another unique characteristic of strings in C is that at the end of every one, there is a hidden \0 character called the 'null terminator'.

This terminator lets the computer know where the string ends.

So, the string 'Hello' in C is stored as 'Hello\0' in memory.

How to Create Strings in C

One way to create a string in C is to initialize an array of characters.

The array will contain the characters that make up the string.

Here is how you would initialize an array to create the string 'Hello':

#include <stdio.h>

int main() {
  char word[6] = {'H', 'e', 'l', 'l', 'o', '\0'};

}

Note how I specified that the array should store 6 characters despite Hello being only 5 characters long. This is due to the null operator.

Make sure to include the null terminator, \0, as the last character to signify the end of the string.

Let's look at how you would create the string 'Hello world':

#include <stdio.h>

int main() {
  char phrase[12] = {'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '\0'};
}

In this example, there is a space between the word 'Hello' and the word 'world'.

So, the array must include a blank space character.

To print the string, you use the printf() function, the %s format code and the name of the array:

#include <stdio.h>

int main() {
  char phrase[] = {'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '\0'};

  printf("%s\n", phrase);

}

Another way to create a string in C is to use a string literal.

In this case, you create an array of characters and then assign the string by enclosing it in double quotes:

#include <stdio.h>

int main() {
  char word[] = "Hello";

}

With string literals, the null terminator (\0) is implied.

Creating strings with string literals is easier, as you don't need to add the null terminator at the end. This method is also much more readable and requires less code.

However, you may want to use character arrays when you want to modify the string's content. String literals are read-only, meaning the content is fixed.

How to Manipulate Strings in C

C provides functions that allow you to perform operations on strings, such as copying, concatenating, and comparing, to name a few.

To use these functions, you first need to include the string.h header file by adding the line #include <string.h> at the top of your file.

How to Find the Length of a String in C

To calculate the length of a string, use the strlen() function:

#include <stdio.h>
#include <string.h>

int main() {
  char phrase[] = "Hello";

  int length = strlen(phrase);

  printf("String length: %i\n", length);

}

Output:

String length: 5

The strlen() function will return the number of characters that make up the string.

Note that the result does not include the null terminator, \0.

How to Copy a String in C

To copy one string into another one, you can use the strcpy() function.

You may want to copy a string in C when you need to make changes to it without modifying it. It comes in handy when you need to keep the original string's content intact.

The general syntax for the strcpy() function looks like this:

strcpy(destination_string, original_string);

The strcpy() function copies original_string into destination_string, including the null terminator ('\0').

One thing to note here is that you need to make sure the destination array has enough space for the original string:

#include <stdio.h>
#include <string.h>

int main() {

    char original[] = "Hello";

    char destination[20]; // Make sure this array is big enough

    strcpy(destination, original);

    printf("Copied string: %s\n", destination);
}

Output:

Copied string: Hello

The strcpy() function copies the original string into an empty array and returns the copied string, which also includes the null terminator character ('\0').

How to Concatenate Strings in C

You can concatenate (add) two strings together by using the strcat() function.

The general syntax for the strcat() function looks something like the following:

strcat(destination_string, original_string);

The strcat() function takes the original string and adds it to the end of destination string.

Make sure that the destination_string has enough memory for the original_string.

Something to note here is that strcat() does not create a new string.

Instead, it modifies the original destination_string, by including the original_string at the end.

Let's see an example of how strcat() works:

#include <stdio.h>
#include <string.h>

int main(void) {

  char greeting[50] = "Hello, ";

  char name[] = "Dionysia";

  strcat(greeting, name);

  printf("Message: %s\n", greeting);

}

Output:

Message: Hello, Dionysia

How to Compare Strings in C

To compare two strings for equality, you can use the strcmp() function.

The general syntax for the strcmp() function looks like this:

strcmp(string1, string2);

The strcmp() function compares string1 with string2 and returns an integer.

If the return value of strcmp() is 0, then it means the two strings are the same:

#include <stdio.h>
#include <string.h>

int main() {

  char word1[] = "apples";
  char word2[] = "apples";

  int result = strcmp(word1, word2);

  printf("Result: %i\n", result); // Result: 0

}

If the return value of strcmp() is less than 0, then it means the first word comes before the second:

#include <stdio.h>
#include <string.h>

int main() {

  char word1[] = "apples";
  char word2[] = "bananas";

  int result = strcmp(word1, word2);

  printf("Result: %i\n", result); // Result: -1

}

And if the return value of strcmp() is greater than 0, then it means the first word comes after the second one:

#include <stdio.h>
#include <string.h>

int main() {

  char word1[] = "bananas";
  char word2[] = "apples";

  int result = strcmp(word1, word2);

  printf("Result: %i\n", result); // Result: 1

}

Further learning: Advanced C Topics

While this handbook has covered a wide range of topics, there is still so much to learn, as programming is so vast.

Once you have built a solid foundation with the basics of C programming, you may want to explore more advanced concepts.

You may want to move on to learning about functions, for example. They allow you to write instructions for a specific task and reuse that code throughout your program.

You may also want to learn about pointers. Pointers in C are like arrows that show you where a specific piece of information is stored in the computer's memory.

Then, you may want to move on to learning about structures. They're like custom data containers that allow you to group different types of information under one name.

Lastly, you may want to learn how to work with files. Working with files in C allows you to read from and write to files. This is useful for tasks like saving user data, reading configuration settings, or sharing data between different programs.

These suggestions are not a definitive guide – just a few ideas for you to continue your C programming learning journey.

If you are interested in learning more, you can check out the following freeCodeCamp resources:

• C Programming Tutorial for Beginners

• Learn C Programming Using the Classic Book by Kernighan and Ritchie

• Unlock the Mysteries of Pointers in C

Conclusion

This marks the end of this introduction to the C programming language.

Thank you so much for sticking with it and making it until the end.

You learned how to work with variables, various data types, and operators.

You also learned how to write conditional statements and loops. And you learned the basics of working with arrays and strings.

Hopefully, you have gained a good understanding of some of the fundamentals of C programming, got some inspiration on what to learn next, and are excited to continue your programming journey.

Happy coding!

We just posted a full course on the freeCodeCamp.org YouTube channel that will help you understand this important concept.

Jalal Bounaim developed this course. He is an experienced developer and created the course he would have wanted when he first started programming in C.

This course is tailored for absolute beginners, ensuring no prior knowledge of pointers is required. It systematically demystifies pointers, their use, and the significance they hold in C programming. Pointers, simply put, are variables that store the memory address of another variable – they "point" to the location of data in memory. By the end of the course, you'll have a robust understanding of these powerful tools, and be able to confidently use them in your own coding projects.

The course begins with a brief introduction and then proceeds to explain what a computer is, with an emphasis on CPU, RAM, and bytes. This foundational knowledge is key to understanding how memory works, which is central to the concept of pointers.

The course moves forward to cover a range of topics, including:

• Data types
• Introduction to processes
• Process memory layout
• Variables in memory
• An illustration of a naive change_value program
• How to use pointers to change the value
• The classic swap problem

The course then delves into more specific aspects of pointers. You will learn the reason behind the identical syntax for pointer declaration and dereference, the advantages of passing by reference versus passing by value, and explore why pointers to different data types have the same size.

But that's not all! The course continues to address some commonly raised questions and confusions about pointers:

• Why do we need a pointer type if all pointers have the same size?
• What exactly are void pointers, and why do they confuse many programmers?
• What is malloc, and why is it handy? What does it have to do with void pointers?
• Are arrays just pointers?

Then, we'll dive into some of the more sophisticated aspects of pointers:

• Why arr[5] and 5[arr] are equivalent
• Introduction to pointers to pointers with **argv
• Understanding argv[] or *argv
• Pointers to functions
• Use case with pointers to functions

Jalal created this course to be as comprehensive as possible, packed with examples that illustrate how pointers work in a variety of scenarios. Each concept is explained in easy-to-understand terms, ensuring you not only learn how to use pointers but also understand the theory behind them.

Whether you're a budding coder or a seasoned programmer wanting to fill in gaps in your understanding, our course on Pointers in C is sure to offer valuable insights that will take your coding abilities to the next level. So what are you waiting for?

Watch the full course on the freeCodeCamp.org YouTube channel (2-hour watch).

Pointers are one of the most important and powerful features of the C programming language. They allow us to manipulate memory directly, which can be very useful in many programming scenarios.

In C, a pointer is simply a variable that holds a memory address. We can think of it as a way to refer to a specific location in memory.

How to Declare a Pointer

To declare a pointer variable in C, we use the asterisk * symbol before the variable name. There are two ways to declare pointer variables in C:

int *p;

int* p;

Both of these declarations are equivalent and they declare a pointer variable named "p" that can hold the memory address of an integer.

However, it's important to note that if you declare multiple variables in a single statement, you need to include the asterisk before each variable name to indicate that they are all pointers. For example:

int *p, *q, *r;

This declares three pointer variables named "p", "q", and "r" that can hold the memory address of an integer.

How to Initialize a Pointer

When we declare a pointer variable, it does not automatically point to any particular memory location. To initialize a pointer to point to a specific variable or memory location, we use the ampersand & operator to get the address of that variable.

For example, to initialize the pointer p to point to an integer variable called x, we would write:

int x = 42;
int *p = &x;

This sets the value of p to be the memory address of x.

How to Dereference a Pointer

Once we have a pointer that points to a specific memory location, we can access or modify the value stored at that location by dereferencing the pointer.

To dereference a pointer, we use the asterisk * symbol again, but this time in front of the pointer variable itself. For example, to print the value of the integer that p points to, we would write:

printf("%d\n", *p);

What Does "Pointer to a Pointer" Mean?

A pointer can also point to another pointer variable. This is known as a "pointer to a pointer". We declare a pointer to a pointer by using two asterisks **. For example:

int x = 42;
int *p = &x;
int **q = &p;

Here, q is a pointer to a pointer. It points to the address of the p variable, which in turn points to the address of the x variable

How to Pass Pointers to Functions

We can pass pointers to functions as arguments, which allows the function to modify the value of the original variable passed in. This is known as "passing by reference".

To pass a pointer to a function, we simply declare the function parameter as a pointer. For example:

void increment(int *p) {
    (*p)++;
}

int main() {
    int x = 42;
    int *p = &x;
    increment(p);
    printf("%d\n", x); // prints 43
    return 0;
}

Here, the increment function takes a pointer to an integer (int *p) and increments the value of the integer by one ((*p)++).

In main(), we declare the integer x and a pointer p that points to x. We then call the increment function, passing in the p pointer. After the function call, x has been incremented to 43.

How to Use Pointers for Dynamic Memory Allocation

One of the most powerful uses of pointers in C is for dynamic memory allocation. This allows us to allocate memory at runtime, rather than at compile time.

We use the malloc function to dynamically allocate memory, and it returns a pointer to the allocated memory. For example:

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

Here, p is a pointer to an integer that has been allocated using malloc. The sizeof operator is used to determine the size of an integer in bytes.

After allocating memory, we can use the pointer variable like any other pointer. When we are finished with the memory, we should free it using the free function. For example:

free(p);

This frees up the memory that was allocated to p.

What is Pointer Casting?

Sometimes you may need to cast a pointer from one type to another. You can do this using the (type *) syntax. For example:

double *p = (double *)malloc(sizeof(double));

Here, p is cast to a pointer to a double type.

How Does Pointer Arithmetic Work?

Because pointers hold memory addresses, we can perform arithmetic operations on them to move them to different memory locations.

For example, we can increment a pointer to move it to the next memory location. This is often used in array operations, where we use a pointer to access elements of an array.

For example, to print the first element of an integer array using a pointer, we could write:

int arr[] = {1, 2, 3};
int *p = arr; // p points to the first element of arr
printf("%d\n", *p); // prints 1

Here, p is set to point to the first element of the arr array, and *p dereferences the pointer to get the value of the first element (which is 1).

How to Use Pointer Arrays

We can also declare arrays of pointers in C. For example:

int *arr[3];

This declares an array of three pointers to integers. Each element of the array can point to a separate integer variable.

Pointer Arithmetic and Arrays

We can use pointer arithmetic to access elements of an array. For example:

int arr[] = {1, 2, 3};
int *p = arr; // p points to the first element of arr
printf("%d\n", *(p + 1)); // prints 2

Here, p is set to point to the first element of the arr array. We can use pointer arithmetic to access the second element of the array (*(p + 1)), which is 2.

Example of How to Use Pointers

Here's an example program that demonstrates some of the concepts we've discussed:

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

void increment(int *p) {
    (*p)++;
}

int main() {
    int x = 42;
    int *p = &x;
    printf("x = %d\n", x); // prints x = 42
    increment(p);
    printf("x = %d\n", x); // prints x = 43

    int *arr = (int *)malloc(3 * sizeof(int));
    arr[0] = 1;
    arr[1] = 2;
    arr[2] = 3;
    int *q = arr;
    printf("arr[0] = %d\n", *q); // prints arr[0] = 1
    q++;
    printf("arr[1] = %d\n", *q); // prints arr[1] = 2
    q++;
    printf("arr[2] = %d\n", *q); // prints arr[2] = 3
    free(arr);

    return 0;
}

Output:

This program demonstrates several concepts related to pointers.

First, we declared an integer variable x and a pointer p that points to x. We called the increment function, passing in the p pointer. The increment function modifies the value of x by incrementing it by one. We then printed the value of x before and after the function call to demonstrate that x has been incremented.

Next, we used dynamic memory allocation to allocate an array of three integers. We set the values of the array elements using pointer arithmetic (arr[0] = 1, arr[1] = 2, etc.). We then declared a pointer q that points to the first element of the array. Furthermore, we used pointer arithmetic to access and print the values of each element of the array.

Finally, we freed the memory that was allocated to the array using the free function.

This program demonstrates how pointers can be used to modify the value of a variable, access elements of an array using pointer arithmetic, and dynamically allocate and free memory.

Common Pointer Errors

Pointers can be tricky to work with, and they can lead to some common errors.

One common error is using an uninitialized pointer. If you declare a pointer variable but do not initialize it to point to a valid memory location, you may get a segmentation fault or other error when you try to dereference the pointer.

Another common error is dereferencing a null pointer, which can also cause a segmentation fault.

Another error to be aware of is using the wrong type of pointer. For example, if you declare a pointer to an integer but then try to dereference it as a pointer to a character, you may get unexpected results or errors.

Conclusion

Pointers are a powerful tool in C programming, but they can be a bit tricky to work with. With practice and patience, you can master pointers and use them to manipulate memory and work with complex data structures.

Thank you for reading!

In this article, I will show you practical examples of the strcmp function, and offer insights into how it compares strings, what its return values mean, and how to use it effectively.

You'll also see some best practices to help optimize your code.

What are Strings in C?

Before we discuss the strcmp function, it is important to understand the basics of strings in C.

A string is an array of characters terminated by a null character ('\0').
Strings are usually represented either using character pointers ( char * ) or character arrays ( char [] ).

What is the strcmp() function of C, and how does it work?

The strcmp() function is part of the standard C library ( string.h ). Its primary purpose is to compare the characters of the two strings in sequence until it finds a mismatch or until the end of the strings is reached (that is, the null character '\0'). In our programming world, we call it lexicographic order-based searching.

The function prototype for strcmp is as follows:

int strcmp(const char *s1, const char *s2);

Here's what the parameters above mean:

• s1 denotes the first string to be compared.
• s2 denotes the second string to be compared.

strcmp() is like a game that compares two words. It helps us to identify whether a word comes before or after another word in the dictionary.

• If the first word (s1) comes before the second word (s2) in the dictionary, strcmp() gives a negative number.
• If the first word (s1) comes after the second (s2) word in the dictionary, strcmp() gives a positive number.
• If both words are the same, strcmp() gives the number 0.

strcmp() compares the corresponding characters from both strings based on their ASCII values, which are numeric codes that represent each character.

Therefore, if the ASCII value of the first differing character in the first string is less than the ASCII value of the corresponding character in the second string, strcmp() returns a negative number. This indicates that the first string comes before the second string in the dictionary.

If the ASCII value of the first differing character in the first string is greater than the ASCII value of the corresponding character in the second string, strcmp() returns a positive number. This indicates that the first string comes after the second string in the dictionary.

If the two strings are equal up to the end of the shorter string, strcmp() returns a negative, zero, or positive value depending on whether the longer string has a character with a smaller, equal, or greater ASCII value than the null character.

Actually, the C compiler implements this logic of comparing the ASCII values of characters in two strings and returning the result accordingly.

strcmp() Function Example #1 – Basic String Comparison

#include <stdio.h>
#include <string.h>

int main() {
    char str1[] = "apple";
    char str2[] = "banana";

    int result = strcmp(str1, str2);

    if (result == 0) {
        printf("The strings are equal.\n");
    } else if (result < 0) {
        printf("String 1 is less than string 2.\n");
    } else {
        printf("String 1 is greater than string 2.\n");
    }

    return 0;
}

Output:

String 1 is less than string 2.

Let me now explain each of the lines from the code given above.

Here, I have taken two different strings as two different character arrays, as we do not have access to direct strings in the C programming language.

In the first character string ( str1[] ), I have stored the string apple. In the second character string ( str2[] ), I have stored the string banana. As the function strcmp() gives a boolean output (true/false, or 0/1), I have taken another int variable named result to store the boolean value ( 1 for true and 0 for false).

The strcmp() function compares the two strings, and finds out that the first string apple comes before the second string banana. Therefore, the function strcmp() returns a negative value indicating that the first string is less than the second string.

Based on the value in result, it prints String 1 is less than string 2..

If you are confused about "the string comes before or after another string" then let me explain to you a bit more.

When we say that the first string comes before the second string, we mean that if the two strings were listed in a dictionary or a sorted list of words, the first string would appear before the second string.

In the case of the program above, the first string is "apple", and the second string is "banana". If we were to look up these two words in a dictionary, we would find that "apple" appears before "banana", which means that the first string comes before the second string.

The strcmp() function compares the two strings character by character and determines which string comes first in the dictionary based on the ASCII values of the characters.

In this case, the first character of "apple" (which is 'a') has a lower ASCII value (ASCII value for a = 97) than the first character of "banana" (which is 'b' and the ASCII value for b = 98), so strcmp() returns a negative value, indicating that the first string comes before the second string.

I hope this clears up any confusion regarding what the phrase "one string comes after/before another string" means.

strcmp() Function Example #2 – Case-insensitive String Comparison

#include <stdio.h>
#include <string.h>

int main() {
    char str1[] = "Apple";
    char str2[] = "apple";

    // Convert both strings to lowercase
    for (int i = 0; str1[i]; i++) {
        str1[i] = tolower(str1[i]);
    }
    for (int i = 0; str2[i]; i++) {
        str2[i] = tolower(str2[i]);
    }

    int result = strcmp(str1, str2);

    if (result == 0) {
        printf("The strings are equal.\n");
    } else if (result < 0) {
        printf("String 1 is less than string 2.\n");
    } else {
        printf("String 1 is greater than string 2.\n");
    }

    return 0;
}

Output:

The strings are equal.

Here I converted both strings into lowercase. I used a for loop to change all the characters in the string to lowercase using the function tolower(). The for loops convert both strings to lowercase by iterating over each character of the strings using an index variable i, and calling the tolower() function on each character to convert it to lowercase.

After converting both strings into lowercase, I called the function strcmp() to check whether both strings are equal or not, like earlier. I stored the output of the strcmp() function in a new variable named result, like earlier.

The if statement checks the value of result and prints out the corresponding message depending on whether the strings are equal, or which string is less or greater. Here, the two strings become equal after converting them to lowercase. Thus, the first if statement executes and provides the output.

Keep in mind that, after converting both strings to lowercase, the value of str1 is "apple", which is the same as the value of str2 in the ASCII.

Therefore, when the strcmp() function is called, it returns 0, which indicates that the strings are equal. This can be useful when we want to compare strings that may differ in case but should be considered equal.

strcmp() Best Practices

Here are some best practices to follow when using the strcmp() function:

• Always include the string.h header when using strcmp().
• To compare case-insensitive strings, use a custom function like strcasecmp() or a standard library function like stricmp().
• Be cautious when comparing strings that may contain non-ASCII characters, as strcmp() uses the difference in ASCII values for comparisons, which might not work as expected for non-ASCII characters. In such cases, consider using a Unicode-aware comparison function or library.

If you want to learn more about ASCII characters, check out this article.

Alternative String Comparison Functions

Apart from strcmp(), there are other string comparison functions available in the C standard library:

• strncmp(): Compares up to a specified number of characters of two strings. It is useful when you want to compare only a portion of the strings.
• strcoll(): This is quite interesting. Let me explain more about this.

The strcoll() function is like a game that helps us compare two words or strings, just like strcmp(). But strcoll() is designed to handle strings that contain non-ASCII characters or require language-specific comparisons, such as words from different languages.

strcoll() uses the rules for comparing words that are specific to the language or region, based on the current locale setting of the computer. In other words, it compares words according to the language-specific collation rules of the locale, which may be different from the standard ASCII ordering used by strcmp().

For example, in the Spanish language, the word "cañón" (which means "canyon" in English) is sorted after "casa" (which means "house" in English), because the letter "ñ" is considered a separate letter in the Spanish alphabet, and comes after "n".

So, strcoll() can be useful for comparing words from different languages or regions that have specific collation rules, and we use this function for this kind of specific need.

Conclusion

In this article, we've explored the strcmp() function in C, how it compares strings, and its return values. We've also looked at examples and best practices for using strcmp effectively.

With this knowledge, you can easily compare strings in C like a pro. Remember to consider alternative comparison functions like strncmp() and strcoll() when working with specific use cases, such as partial or locale-specific string comparisons.

If this article helps you in any way, then let me know via Twitter or LinkedIn. You can also follow me on GitHub and check my YouTube channel, and my website. You can also buy me a coffee if you want to support me.

Cover: Photo by Max Duzij on Unsplash

We'll look at functions in C, their syntax, and how to use them successfully in this article.

What is a Function in C?

A function is a block of code that executes a particular task in programing. It is a standalone piece of code that can be called from anywhere in the program.

A function can take in parameters, run computations, and output a value. A function in C can be created using this syntax:

return_type function_name(parameter list) {
   // function body
}

The return_type specifies the type of value that the function will return. If the function does not return anything, the return_type will be void.

The function_name is the name of the function, and the parameter list specifies the parameters that the function will take in.

How to Declare a Function in C

Declaring a function in C informs the compiler about the presence of a function without giving implementation details. This enables the function to be called by other sections of the software before it is specified or implemented.

A function declaration usually contains the function name, return type, and the parameter types. The following is the syntax for defining a function in C:

return_type function_name(parameter_list);

Here, return_type is the data type of the value that the function returns. function_name is the name of the function, and parameter_list is the list of parameters that the function takes as input.

For example, suppose we have a function called add that takes two integers as input and returns their sum. We can declare the function as follows:

int add(int num1, int num2);

This tells the compiler that there is a function called add that takes two integers as input and returns an integer as output.

It's worth noting that function declarations do not include the function body, which includes the actual code that runs when the function is invoked.

The body of the function is defined independently of the function statement, usually in a separate block of code called the function definition.

Here's an example:

#include <stdio.h>

/* function statement */
int add(int a, int b);

/* function definition */
int add(int a, int b) {
    return a + b;
}

int main() {
    int result = add(2, 3);
    printf("The result is %d\n", result);
    return 0;
}

In this example, the add function is declared with a function statement at the top of the file, which specifies its name, return type (int), and parameters (a and b, both ints).

The actual code for the add function is defined in the function definition. Here, the function simply adds its two parameters and returns the result.

The main function calls the add function with arguments 2 and 3, and stores the result in the result variable. Finally, it prints the result using the printf function.

How to Use a Function in Multiple Source Files

If you want to use a function in numerous source files, you must include a function declaration (also known as a function prototype) in the header file and the definition in one source file.

when you build, you first compile the source files to object files, and then you link the object files into the final executable.

Let's create a header file called myfunctions.h:

#ifndef MYFUNCTIONS_H
#define MYFUNCTIONS_H

int add(int a, int b);// Function prototype, its declaration

#endif /* MYFUNCTIONS_H */

In this header file, we declare a function add using a function statement.

Next, let's create a source file called myfunctions.c, which defines the add function:

#include "myfunctions.h"

int add(int a, int b) {
    return a + b;
}

In this file, we include the myfunctions.h header file using quotes, and we define the add function.

Finally, let's create a source file called main.c, which uses the add function:

#include <stdio.h>
#include "myfunctions.h"

int main() {
    int a = 10, b = 5;
    int sum = add(a, b);

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

    return 0;
}

In this file, we include both the stdio.h header file and our myfunctions.h header file using angle brackets and quotes, respectively. We then call the add function, passing in values a and b and storing the result in sum. Finally, we print the result using printf.

The way you create it is heavily influenced by your environment. If you are using an IDE (such as Visual Studio), you must position all files in the proper locations in the project.

If you are creating from the command line e.g Linux. To compile this program, you would need to compile both myfunctions.c and main.c and link them together as shown below:

gcc -c myfunctions.c
gcc -c main.c
gcc -o program main.o myfunctions.o

The -c option instructs the compiler to create an object file with the same name as the source file but with a .o suffix. The final instruction joins the two object files to create the final executable, which is named program (the -o option specifies the name of the output file).

What Happens if You Call a Function Before Its Declaration in C?

In this instance, the computer believes the usual return type is an integer. If the function gives a different data type, it throws an error.

If the return type is also an integer, it will function properly. But some cautions may be generated:

#include<stdio.h>
main() {
   printf("The returned value: %d", function);
}
char function() {
   return 'V';
}

In this code, the function function() is called before it is declared. This returns an error:

warnings and errors

How to Define a Function in C

Assuming you want to create a code that accepts two integers and returns their sum, you can define a function that does that this way:

int sum(int num1, int num2) {
   int result = num1 + num2;
   return result;
}

In this example, the function sum takes in two integer parameters – num1 and num2. The function calculates their sum and returns the result. The return type of the function is int.

Where Should a Function Be Defined?

In C, a function can be defined anywhere in the program, as long as it is defined before it is used. But it is a good practice to define functions at the beginning of the file or in a separate file to make the code more readable and organized.

Here's an example code showing how to define a function in C:

#include <stdio.h>

// function declaration (also known as function prototype)
int add(int a, int b);

int main() {
   int x = 10, y = 20, sum;
   sum = add(x, y);
   printf("The sum of %d and %d is %d\n", x, y, sum);
   return 0;
}

// function definition
int add(int a, int b) {
   int result;
   result = a + b;
   return result;
}

In this example, the function add() is defined after its declaration (or prototype) within the same file.

Another approach is to define the function in a separate header file, which is then included in the main file using the #include directive. For example:

// header file: math.h
#ifndef MATH_H
#define MATH_H

int add(int a, int b);

#endif

// main file: main.c
#include <stdio.h>
#include "math.h"  // include the header file

int main() {
   int x = 10, y = 20, sum;
   sum = add(x, y);
   printf("The sum of %d and %d is %d\n", x, y, sum);
   return 0;
}

// implementation file: math.c
int add(int a, int b) {
   int result;
   result = a + b;
   return result;
}

In this approach, the function declaration (or prototype) is included in the header file math.h, which is then included in the main file main.c using the #include directive. The function implementation is defined in a separate file math.c.

This approach allows for better code organization and modularity, as the function implementation can be separated from the main program code.

How to Call a Function in C

We can call a function from anywhere in the program once we've defined it. We use the function name followed by the argument list in parentheses to call a function. For example, we can use the following code to call the sum function that we defined earlier:

int a = 5;
int b = 10;
int c = sum(a, b);

In this code, we are calling the sum function with a and b as its parameters. The function returns the sum of a and b, which is then stored in the variable c.

How to Pass Parameters to a Function

There are two methods of passing parameters (also called arguments) to a function in C: by value and by reference.

When we pass a parameter by value, the method receives a copy of the parameter's value. Changes to the parameter within the code have no effect on the initial variable outside the function.

When we pass a parameter by reference, the method receives a link to the parameter's memory location. Any modifications to the parameter within the code will have an impact on the initial variable outside the function.

Consider the following examples of passing parameters by value and by reference. Assuming we want to create a function that accepts an integer and multiplies it by two, the function can be defined as follows:

void doubleValue(int num) {
   num = num * 2;
}

In this example, the function doubleValue takes in an integer parameter num by value. It doubles the value of num and assigns it back to num. However, this change will not affect the original value of num outside the function.

Here's another example that shows how you can pass a single parameter by value:

#include <stdio.h>

void square(int num) {
    // Function to calculate the square of a number.
    int result = num * num;
    printf("%d\n", result);
}

int main() {
    square(5);  // Output: 25
    return 0;
}

In this example, we define a function called square that takes an integer parameter num by value. Inside the function, we calculate the square of num and print the result. We then call the function with the argument 5.

Now, let's look at an example of passing a parameter by reference:

#include <stdio.h>

void square(int* num) {
    // Function to calculate the square of a number.
    *num = (*num) * (*num);
}

int main() {
    int x = 5;
    square(&x);
    printf("%d\n", x);  // Output: 25
    return 0;
}

In this example, we define a function square that takes an integer pointer parameter num by reference. Inside the function, we reference the pointer and calculate the square of the value pointed to by num.

We then call the function with the address of the integer variable x. After calling the function, the value of x is modified to be the square of its original value, which we then print in the main function.

Conclusion

In conclusion, functions are an essential component of C programming. You can use them to divide large problems into smaller, more manageable pieces of code.

You can declare and define functions in C, and pass parameters either by value or by reference. It's a good practice to declare all functions before using them, and to define them at the beginning of the file or in a separate file for better code organization and modularity.

By using functions effectively, you can write cleaner, more readable code that is easier to debug and maintain.

I will first explain how to declare and initialize arrays.

Then, I will also go over how to access and change items in an array in C with the help of code examples along the way.

Let's get into it!

What Is An Array in C Programming?

An array is a data structure that stores multiple values in a single variable and in a sequential order that is easily accessible.

Arrays in C are a collection of values that store items of the same data type – an integer array holds only elements of the type int, a float array holds only elements of the type float, and so on.

How to Declare an Integer Array in C Programming

The general syntax for declaring an array in C looks as you can see it in the code snippet below:

data_type array_name[array_size];

Let's take the following example:

int my_numbers[5];

Let's break it down:

• I first defined the data type of the array, int.
• I then specified the name, my_numbers, followed by a pair of opening and closing square brackets,[].
• Inside the square brackets, I defined the size (5), meaning the array can hold 5 integer values.
• Finally, I ended the statement with a semicolon (;).

Once you have set the array type and size during declaration, the array can't hold items of another type.

The array is also fixed in size, meaning you cannot add or remove items.

How to Initialize an Integer Array in C Programming

There are a couple of ways you can initialize an integer array in C.

The first way is to initialize the array during declaration and insert the values inside a pair of opening and closing curly braces, {}.

The general syntax to do that looks like this:

data_type array_name[array_size] = {value1, value2, value3, ...};

Let's take the array I declared in the previous section that can hold five integers and initialize it with some values:

int my_numbers[5] = {10, 20, 30, 40, 50};

In the example above, I placed five comma-separated values inside curly braces, and assigned those values to my_numbers through the assignment operator (=).

Something to note here is that when you specify the size of the array, you can assign less number of elements, like so:

int my_numbers[5] = {10, 20, 30};

Although the size of the array is 5, I only placed three values inside it.

The array can hold two more items, and those remaining two positions have a default value of 0.

Another way to initialize an array is to not specify the size, like so:

int my_numbers[] = {10, 20, 30, 40, 50};

Even though I did not set the size of the array, the compiler knows its size because it knows the number of items stored inside it.

How to Access Items in an Integer Array in C Programming

To access an element in an array, you have to specify the index of the element in square brackets after the array name.

The syntax to access an element looks like this:

array_name[element_index]

In C and programming in general, an array index always starts at 0, becuase in computer science, counting starts from 0.

So, the first item in an array has an index of 0, the second item has an index of 1, the third item has an index of 2, and so on.

Taking the same array from the previous section, here is how you would access the first element, that is, 10:

#include <stdio.h>
int main() {
  int my_numbers[] = {10, 20, 30, 40, 50};
  printf("%d\n",my_numbers[0]);
  return 0;
}

Keep in mind that the last element in an array has an index of array_size -1 – it is always one less than the size of the array. So, in an array that holds five elements, the index of the last element is 4.

If in an array of five items, you try to access the last element by using an index of 5, the program will run, but the element is not available, and you will get undefined behavior:

#include <stdio.h>
int main() {
  int my_numbers[] = {10, 20, 30, 40, 50};
  printf("%d\n",my_numbers[5]);
  return 0;
}

// output
// -463152408

How to Change Items in an Integer Array in C Programming

To change the value of a specific element, specify its index number and, with the assignment operator, =, assign a new value:

#include <stdio.h>
int main() {
  int my_numbers[] = {10, 20, 30, 40, 50};
  my_numbers[0] = 11;
  return 0;
}

In the example above, I changed the first item in the array from 10 to 11.

Conclusion

And there you have it! You now know the basics of working with arrays in C.

To learn more about C, give this C beginner's handbook a read to become familiar with the basics of the language.

Thanks for reading, and happy coding!

I will first explain what operators are in programming and list the different types of operators available in C.

Then, you will learn the role logical operators have and how to use them with the help of code examples along the way.

Let's get into it!

What Is An Operator in Computer Programming?

In computer programing, an operator is a character, symbol, keyword, or combination of those. It determines what action gets performed on one or more operands.

An operand is an individual data item that gets manipulated by the operator.

Each high-level programming language defines these built-in characters and uses them to tell the compiler to perform arithmetic, relational or logical operations that manipulate data items and then return a final result.

What Are The Different Types of Operators in C Programming?

In C programming, operators fall into one of three categories:

• Unary operators
• Binary operators
• Ternary operators

Unary operators operate on a single operand. Some of the unary operators in C are:

• Arithmetic operators such as the increment operator(++), which increments the value of the operand by 1. And the decrement operator(--), which decrements the value of the operand by 1.
• Logical operators like the NOT(!) operator. This operator reverses the logical value of the operand – it changes true to false and false to true.
• Bitwise operators like the NOT(~) operator, which changes each 0 bit to 1 and each 1 bit to 0.

Binary operators operate on two operands. Some of the binary operators in C are:

• Arithmetic operators (+, -, *, /, %). These operators perform mathematical calculations on numerical data such as addition, subtraction, multiplication, division, and finding the remainder.
• Equality/Relational operators (==, !=, >, <, >=, <=). These operators compare two values and determine if one operand is greater than, less than, equal to, or not equal to the other operand.
• Logical/Conditional operators such as the AND(&&) and OR(||) operators.
• Bitwise operators ((&, |, ^, <<, >>), which treat data items as a sequence of bits (that is, 0s and 1s).
• Assignment operators (=, +=, -=, *=, /=, %=), which assign a specific value to a variable.

The Ternary operator (?:) operates on three operands. The general syntax looks something similar to the following:

(condition) ? expression1 : expression2;

The ternary operator is a conditional operator you can use as a shorthand for an if..else statement. It performs comparisons and returns a result.

What Is the Role of Logical Operators in C Programming?

You will see logical operators commonly used in conditional statements (such as if..else statements) since they aid in decision making – they determine what action should take place and what code should run next based on conditions you set.

You combine logical operators with one or multiple conditions to create a logical expression.

The logical operators evaluate the logical expression and return a result.

The result is always a Boolean value. A Boolean value determines whether the expression is true or false.

There are three logical operators in C programming: logical AND(&&), logical OR(||), and logical NOT (!).

Let's go into more detail on each one in the following sections.

How to Use the AND (&&) Logical Operator in C Programming

The logical AND(&&) operator checks whether all operands are true – the result is true only when all operands are true.

Here is the truth table for the AND(&&) operator when you are working with two operands: | First Operand | Second Operand | Result | | --- | --- | --- | | true | true | true | | true | false | false | | false | true | false | | false | false | false |

Something to note here is that, when the first operand is false, the second operand is not evaluated.

Let's look at an example: The result of (10 == 10) && (20 == 20) is true because both operands are true – (10 == 10) is true and (20 == 20) is true.

Let's look at another example: The result of (10 == 20) && (20 == 20) is false because one of the operands is false – in this case, the first operand is false, so the second operand doesn't get evaluated.

Now, let's see how you can use the && operator in an if statement:

#include <stdio.h>

int main(void) {
  int a = 20;
  int b = 30;

  if (a > 10 && b > 10)
    printf("Both numbers are greater than 10\n");
}

// output

// Both numbers are greater than 10

In the example above, the output is Both numbers are greater than 10 because the condition a > 10 && b > 10 is satisfied.

Both a > 10 and b > 10 are true, so the result is true.

If either a or b did not satisfy the condition, then there would be no output in the console since I have not specified an else condition.

How to Use the OR (||) Logical Operator in C Programming

The logical OR(||) operator checks whether one of the operands is true – the result is true if at least one of the operands is true.

Here is the truth table for the OR(||) operator when you are working with two operands: | First Operand | Second Operand | Result | | --- | --- | --- | | true | true | true | | true | false | true | | false | true | true | | false | false | false |

Note that with the OR (||) operator, if the first operand is true, then the second operator is not evaluated.

Let's look at an example: The result of (10 == 20) || (20 == 20) is true because at least one of the operands is true, in this case, it is the second operand, even if the first operand is false.

Let's look at another example: The result of (20 == 20) || (10 == 20) is true because one of the operands is true – in this case, since the first operand is true, the second one is not evaluated.

Now, let's see how you can use the OR (||) operator in an if statement:

#include <stdio.h>

int main(void) {
  int a = 20;
  int b = 5;

  if (a > 10 || b > 10)
    printf("At least one of the numbers is greater than 10");
}

In the example above, the output is At least one of the numbers is greater than 10 because the condition a > 10 || b > 10 is satisfied – at least one of the operands is true.

The first condition, a > 10, is true, so the result is true.

If both a and b were false, there would be no output.

How to Use the NOT (!) Logical Operator in C Programming

The logical NOT(!) operator negates the operand – that is, it returns the opposite of the operand.

If the operand is true, it returns false.

And if it is false, it returns true.

Here is the truth table for the NOT(!) operator: | Operand | Result | | --- | --- | | true | false | | false | true |

Let's look at an example: The result of !(10 == 10) is false.

The condition 10 == 10 is true, but the ! operator negates it.

And let's look at another example: The result of !(10 == 20) is true.

The condition 10 == 20 is false, but the ! operator negates it.

Now, check the example below for how you can use the NOT(!) operator in an if statement:

#include <stdio.h>

int main(void) {
  int a = 20;
  int b = 5;

  if ( a > b)
    printf("a is greater than b\n");
}

The output is a is greater than b because the condition a > b is true.

However, if you used the NOT(!) operator, the condition is no longer true, so there would be no output:

#include <stdio.h>

int main(void) {
  int a = 20;
  int b = 5;

  if ( !(a > b))
    printf("a is greater than b\n");
}

Conclusion

And there you have it! You now know how the three logical operators work in C programming.

To learn more about C, give this C beginner's handbook a read to become familiar with the basics of the language.

Thanks for reading, and happy coding!

Input is an essential part of most programs, and the scanf() function provides an easy way to read input in a variety of formats. But it's important to use scanf() carefully and to always validate user input to prevent security vulnerabilities and unexpected program behavior.

In this article, we'll take a closer look at the scanf() function and how to use it effectively in C programming.

What you will learn

Here are some things that you will learn:

1. What scanf() is and what it's used for
2. How to use scanf() to read input from the user or from a file
3. The syntax of the scanf() function and how to use conversion specifiers to read input
4. How to store input in variables using pointers
5. The importance of input validation and error checking to prevent unexpected program behavior and security vulnerabilities

Syntax of the scanf() function

The basic syntax of the scanf() function is as follows:

int scanf(const char *format, ...);

The scanf() function returns the number of items successfully read, or EOF if an error occurs or the end of the input stream is reached.

The function takes two arguments:

1. format: A string that specifies the format of the input to be read. This string can contain conversion specifiers that tell scanf() what type of input to expect and how to read it. See the next section for more details on conversion specifiers.
2. ...: A variable-length argument list that contains the memory addresses of variables where the input values will be stored. These memory addresses must be passed as pointers.

How to Use Conversion Specifiers to Read Input

The scanf() function takes a format string as its first argument, which specifies the format and data types of the input that will be read.

The format string can include conversion specifiers, which begin with the percent sign (%) and are followed by one or more characters that specify the type of data to be read.

The most common conversion specifiers are:

• %d: reads an integer value
• %f: reads a floating-point value
• %c: reads a single character
• %s: reads a string of characters
• %lf: reads a double-precision floating-point value

After the format string, the scanf() function takes a variable number of arguments, each of which is a pointer to the variable where the input value will be stored. The number and type of arguments must match the conversion specifiers in the format string.

For example, the following code reads an integer value and a floating-point value from the user, and stores them in the variables num and fnum, respectively:

#include <stdio.h>

int main() {
    int num;
    float fnum;
    printf("Enter an integer and a floating-point number: ");
    scanf("%d %f", &num, &fnum);
    printf("You entered %d and %f\n", num, fnum);
    return 0;
}

Below is the expected output:

output

In this example, the format string "%d %f" tells scanf() to read an integer value followed by a floating-point value, separated by a space. The & operator is used to pass the address of the num and fnum variables to scanf(), so that the input values can be stored in those variables.

Conversion Specifiers vs Type Specifiers

In the C programming language, "conversion specifiers" and "type specifiers" are related concepts, but they have different meanings and purposes.

A "type specifier" is a keyword that specifies the data type of a variable or expression. For example, the int, float, and char keywords are type specifiers that indicate integer, floating-point, and character data types, respectively. We use type specifiers to declare variables and functions and to define the return type of a function.

On the other hand, a "conversion specifier" is a symbol we use in format strings to specify the format of input and output operations. Conversion specifiers start with the % character, followed by a single letter or sequence of characters that indicates the type of data to be read or written. For example, the %d conversion specifier reads integer values, while the %f specifier reads floating-point values.

In summary, type specifiers are used to specify the data type of variables and expressions, while conversion specifiers are used to specify the format of input and output operations. Both concepts are important in C programming and are used in different contexts.

How to Store Input in Variables Using Pointers

To store input in a variable using scanf(), you need to pass the memory address of the variable as an argument to the function using the & (address of) operator. This is because scanf() expects pointers as arguments to store input values directly in memory locations.

Here's an example of using scanf() to read an integer value from the user and store it in a variable called num:

int num;
printf("Enter an integer: ");
scanf("%d", &num);

In this example, the %d conversion specifier tells scanf() to expect an integer input value. The memory address of the num variable is passed to scanf() using the & operator, which returns a pointer to the memory location of num.

If you need to read multiple input values, you can pass multiple pointers as arguments to scanf() in the order that they appear in the format string. For example, to read two integer values and store them in variables num1 and num2, you could do:

int num1, num2;
printf("Enter two integers: ");
scanf("%d %d", &num1, &num2);

Note that it's important to make sure that the data types of the input values match the data types of the variables that you're storing them in. If the types don't match, the input value may be interpreted incorrectly, leading to unexpected program behavior.

Additionally, it's a good practice to validate input values and handle input errors, as discussed in the next section.

Input Validation and Error Checking

Input validation and error checking are important concepts in programming, especially when dealing with user input or input from external sources. In C, you can use various techniques to validate input and handle input errors.

One common technique is to use the return value of scanf() to check if the input operation was successful or if an error occurred. The scanf() function returns the number of input values that were successfully read and stored, or EOF if an error occurred or the end of the input stream was reached.

By checking the return value, you can determine if the input operation was successful or if an error occurred.

For example, if you're using scanf() to read an integer value from the user and store it in a variable called num, you could use the following code to validate the input:

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

int main() {
    int num;
    printf("Enter an integer: ");
    if (scanf("%d", &num) != 1) {
        printf("Error: Invalid input\n");
        exit(1);
    }
    return 0;
}

In this example, the scanf() function is used to read an integer value and store it in the num variable. The return value of scanf() is compared to 1 to check if one input value was successfully read and stored. If the return value is not 1, an error message is printed to the console and the program exits with an error code.

Below is the expected output:

Output

You can use similar techniques to validate input of other types, such as floating-point numbers or strings. For example, to validate the input of a floating-point value, you could use the %f conversion specifier and check if the return value of scanf() is equal to 1.

In addition to checking the return value of scanf(), you can also use other techniques to validate input and handle errors, such as using fgets() to read input as a string and then parsing the string to extract the desired values, or using regular expressions to validate input patterns.

It's important to carefully validate input and handle errors to prevent unexpected program behavior or security vulnerabilities.

scanf() and the Standard C Library

The scanf() function is included in the standard C library, which provides a collection of pre-defined functions that you can use in C programs. The stdio.h header file is also part of the standard C library and contains declarations for input and output functions like scanf(), printf(), and others.

To use the scanf() function in a C program, you need to include the stdio.h header file at the beginning of your program using the #include preprocessor directive. This allows you to access the functions and data types defined in the standard C library, including scanf().

Here's an example of how to use scanf() in a C program:

#include <stdio.h>

int main() {
    int num;
    printf("Enter an integer: ");
    scanf("%d", &num);
    printf("You entered: %d\n", num);
    return 0;
}

In this example, we first include the stdio.h header file using #include. We then define a variable num of type int. We use the printf() function to prompt the user to enter an integer, and the scanf() function reads the user's input and stores it in the num variable. Finally, we use another printf() statement to print the value of num.

Note that we use the & operator before the variable name in the scanf() function to pass the memory address of the variable to the function. This allows the scanf() function to store the user's input directly in the variable.

Conclusion

The scanf() function in C is a powerful tool for reading input from the user or from a file and storing it in variables. By specifying conversion specifiers in the format string, you can read input values of different types, such as integers, floating-point numbers, and strings.

When using scanf(), it's important to be aware of potential input errors and to validate input values to prevent unexpected program behavior or security vulnerabilities.

You can use the return value of scanf() to check if the input operation was successful. You can also use various techniques to validate input and handle errors, such as checking input ranges, using regular expressions, or converting input values to strings and parsing them.

Overall, scanf() is a versatile function that you can use in a variety of programming scenarios. By understanding how to use scanf() effectively and how to validate and handle input errors, you can build robust and reliable C programs that interact with users and external data sources in a safe and secure manner.

Before approaching the process of running your first C or C++ code on Visual Studio Code, let me guide you through the process and get it all set up based on the operating system you are using on your computer.

C and C++ compilers

For running C or C++ code, you just need to have a valid C/C++ compiler installed on your computer. If you are using a Linux operating system, then there is a high chance that it is already installed on your system. But we need to make sure that it is correctly installed.

For checking whether or not you have the compiler (GCC/G++/MinGW) installed on your system or not, you have to check the compiler version first.

Simply open your terminal and use gcc --version and g++ --version. If you get the version number, then the compiler is already installed on your system.

You can check the version using the same commands on any operating system, whether that is a Windows, Linux, or macOS-based operating system.

If you get feedback on your terminal that it does not know anything about GCC or G++, then you have to install the compiler correctly.

If you are using the most used Windows operating system, then I already have written an in-depth article showing you all the processes step-by-step on freeCodeCamp. Make sure to read the entire article first, as it also contains a complete video to provide you with complete support.

Embedded content

If you are using another operating system, and you don't have the compilers installed, then make sure to install them before proceeding.

How to Install VS Code or VS Code Insiders

You have to download Visual Studio Code directly from the official website: https://code.visualstudio.com/.

If you want, you can also install VS Code Insiders, and the same process is applicable for that as well.

Visual Studio Code Insiders is actually the "Insiders" build of Visual Studio Code, which contains all the latest features that are shipped daily. You can think of VS Code as the stable release and the VS Code Insiders as the Insiders release of that.

If you want to experience the latest updates instantly, then you might also try Visual Studio Code Insiders (I use it myself). For downloading VS Code Insiders, you can visit the official website for VS Code Insiders here: https://code.visualstudio.com/insiders/

Make sure to download the exact file for your operating system.

Download Page: VS Code

Download Page: VS Code Insiders

The installation process is pretty basic. But I am going to show you all the steps sequentially. For now, I am going to show you the installation process using VS Code Insiders, but everything you will see here is going to be exactly the same for VS Code as well.

Make sure to click the box on the "I accept the agreement " box and click on Next.

Accept the agreement and click Next

Keep everything as it is. Do not change anything from here.

Click Next

Click Next. Again, simply click Next.

Click Next

Make sure to add the checkmark (✔) on all of the boxes. Then click on Next.

Check all of the boxes, and click Next

Click on Install.

Click Install

It might take a little time to finish the installation.

Let it finish...

Click on Finish.

Click Finish

Congrats - you've successfully installed VS Code/VS Code Insiders on your system. Now, cheers! 🥂

How to Prepare VS Code/VS Code Insiders For C and C++ Code

First, open VS Code or VS Code Insiders.

Go to the Extension tab. Search for "C" or "C++" and install the first one that is already verified by Microsoft itself.

Install C/C++ extension

Also, install C/C++ Extension Pack. It should also be verified by Microsoft.

Install C/C++ Extension Pack

Then you have to search for Code Runner and install the extension as well.

Install Code Runner Extension

Now, we need to change some settings.

Change some settings

Click the gear box (It is called the Manage section), and then click Settings. Alternatively, you can also use the shortcut keys Ctrl + ,. You need to replace the Ctrl key with the Command key for Mac.

Type "Run code in terminal" and press Enter key

In the search bar, type "Run code in terminal" and press the Enter key.

Scroll down a little bit until you find Code-runner: Run In Terminal. Make sure that the box is checked (✔).

Make sure to check the box

Now you need to restart your VS Code/VS Code Insiders. Simply close and reopen the program.

How to Test Your Code

Simply open VS Code/VS Code Insiders, open any folder, and create any file with the extension .c for the C file and .cpp for the C++ file.

After writing your code, you can run the code directly using the play button you'll find in the upper right corner.

This is how you can run any C/C++ program from VS Code/Insiders

It will compile and then run the code directly. After running a code, the code runner button would be set default to run directly. So, your computer is 100% ready for compiling and running any C/C++ programming code. 😀

Conclusion

Thanks for reading the entire article. If it helps you then you can also check out other articles of mine at freeCodeCamp.

If you want to get in touch with me, then you can do so using Twitter, LinkedIn, and GitHub.

You can also SUBSCRIBE to my YouTube channel (Code With FahimFBA) if you want to learn various kinds of programming languages with a lot of practical examples regularly.

If you want to check out my highlights, then you can do so at my Polywork timeline.

You can also visit my website to learn more about me and what I'm working on.

Thanks a bunch!

For example, when you want to loop through all the elements stored in the array to determine whether a specific value is present.

In this article, you will learn how to find the size of an array using the sizeof() operator.

Let's dive in!

What is An Array in the C Programming Language?

Arrays let you store multiple values under the same variable name.

An array in the C programming language is a collection of items of the same data type. This means you can create an array of only integer values or an array of chars and so on.

To create an array in C, you first need to specify the data type of the values the array will store.

Then, you give the array a name followed by a pair of square brackets, [].

Inside the square brackets, you can specify the size of the array.

So, here is how you would create an array of type int called faveNumbers that will hold 5 integers:

int faveNumbers[5];

To insert values inside the array during its declaration, use the assignment operator, =, and a pair of curly braces, {}.

Inside the curly braces, enter the items and separate each one with a comma:

int faveNumbers[5] = {7, 33, 13, 9, 29};

The code above creates an array with the name faveNumbers that holds 5 integers, 7, 33, 13, 9, 29.

You could also write the code above as follows:

int faveNumbers[] = {7, 33, 13, 9, 29};

In the example above, I didn't specify the size of the array.

However, the compiler can tell that the size is 5 since I initialized it with 5 elements.

Something to note here is that you cannot change the size and type of the array once you declare it since they have a fixed length.

How to Find the Size of An Array in the C Programming Language

C does not provide a built-in way to get the size of an array.

With that said, it does have the built-in sizeof operator, which you can use to determine the size.

The general syntax for using the sizeof operator is the following:

datatype size = sizeof(array_name) / sizeof(array_name[index]);

Let's break it down:

• size is the variable name that stores the size of the array, and datatype specifies the type of data value stored in size.
• sizeof(array_name) calculates the size of the array in bytes.
• sizeof(array_name[index]) calculates the size of one element in the array.

Now, let's see this operation in action and break it down into individual steps to see how it works.

Firstly, the sizeof operator returns the total amount of memory allocated to the array in bytes.

#include <stdio.h>
int main() {
    // my array
    int faveNumbers[] = {7, 33, 13, 9, 29};

    // using sizeof to get the size of the array in bytes
    size_t size = sizeof(faveNumbers);

    printf("The size is %d bytes \n", size);
}

// output

// The size is 20 bytes

However, the code above doesn't calculate the size of the array directly.

You will need some extra programming logic, which will look something like this:

array_length = (total size of the array) / (size of the first element in the array)

To find the length of the array, you need to divide the total amount of memory by the size of one element - this method works because the array stores items of the same type.

So, you can divide the total number of bytes by the size of the first element in the array.

To access the first element in an array, specify the name and, in square brackets, include 0.

In programming and Computer Science in general, indexing always starts at 0, so the first element in an array will always have an index of 0.

#include <stdio.h>
int main() {
    int faveNumbers[] = {7, 33, 13, 9, 29};

    size_t size = sizeof(faveNumbers) / sizeof(faveNumbers[0]);

    printf("The length of the array is %d \n", size);
}

// output

// The length of the array is 5

Something to note here is the size of data types will vary from platform to platform.

Conclusion

Hopefully, this article helped you understand how to find the size of an array in the C programming language using the built-in sizeof operator.

Thank you for reading, and happy coding!

We just published a C programming course on the freeCodeCamp.org YouTube channel. In the course, Dr. Charles Severance will help you learn C programming by taking you through the classic 1978 C programming book written by Ritchie and Kernighan. Dr. Charles Severance (aka Dr. Chuck) is a professor at the University of Michigan and a very popular software instructor.

The course will help you understanding computer architecture and low-level programming.

The classic Kernighan and Ritchie book places the reader in the middle of the 1970's transition from a hardware-centered computer science to a focus on writing portable and efficient software. C was used to develop operating systems like Unix, Minix, and Linux and progamming languages like C++, Java, JavaScript, and Python.

In this course we will be reflecting on how C provided an important foundation for the creation of modern programming languages. This is not a good place to start if you do not already have some programming experience. A suggested pre-requisite is Dr. Chuck's Python for Everybody course.

Dr. Chuck also created a website to go along with this course that has many supplementary resources. You can access the site here.

Here are the chapters in the book which this course follows:

• Chapter 0: Introduction
• Chapter 1: A Tutorial Introduction
• Chapter 2: Types, Operators, and Expressions
• Chapter 3: Control Flow
• Chapter 4: Functions and Program Structure
• Chapter 5: Pointers and Arrays
• Chapter 6: Structures
• Chapter 7: Input and Output
• Chapter 8: The UNIX System Interface

Watch the full course below or on the freeCodeCamp.org YouTube channel (10-hour watch).