1.

// Header file for input output functions

#include <stdio.h>

// Main function: entry point for execution

int main() {

// Writing print statement to print hello world

printf("Hello World");

return 0;

Output

Hello World

Explanation:

 #include <stdio.h> – This line includes the standard input-output library in

the program.

 int main() – The main function where the execution of the program begins.

 printf(“Hello, World!\n”); – This function call prints “Hello, World!” followed

by a new line.

 return 0; -This statement indicates that the program ended successfully.

Examples

Input: name = "Rahul"

Output: Rahul
Explanation: The program prints "Rahul" to the screen.

Input: name = "Vikas"

Output: Vikas
Explanation: The program prints "Vikas" to the screen.

Print Your Own Name Using printf()

The simplest way to print something is to use the printf() function. You can provide
your name in the form of string to printf() function and it will print it on the output
screen.

Syntax of printf

printf("your_name_here")

Program to Print Your Own Name Using printf

// C Program to Print Your Own Name using printf

#include <stdio.h>

int main() {

// Printing your name "Rahul" on the output screen

printf("Rahul");

return 0;

Output

Rahul

Program to Print Your Own Name by Taking it as Input

// C Program to Print Your Own Name using scanf and printf

#include <stdio.h>

int main() {

// Defining string (character array) assuming 100

// characters at max

char name[100];

// Taking input from the user

printf("Enter Your Name: ");

scanf("%s", name);+

// Printing your name to the screen

printf("Your Name: %s\n", name);

return 0;
}

Output

Enter Your Name: Rahul

Your Name: Rahul

Using puts()

The puts() function is another function that is used to print the given string to the
output screen. It is also defined inside the <stdio.h> header file.

Syntax of puts()

puts("name");

Program to Print Your Own Name Using puts()

// C Program to Print Your Own Name using puts

#include <stdio.h>

int main() {

// Print the name "Vikas" on the output screen

puts("Vikas");

return 0;

10

}
Output

Vikas

Using fputs()

The fputs() function is used for file output. We can redirect this function to standard
output buffer "stdout" to print your name on the console screen.

Syntax

fputs("name", stdout);

Program to Print Your Own Name Using fputs()

// C Program to Print Your Own Name using fputs

#include <stdio.h>

int main() {

// Print the name "Robert" on the screen

fputs("Robert", stdout);

return 0;

10

Output

Robert
Using fprintf()

The fprintf() function is used also for file output. It is similar to the printf function,
but we need to specify the output buffer in the function which in this case is stdout.

Syntax

fprintf("name", stdout);

Program to Print Your Own Name Using fprintf()

// C Program to Print Your Own Name using fprintf

#include <stdio.h>

int main() {

// Print the name "Robert" on the screen

fputs("Robert", stdout);

return 0;

Output

Robert
C Variables

Variables are containers for storing data values, like numbers and characters.

In C, there are different types of variables (defined with different keywords), for
example:

 int - stores integers (whole numbers), without decimals, such as 123 or -123

 float - stores floating point numbers, with decimals, such as 19.99 or -19.99

 char - stores single characters, such as 'a' or 'B'. Characters are surrounded
by single quotes

Declaring (Creating) Variables

To create a variable, specify the type and assign it a value:

Syntax

type variable Name = value;

Where type is one of C types (such as int), and variable Name is the name of the
variable (such as x or myName). The equal sign is used to assign a value to the
variable.

So, to create a variable that should store a number, look at the following example:

Example

Create a variable called myNum of type int and assign the value 15 to it:

int myNum = 15;

You can also declare a variable without assigning the value, and assign the value
later:

Example

// Declare a variable
int myNum;

// Assign a value to the variable

myNum = 15;

Output Variables
Example

printf("Hello World!");

In many other programming languages (like Python, Java, and C++), you would
normally use a print function to display the value of a variable. However, this is not
possible in C:

Example

int myNum = 15;

printf(myNum); // Nothing happens

To output variables in C, you must get familiar with something called "format
specifiers",

C Format Specifiers

Format Specifiers

Format specifiers are used together with the printf() function to tell the compiler
what type of data the variable is storing. It is basically a placeholder for the variable
value.

A format specifier starts with a percentage sign %, followed by a character.

For example, to output the value of an int variable, use the format
specifier %d surrounded by double quotes (""), inside the printf() function:

Example

int myNum = 15;

printf("%d", myNum); // Outputs 15

To print other types, use %c for char and %f for float:

Example

// Create variables
int myNum = 15; // Integer (whole number)
float myFloatNum = 5.99; // Floating point number
char myLetter = 'D'; // Character

// Print variables
printf("%d\n", myNum);
printf("%f\n", myFloatNum);
printf("%c\n", myLetter);

To combine both text and a variable, separate them with a comma inside
the printf() function:

Example
int myNum = 15;
printf("My favorite number is: %d", myNum);

To print different types in a single printf() function, you can use the following:

Example

int myNum = 15;

char myLetter = 'D';
printf("My number is %d and my letter is %c", myNum, myLetter);

Print Values Without Variables

You can also just print a value without storing it in a variable, as long as you use the
correct format specifier:

Example

printf("My favorite number is: %d", 15);

printf("My favorite letter is: %c", 'D');

However, it is more sustainable to use variables as they are saved for later and can
be re-used whenever.

C Variable Values

Change Variable Values

If you assign a new value to an existing variable, it will overwrite the previous value:

Example

int myNum = 15; // myNum is 15

myNum = 10; // Now myNum is 10

You can also assign the value of one variable to another:

Example

int myNum = 15;

int myOtherNum = 23;

// Assign the value of myOtherNum (23) to myNum

myNum = myOtherNum;

// myNum is now 23, instead of 15

printf("%d", myNum);

Or copy values to empty variables:

Example

// Create a variable and assign the value 15 to it

int myNum = 15;

// Declare a variable without assigning it a value

int myOtherNum;

// Assign the value of myNum to myOtherNum

myOtherNum = myNum;

// myOtherNum now has 15 as a value

printf("%d", myOtherNum);

Add Variables Together

To add a variable to another variable, you can use the + operator:

Example

int x = 5;
int y = 6;
int sum = x + y;
printf("%d", sum);

C Declare Multiple Variables

Declare Multiple Variables

To declare more than one variable of the same type, use a comma-separated list:

Example

int x = 5, y = 6, z = 50;
printf("%d", x + y + z);

You can also assign the same value to multiple variables of the same type:

Example

int x, y, z;
x = y = z = 50;
printf("%d", x + y + z);

C Variable Names (Identifiers)

C Variable Names
All C variables must be identified with unique names.

These unique names are called identifiers.

Identifiers can be short names (like x and y) or more descriptive names (age, sum,
totalVolume).

Note: It is recommended to use descriptive names in order to create understandable

and maintainable code:

Example

// Good variable name

int minutesPerHour = 60;

// OK, but not so easy to understand what m actually is

int m = 60;

The general rules for naming variables are:

 Names can contain letters, digits and underscores

 Names must begin with a letter or an underscore (_)

 Names are case-sensitive (myVar and myvar are different variables)

 Names cannot contain whitespaces or special characters like !, #, %, etc.

 Reserved words (such as int) cannot be used as names

C Variables - Examples

Real-Life Example

Often in our examples, we simplify variable names to match their data type (myInt
or myNum for int types, myChar for char types, and so on). This is done to avoid
confusion.

However, for a practical example of using variables, we have created a program that
stores different data about a college student:

Example

// Student data
int studentID = 15;
int studentAge = 23;
float studentFee = 75.25;
char studentGrade = 'B';

// Print variables
printf("Student id: %d\n", studentID);
printf("Student age: %d\n", studentAge);
printf("Student fee: %f\n", studentFee);
printf("Student grade: %c", studentGrade);

Calculate the Area of a Rectangle

In this real-life example, we create a program to calculate the area of a rectangle (by
multiplying the length and width):

Example

// Create integer variables

int length = 4;
int width = 6;
int area;

// Calculate the area of a rectangle

area = length * width;

// Print the variables

printf("Length is: %d\n", length);
printf("Width is: %d\n", width);
printf("Area of the rectangle is: %d", area);

Data Types

As explained in the Variables chapter, a variable in C must be a specified data type,

and you must use a format specifier inside the printf() function to display it:

Example

// Create variables
int myNum = 5; // Integer (whole number)
float myFloatNum = 5.99; // Floating point number
char myLetter = 'D'; // Character

// Print variables
printf("%d\n", myNum);
printf("%f\n", myFloatNum);
printf("%c\n", myLetter);

Basic Data Types

The data type specifies the size and type of information the variable will store.

In this tutorial, we will focus on the most basic ones:

Data Type Size Description

int 2 or 4 bytes Stores whole numbers, without decimals

float 4 bytes Stores fractional numbers, containing one or more decimals. Suffici
digits

double 8 bytes Stores fractional numbers, containing one or more decimals. Suffici

char 1 byte Stores a single character/letter/number, or ASCII values

Basic Format Specifiers

There are different format specifiers for each data type. Here are some of them:

Format Specifier Data Type

%d or %i int

%f or %F float

%lf double

%c char

%s Used for strings (text), which you will learn more about in a later c

Note: It is important that you use the correct format specifier for the specified data
type. If not, the program may produce errors or even crash.

C Character Data Types

The char Type

The char data type is used to store a single character.

The character must be surrounded by single quotes, like 'A' or 'c', and we use
the %c format specifier to print it:

Example
char myGrade = 'A';
printf("%c", myGrade);

Alternatively, if you are familiar with ASCII, you can use ASCII values to display
certain characters. Note that these values are not surrounded by quotes (''), as they
are numbers:

Example

char a = 65, b = 66, c = 67;

printf("%c", a);
printf("%c", b);
printf("%c", c);

Tip: A list of all ASCII values can be found in our ASCII Table Reference.

Notes on Characters

If you try to store more than a single character, it will only print the last character:

Example

char myText = 'Hello';

printf("%c", myText);

Note: Don't use the char type for storing multiple characters, as it may produce
errors.

To store multiple characters (or whole words), use strings (which you will learn more
about in a later chapter):

Example

char myText[] = "Hello";

printf("%s", myText);

C Numeric Data Types

Numeric Types

Use int when you need to store a whole number without decimals, like 35 or 1000,
and float or double when you need a floating point number (with decimals), like
9.99 or 3.14515.

int

int myNum = 1000;

printf("%d", myNum);

float
float myNum = 5.75;
printf("%f", myNum);

double

double myNum = 19.99;

printf("%lf", myNum);

float vs. double

The precision of a floating point value indicates how many digits the value can have
after the decimal point. The precision of float is six or seven decimal digits,
while double variables have a precision of about 15 digits. Therefore, it is often safer
to use double for most calculations - but note that it takes up twice as
much memory as float (8 bytes vs. 4 bytes).

Scientific Numbers

A floating point number can also be a scientific number with an "e" to indicate the
power of 10:

Example

float f1 = 35e3;
double d1 = 12E4;

printf("%f\n", f1);
printf("%lf", d1);

C Decimal Precision

Set Decimal Precision

You have probably already noticed that if you print a floating point number, the
output will show many digits after the decimal point:

Example

float myFloatNum = 3.5;

double myDoubleNum = 19.99;

printf("%f\n", myFloatNum); // Outputs 3.500000

printf("%lf", myDoubleNum); // Outputs 19.990000

If you want to remove the extra zeros (set decimal precision), you can use a dot (.)
followed by a number that specifies how many digits that should be shown after the
decimal point:

Example
float myFloatNum = 3.5;

printf("%f\n", myFloatNum); // Default will show 6 digits after the decimal point
printf("%.1f\n", myFloatNum); // Only show 1 digit
printf("%.2f\n", myFloatNum); // Only show 2 digits
printf("%.4f", myFloatNum); // Only show 4 digits

Try it Yourself »

C The size of Operator

Get the Memory Size

We introduced in the data types chapter that the memory size of a variable varies
depending on the type:

Data Type Size

int 2 or 4 bytes

float 4 bytes

double 8 bytes

char 1 byte

The memory size refers to how much space a type occupies in the computer's
memory.

To actually get the size (in bytes) of a data type or variable, use the sizeof operator:

Example

int myInt;
float myFloat;
double myDouble;
char myChar;

printf("%lu\n", sizeof(myInt));
printf("%lu\n", sizeof(myFloat));
printf("%lu\n", sizeof(myDouble));
printf("%lu\n", sizeof(myChar));

Note that we use the %lu format specifer to print the result, instead of %d. It is
because the compiler expects the sizeof operator to return a long unsigned int (%lu),
instead of int (%d). On some computers it might work with %d, but it is safer to
use %lu.

Why Should I Know the Size of Data Types?

Knowing the size of different data types is important because it says something
about memory usage and performance.

For example, the size of a char type is 1 byte. Which means if you have an array of
1000 char values, it will occupy 1000 bytes (1 KB) of memory.

Using the right data type for the right purpose will save memory and improve the
performance of your program.

Real-Life Example

Here's a real-life example of using different data types, to calculate and output the
total cost of a number of items:

Example

// Create variables of different data types

int items = 50;
float cost_per_item = 9.99;
float total_cost = items * cost_per_item;
char currency = '$';

// Print variables
printf("Number of items: %d\n", items);
printf("Cost per item: %.2f %c\n", cost_per_item, currency);
printf("Total cost = %.2f %c\n", total_cost, currency);

C Type Conversion

Type Conversion

Sometimes, you have to convert the value of one data type to another type. This is
known as type conversion.

For example, if you try to divide two integers, 5 by 2, you would expect the result to
be 2.5. But since we are working with integers (and not floating-point values), the
following example will just output 2:

Example

int x = 5;
int y = 2;
int sum = 5 / 2;

printf("%d", sum); // Outputs 2

To get the right result, you need to know how type conversion works.

There are two types of conversion in C:

 Implicit Conversion (automatically)

  Explicit Conversion (manually)

Implicit Conversion

Implicit conversion is done automatically by the compiler when you assign a value of
one type to another.

For example, if you assign an int value to a float type:

Example

// Automatic conversion: int to float

float myFloat = 9;

printf("%f", myFloat); // 9.000000

As you can see, the compiler automatically converts the int value 9 to a float value
of 9.000000.

This can be risky, as you might lose control over specific values in certain situations.

Especially if it was the other way around - the following example automatically
converts the float value 9.99 to an int value of 9:

Example

// Automatic conversion: float to int

int myInt = 9.99;

printf("%d", myInt); // 9

What happened to .99? We might want that data in our program! So be careful. It is
important that you know how the compiler work in these situations, to avoid
unexpected results.

As another example, if you divide two integers: 5 by 2, you know that the sum is 2.5.
And as you know from the beginning of this page, if you store the sum as an integer,
the result will only display the number 2. Therefore, it would be better to store the
sum as a float or a double, right?

Example

float sum = 5 / 2;

printf("%f", sum); // 2.000000

Why is the result 2.00000 and not 2.5? Well, it is because 5 and 2 are still integers in
the division. In this case, you need to manually convert the integer values to
floating-point values. (see below).
Explicit Conversion

Explicit conversion is done manually by placing the type in parentheses () in front of

the value.

Considering our problem from the example above, we can now get the right result:

Example

// Manual conversion: int to float

float sum = (float) W 5 / 2;

printf("%f", sum); // 2.500000

You can also place the type in front of a variable:

Example

int num1 = 5;
int num2 = 2;
float sum = (float) num1 / num2;

printf("%f", sum); // 2.500000

And since you learned about "decimal precision" in the previous chapter, you could
make the output even cleaner by removing the extra zeros (if you like):

Example

int num1 = 5;
int num2 = 2;
float sum = (float) num1 / num2;

printf("%.1f", sum); // 2.5

Real-Life Example

Here's a real-life example of data types and type conversion where we create a
program to calculate the percentage of a user's score in relation to the maximum
score in a game:

Example

// Set the maximum possible score in the game to 500

int maxScore = 500;

// The actual score of the user

int userScore = 423;

/* Calculate the percantage of the user's score in relation to the maximum available
score.
Convert userScore to float to make sure that the division is accurate */
float percentage = (float) userScore / maxScore * 100.0;

// Print the percentage

printf("User's percentage is %.2f", percentage);

C Constants

Constants

If you don't want others (or yourself) to change existing variable values, you can use
the const keyword.

This will declare the variable as "constant", which means unchangeable and read-
only:

Example

const int myNum = 15; // myNum will always be 15

myNum = 10; // error: assignment of read-only variable 'myNum'

You should always declare the variable as constant when you have values that are
unlikely to change:

Example

const int minutesPerHour = 60;

Notes On Constants

When you declare a constant variable, it must be assigned with a value:

Example

Like this:

const int minutesPerHour = 60;

This however, will not work:

const int minutesPerHour;

minutesPerHour = 60; // error

Good Practice
Another thing about constant variables, is that it is considered good practice to
declare them with uppercase.

It is not required, but useful for code readability and common for C programmers:

Example

const int BIRTHYEAR = 1980;

C Operators

Operators

Operators are used to perform operations on variables and values.

In the example below, we use the + operator to add together two values:

Example

int myNum = 100 + 50;

Although the + operator is often used to add together two values, like in the
example above, it can also be used to add together a variable and a value, or a
variable and another variable:

Example

int sum1 = 100 + 50; // 150 (100 + 50)

int sum2 = sum1 + 250; // 400 (150 + 250)
int sum3 = sum2 + sum2; // 800 (400 + 400)

C divides the operators into the following groups:

 Arithmetic operators

 Assignment operators

 Comparison operators

 Logical operators

 Bitwise operators

Arithmetic Operators

Arithmetic operators are used to perform common mathematical operations.

Operator Name Description

 + Addition Adds together two values

- Subtraction Subtracts one value from another

* Multiplication Multiplies two values

/ Division Divides one value by another

% Modulus Returns the division remainder

++ Increment Increases the value of a variable by 1

-- Decrement Decreases the value of a variable by 1

Assignment Operators

Assignment operators are used to assign values to variables.

In the example below, we use the assignment operator (=) to assign the value 10 to
a variable called x:

Example

int x = 10;

The addition assignment operator (+=) adds a value to a variable:

Example

int x = 10;
x += 5;

A list of all assignment operators:

Operator Example Same As

= x=5 x=5

+= x += 3 x=x+3

-= x -= 3 x=x-3

*= x *= 3 x=x*3

/= x /= 3 x=x/3
 %= x %= 3 x=x%3

&= x &= 3 x=x&3

|= x |= 3 x=x|3

^= x ^= 3 x=x^3

>>= x >>= 3 x = x >> 3

<<= x <<= 3 x = x << 3

Comparison Operators

Comparison operators are used to compare two values (or variables). This is
important in programming, because it helps us to find answers and make decisions.

The return value of a comparison is either 1 or 0, which means true (1) or false (0).
These values are known as Boolean values, and you will learn more about them in
the Booleans and If..Else chapter.

In the following example, we use the greater than operator (>) to find out if 5 is
greater than 3:

Example

Operator Name Example Description

== Equal to x == y Returns 1 if the values are equal

!= Not equal x != y Returns 1 if the values are not equal

> Greater than x>y Returns 1 if the first value is greater tha

< Less than x<y Returns 1 if the first value is less than t

>= Greater than or equal to x >= y Returns 1 if the first value is greater tha
value
 <= Less than or equal to x <= y Returns 1 if the first value is less than,

int x = 5;
int y = 3;
printf("%d", x > y); // returns 1 (true) because 5 is greater than 3

Try it Yourself »

A list of all comparison operators:

Logical Operators

You can also test for true or false values with logical operators.

Logical operators are used to determine the logic between variables or values, by
combining multiple conditions:

Operator Name Example Description

&& AND x < 5 && x < 10 Returns 1 if both statements are true

|| OR x < 5 || x < 4 Returns 1 if one of the statements is true

! NOT !(x < 5 && x < 10) Reverse the result, returns 0 if the result is 1

Exercise?

What will the following code output?

C Booleans
Booleans

Very often, in programming, you will need a data type that can only have one of two
values, like:

 YES / NO

 ON / OFF

 TRUE / FALSE

For this, C has a bool data type, which is known as booleans.

Booleans represent values that are either true or false.

Boolean Variables

In C, the bool type is not a built-in data type, like int or char.

It was introduced in C99, and you must import the following header file to use it:

#include <stdbool.h>

A boolean variable is declared with the bool keyword and can take the
values true or false:

bool isProgrammingFun = true;

bool isFishTasty = false;

Before trying to print the boolean variables, you should know that boolean values
are returned as integers:

 1 (or any other number that is not 0) represents true

 0 represents false

Therefore, you must use the %d format specifier to print a boolean value:

Example

// Create boolean variables

bool isProgrammingFun = true;
bool isFishTasty = false;

// Return boolean values

printf("%d", isProgrammingFun); // Returns 1 (true)
printf("%d", isFishTasty); // Returns 0 (false)

However, it is more common to return a boolean value by comparing values and

variables.
Comparing Values and Variables

Comparing values are useful in programming, because it helps us to find answers

and make decisions.

For example, you can use a comparison operator, such as the greater than (>)
operator, to compare two values:

Example

printf("%d", 10 > 9); // Returns 1 (true) because 10 is greater than 9

From the example above, you can see that the return value is a boolean value (1).

You can also compare two variables:

Example

int x = 10;
int y = 9;
printf("%d", x > y);

In the example below, we use the equal to (==) operator to compare different
values:

Example

printf("%d", 10 == 10); // Returns 1 (true), because 10 is equal to 10

printf("%d", 10 == 15); // Returns 0 (false), because 10 is not equal to 15
printf("%d", 5 == 55); // Returns 0 (false) because 5 is not equal to 55

You are not limited to only compare numbers. You can also compare boolean
variables, or even special structures, like arrays (which you will learn more about in a
later chapter):

Example

bool isHamburgerTasty = true;

bool isPizzaTasty = true;

// Find out if both hamburger and pizza is tasty

printf("%d", isHamburgerTasty == isPizzaTasty);

Remember to include the <stdbool.h> header file when working with bool variables.

C Boolean Examples

Real Life Example

Let's think of a "real life example" where we need to find out if a person is old
enough to vote.
In the example below, we use the >= comparison operator to find out if the age (25)
is greater than OR equal to the voting age limit, which is set to 18:

Example

int myAge = 25;

int votingAge = 18;

printf("%d", myAge >= votingAge); // Returns 1 (true), meaning 25 year olds are
allowed to vote!

Try it Yourself »

Cool, right? An even better approach (since we are on a roll now), would be to wrap
the code above in an if...else statement, so we can perform different actions
depending on the result:

Example

Output "Old enough to vote!" if myAge is greater than or equal to 18. Otherwise
output "Not old enough to vote.":

int myAge = 25;

int votingAge = 18;

if (myAge >= votingAge) {

printf("Old enough to vote!");
} else {
printf("Not old enough to vote.");
}

Booleans are the basis for all comparisons and conditions.

You will learn more about conditions (if...else) in the next chapter.

C If ... Else

Conditions and If Statements

You have already learned that C supports the usual logical conditions from
mathematics:

 Less than: a < b

 Less than or equal to: a <= b

 Greater than: a > b

 Greater than or equal to: a >= b

 Equal to a == b
  Not Equal to: a != b

You can use these conditions to perform different actions for different decisions.

C has the following conditional statements:

 Use if to specify a block of code to be executed, if a specified condition

is true

 Use else to specify a block of code to be executed, if the same condition

is false

 Use else if to specify a new condition to test, if the first condition is false

 Use switch to specify many alternative blocks of code to be executed

The if Statement

Use the if statement to specify a block of code to be executed if a condition is true.

Syntax

if (condition) {
// block of code to be executed if the condition is true
}

Note that if is in lowercase letters. Uppercase letters (If or IF) will generate an error.

In the example below, we test two values to find out if 20 is greater than 18. If the
condition is true, print some text:

Example

if (20 > 18) {

printf("20 is greater than 18");
}

We can also test variables:

Example

int x = 20;
int y = 18;
if (x > y) {
printf("x is greater than y");
}

Example explained

In the example above we use two variables, x and y, to test whether x is greater than
y (using the > operator). As x is 20, and y is 18, and we know that 20 is greater than
18, we print to the screen that "x is greater than y".
C Else

The else Statement

Use the else statement to specify a block of code to be executed if the condition
is false.

Syntax

if (condition) {
// block of code to be executed if the condition is true
} else {
// block of code to be executed if the condition is false
}

Example

int time = 20;

if (time < 18) {
printf("Good day.");
} else {
printf("Good evening.");
}
// Outputs "Good evening."

Example explained

In the example above, time (20) is greater than 18, so the condition is false. Because
of this, we move on to the else condition and print to the screen "Good evening". If
the time was less than 18, the program would print "Good day".

C Else If

The else if Statement

Use the else if statement to specify a new condition if the first condition is false.

Syntax

if (condition1) {
// block of code to be executed if condition1 is true
} else if (condition2) {
// block of code to be executed if the condition1 is false and condition2 is true
} else {
// block of code to be executed if the condition1 is false and condition2 is false
}
Example

int time = 22;

if (time < 10) {
printf("Good morning.");
} else if (time < 20) {
printf("Good day.");
} else {
printf("Good evening.");
}
// Outputs "Good evening."

Example explained

In the example above, time (22) is greater than 10, so the first condition is false. The
next condition, in the else if statement, is also false, so we move on to
the else condition since condition1 and condition2 is both false - and print to the
screen "Good evening".

However, if the time was 14, our program would print "Good day."

C If ... Else Examples

Real-Life Examples

This example shows how you can use if..else to "open a door" if the user enters the
correct code:

Example

int doorCode = 1337;

if (doorCode == 1337) {
printf("Correct code.\nThe door is now open.");
} else {
printf("Wrong code.\nThe door remains closed.");
}

Try it Yourself »

This example shows how you can use if..else to find out if a number is positive or
negative:

Example

int myNum = 10; // Is this a positive or negative number?

if (myNum > 0) {
printf("The value is a positive number.");
} else if (myNum < 0) {
printf("The value is a negative number.");
} else {
 printf("The value is 0.");
}

Find out if a person is old enough to vote:

Example

int myAge = 25;

int votingAge = 18;

if (myAge >= votingAge) {

printf("Old enough to vote!");
} else {
printf("Not old enough to vote.");
}

Find out if a number is even or odd:

Example

int myNum = 5;

if (myNum % 2 == 0) {
printf("%d is even.\n", myNum);
} else {
printf("%d is odd.\n", myNum);
}

C Switch

Switch Statement

Instead of writing many if..else statements, you can use the switch statement.

The switch statement selects one of many code blocks to be executed:

Syntax

switch (expression) {
case x:
// code block
break;
case y:
// code block
break;
default:
// code block
}

This is how it works:

 The switch expression is evaluated once

  The value of the expression is compared with the values of each case

 If there is a match, the associated block of code is executed

 The break statement breaks out of the switch block and stops the execution

 The default statement is optional, and specifies some code to run if there is
no case match

The example below uses the weekday number to calculate the weekday name:

Example

int day = 4;

switch (day) {
case 1:
printf("Monday");
break;
case 2:
printf("Tuesday");
break;
case 3:
printf("Wednesday");
break;
case 4:
printf("Thursday");
break;
case 5:
printf("Friday");
break;
case 6:
printf("Saturday");
break;
case 7:
printf("Sunday");
break;
}

// Outputs "Thursday" (day 4)

The break Keyword

When C reaches a break keyword, it breaks out of the switch block.

This will stop the execution of more code and case testing inside the block.

When a match is found, and the job is done, it's time for a break. There is no need
for more testing.
A break can save a lot of execution time because it "ignores" the execution of all the
rest of the code in the switch block.

The default Keyword

The default keyword specifies some code to run if there is no case match:

Example

int day = 4;

switch (day) {
case 6:
printf("Today is Saturday");
break;
case 7:
printf("Today is Sunday");
break;
default:
printf("Looking forward to the Weekend");
}

// Outputs "Looking forward to the Weekend"

Note: The default keyword must be used as the last statement in the switch, and it
does not need a break.

C While Loop

Loops

Loops can execute a block of code as long as a specified condition is reached.

Loops are handy because they save time, reduce errors, and they make code more
readable.

While Loop

The while loop loops through a block of code as long as a specified condition is true:

Syntax

while (condition) {
// code block to be executed
}
In the example below, the code in the loop will run, over and over again, as long as a
variable (i) is less than 5:

Example

int i = 0;

while (i < 5) {
printf("%d\n", i);
i++;
}

Note: Do not forget to increase the variable used in the condition (i++), otherwise
the loop will never end!

C Do/While Loop

The Do/While Loop

The do/while loop is a variant of the while loop. This loop will execute the code
block once, before checking if the condition is true, then it will repeat the loop as
long as the condition is true.

Syntax

do {
// code block to be executed
}
while (condition);

The example below uses a do/while loop. The loop will always be executed at least
once, even if the condition is false, because the code block is executed before the
condition is tested:

Example

int i = 0;

do {
printf("%d\n", i);
i++;
}
while (i < 5);

Do not forget to increase the variable used in the condition, otherwise the loop will
never end!
C While Loop Examples

Real-Life Examples

To demonstrate a practical example of the while loop, we have created a simple

"countdown" program:

Example

int countdown = 3;

while (countdown > 0) {

printf("%d\n", countdown);
countdown--;
}

printf("Happy New Year!!\n");

In this example, we create a program that only print even numbers between 0 and
10 (inclusive):

Example

int i = 0;

while (i <= 10) {

printf("%d\n", i);
i += 2;
}

In this example we use a while loop to reverse some numbers:

Example

// A variable with some specific numbers

int numbers = 12345;

// A variable to store the reversed number

int revNumbers = 0;

// Reverse and reorder the numbers

while (numbers) {
// Get the last number of 'numbers' and add it to 'revNumber'
 revNumbers = revNumbers * 10 + numbers % 10;
// Remove the last number of 'numbers'
numbers /= 10;
}

To demonstrate a practical example of the while loop combined with an if else

statement, let's say we play a game of Yatzy:

Example

Print "Yatzy!" If the dice number is 6:

int dice = 1;

while (dice <= 6) {

if (dice < 6) {
printf("No Yatzy\n");
} else {
printf("Yatzy!\n");
}
dice = dice + 1;
}

If the loop passes the values ranging from 1 to 5, it prints "No Yatzy". Whenever it
passes the value 6, it prints "Yatzy!".

C For Loop

For Loop

When you know exactly how many times you want to loop through a block of code,
use the for loop instead of a while loop:

Syntax

for (expression 1; expression 2; expression 3) {

// code block to be executed
}

Expression 1 is executed (one time) before the execution of the code block.

Expression 2 defines the condition for executing the code block.

Expression 3 is executed (every time) after the code block has been executed.

The example below will print the numbers 0 to 4:

Example
int i;

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

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

Example explained

Expression 1 sets a variable before the loop starts (int i = 0).

Expression 2 defines the condition for the loop to run (i must be less than 5). If the
condition is true, the loop will start over again, if it is false, the loop will end.

Expression 3 increases a value (i++) each time the code block in the loop has been
executed.

C Nested Loops

Nested Loops

It is also possible to place a loop inside another loop. This is called a nested loop.

The "inner loop" will be executed one time for each iteration of the "outer loop":

Example

int i, j;

// Outer loop
for (i = 1; i <= 2; ++i) {
printf("Outer: %d\n", i); // Executes 2 times

// Inner loop
for (j = 1; j <= 3; ++j) {
printf(" Inner: %d\n", j); // Executes 6 times (2 * 3)
}
}

C For Loop Examples

Real-Life Examples

To demonstrate a practical example of the for loop, let's create a program that
counts to 100 by tens:

Example
for (i = 0; i <= 100; i += 10) {
printf("%d\n", i);
}

In this example, we create a program that only print even numbers between 0 and
10 (inclusive):

Example

for (i = 0; i <= 10; i = i + 2) {

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

Here we only print odd numbers:

Example

for (i = 1; i < 10; i = i + 2) {

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

In this example we print the powers of 2 up to 512:

Example

for (i = 2; i <= 512; i *= 2) {

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

And in this example, we create a program that prints the multiplication table for a
specified number:

Example

int number = 2;
int i;

// Print the multiplication table for the number 2

for (i = 1; i <= 10; i++) {
printf("%d x %d = %d\n", number, i, number * i);
}

return 0;

C Break and Continue

Break

You have already seen the break statement used in an earlier chapter of this tutorial.
It was used to "jump out" of a switch statement.
The break statement can also be used to jump out of a loop.

This example jumps out of the for loop when i is equal to 4:

Example

int i;

for (i = 0; i < 10; i++) {

if (i == 4) {
break;
}
printf("%d\n", i);
}

Continue

The continue statement breaks one iteration (in the loop), if a specified condition
occurs, and continues with the next iteration in the loop.

This example skips the value of 4:

Example

int i;

for (i = 0; i < 10; i++) {

if (i == 4) {
continue;
}
printf("%d\n", i);
}

Break and Continue in While Loop

You can also use break and continue in while loops:

Break Example

int i = 0;

while (i < 10) {

if (i == 4) {
break;
}
printf("%d\n", i);
i++;
}

Continue Example

int i = 0;

while (i < 10) {

if (i == 4) {
i++;
continue;
}
printf("%d\n", i);
i++;
}

C Arrays

Arrays

Arrays are used to store multiple values in a single variable, instead of declaring
separate variables for each value.

To create an array, define the data type (like int) and specify the name of the array
followed by square brackets [].

To insert values to it, use a comma-separated list inside curly braces, and make sure
all values are of the same data type:

int myNumbers[] = {25, 50, 75, 100};

We have now created a variable that holds an array of four integers.

Access the Elements of an Array

To access an array element, refer to its index number.

Array indexes start with 0: [0] is the first element. [1] is the second element, etc.

This statement accesses the value of the first element [0] in myNumbers:

Example

int myNumbers[] = {25, 50, 75, 100};

printf("%d", myNumbers[0]);

// Outputs 25
Change an Array Element

To change the value of a specific element, refer to the index number:

Example

myNumbers[0] = 33;

Example

int myNumbers[] = {25, 50, 75, 100};

myNumbers[0] = 33;

printf("%d", myNumbers[0]);

// Now outputs 33 instead of 25

Loop Through an Array

You can loop through the array elements with the for loop.

The following example outputs all elements in the myNumbers array:

Example

int myNumbers[] = {25, 50, 75, 100};

int i;

for (i = 0; i < 4; i++) {

printf("%d\n", myNumbers[i]);
}

Set Array Size

Another common way to create arrays, is to specify the size of the array, and add
elements later:

Example

// Declare an array of four integers:

int myNumbers[4];

// Add elements
myNumbers[0] = 25;
myNumbers[1] = 50;
myNumbers[2] = 75;
myNumbers[3] = 100;

Using this method, you should know the number of array elements in advance, in
order for the program to store enough memory.

You are not able to change the size of the array after creation.

Avoid Mixing Data Types

It is important to note that all elements in an array must be of the same data type.

This means you cannot mix different types of values, like integers and floating point
numbers, in the same array:

Example

int myArray[] = {25, 50, 75, 3.15, 5.99};

In the example above, the values 3.15 and 5.99 will be truncated to 3 and 5. In some
cases it might also result in an error, so it is important to always make sure that the
elements in the array are of the same type.

C Array Size

Get Array Size or Length

To get the size of an array, you can use the sizeof operator:

Example

int myNumbers[] = {10, 25, 50, 75, 100};

printf("%lu", sizeof(myNumbers)); // Prints 20

Why did the result show 20 instead of 5, when the array contains 5 elements?

- It is because the sizeof operator returns the size of a type in bytes.

You learned from the Data Types chapter that an int type is usually 4 bytes, so from
the example above, 4 x 5 (4 bytes x 5 elements) = 20 bytes.

Knowing the memory size of an array is great when you are working with larger
programs that require good memory management.

But when you just want to find out how many elements an array has, you can use
the following formula (which divides the size of the array by the size of the first
element in the array):

Example
int myNumbers[] = {10, 25, 50, 75, 100};
int length = sizeof(myNumbers) / sizeof(myNumbers[0]);

printf("%d", length); // Prints 5

Making Better Loops

In the array loops section in the previous chapter, we wrote the size of the array in
the loop condition (i < 4). This is not ideal, since it will only work for arrays of a
specified size.

However, by using the size of formula from the example above, we can now make
loops that work for arrays of any size, which is more sustainable.

Instead of writing:

Example

int myNumbers[] = {25, 50, 75, 100};

int i;

for (i = 0; i < 4; i++) {

printf("%d\n", myNumbers[i]);
}

It is better to write:

Example

int myNumbers[] = {25, 50, 75, 100};

int length = sizeof(myNumbers) / sizeof(myNumbers[0]);
int i;

for (i = 0; i < length; i++) {

printf("%d\n", myNumbers[i]);
}

C Arrays - Real-Life Examples

Real-Life Example

To demonstrate a practical example of using arrays, let's create a program that

calculates the average of different ages:

Example

// An array storing different ages

int ages[] = {20, 22, 18, 35, 48, 26, 87, 70};
float avg, sum = 0;
int i;

// Get the length of the array

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

// Loop through the elements of the array

for (i = 0; i < length; i++) {
sum += ages[i];
}

// Calculate the average by dividing the sum by the length

avg = sum / length;

// Print the average

printf("The average age is: %.2f", avg);

And in this example, we create a program that finds the lowest age among different
ages:

Example

// An array storing different ages

int ages[] = {20, 22, 18, 35, 48, 26, 87, 70};

int i;

// Get the length of the array

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

// Create a variable and assign the first array element of ages to it

int lowestAge = ages[0];

// Loop through the elements of the ages array to find the lowest age
for (i = 0; i < length; i++) {
if (lowestAge > ages[i]) {
lowestAge = ages[i];
}
}

C Multidimensional Arrays

Multidimensional Arrays
In the previous chapter, you learned about arrays, which is also known as single
dimension arrays. These are great, and something you will use a lot while
programming in C. However, if you want to store data as a tabular form, like a table
with rows and columns, you need to get familiar with multidimensional arrays.

A multidimensional array is basically an array of arrays.

Arrays can have any number of dimensions. In this chapter, we will introduce the
most common; two-dimensional arrays (2D).

Two-Dimensional Arrays

A 2D array is also known as a matrix (a table of rows and columns).

To create a 2D array of integers, take a look at the following example:

int matrix[2][3] = { {1, 4, 2}, {3, 6, 8} };

The first dimension represents the number of rows [2], while the second dimension
represents the number of columns [3]. The values are placed in row-order, and can
be visualized like this:

Access the Elements of a 2D Array

To access an element of a two-dimensional array, you must specify the index

number of both the row and column.

This statement accesses the value of the element in the first row (0) and third
column (2) of the matrix array.

Example

int matrix[2][3] = { {1, 4, 2}, {3, 6, 8} };

printf("%d", matrix[0][2]); // Outputs 2

Remember that: Array indexes start with 0: [0] is the first element. [1] is the second
element, etc.

Change Elements in a 2D Array

To change the value of an element, refer to the index number of the element in each
of the dimensions:
The following example will change the value of the element in the first row
(0) and first column (0):

Example

int matrix[2][3] = { {1, 4, 2}, {3, 6, 8} };

matrix[0][0] = 9;

printf("%d", matrix[0][0]); // Now outputs 9 instead of 1

Loop Through a 2D Array

To loop through a multi-dimensional array, you need one loop for each of the array's
dimensions.

The following example outputs all elements in the matrix array:

Example

int matrix[2][3] = { {1, 4, 2}, {3, 6, 8} };

int i, j;
for (i = 0; i < 2; i++) {
for (j = 0; j < 3; j++) {
printf("%d\n", matrix[i][j]);
}
}

C Strings

Strings

Strings are used for storing text/characters.

For example, "Hello World" is a string of characters.

Unlike many other programming languages, C does not have a String type to easily
create string variables. Instead, you must use the char type and create an array of
characters to make a string in C:

char greetings[] = "Hello World!";

Note that you have to use double quotes ("").

To output the string, you can use the printf() function together with the format
specifier %s to tell C that we are now working with strings:

Example
char greetings[] = "Hello World!";
printf("%s", greetings);

Access Strings

Since strings are actually arrays in C, you can access a string by referring to its index
number inside square brackets [].

This example prints the first character (0) in greetings:

Example

char greetings[] = "Hello World!";

printf("%c", greetings[0]);

Note that we have to use the %c format specifier to print a single character.

Modify Strings

To change the value of a specific character in a string, refer to the index number, and
use single quotes:

Example

char greetings[] = "Hello World!";

greetings[0] = 'J';
printf("%s", greetings);
// Outputs Jello World! instead of Hello World!

Loop Through a String

You can also loop through the characters of a string, using a for loop:

Example

char carName[] = "Volvo";

int i;

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

printf("%c\n", carName[i]);
}

And like we specified in the arrays chapter, you can also use the sizeof
formula (instead of manually write the size of the array in the loop condition (i < 5))
to make the loop more sustainable:

Example
char carName [] = "Volvo";
int length = sizeof(carName) / sizeof (carName [0]);
int i;

for (i = 0; i < length; ++i) {

printf("%c\n", carName[i]);
}

Another Way Of Creating Strings

In the examples above, we used a "string literal" to create a string variable. This is
the easiest way to create a string in C.

You should also note that you can create a string with a set of characters. This
example will produce the same result as the example in the beginning of this page:

Example

char greetings[] = {'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '!', '\0'};
printf("%s", greetings);

Why do we include the \0 character at the end? This is known as the "null
terminating character", and must be included when creating strings using this
method. It tells C that this is the end of the string.

Differences

The difference between the two ways of creating strings, is that the first method is
easier to write, and you do not have to include the \0 character, as C will do it for
you.

You should note that the size of both arrays is the same: They both have 13
characters (space also counts as a character by the way), including the \0 character:

Example

char greetings[] = {'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '!', '\0'};
char greetings2[] = "Hello World!";

printf("%lu\n", sizeof(greetings)); // Outputs 13

printf("%lu\n", sizeof(greetings2)); // Outputs 13

Real-Life Example

Use strings to create a simple welcome message:

Example

char message[] = "Good to see you,";

char fname[] = "John";

printf("%s %s!", message, fname);

C Special Characters

Strings - Special Characters

Because strings must be written within quotes, C will misunderstand this string, and
generate an error:

char txt[] = "We are the so-called "Vikings" from the north.";

The solution to avoid this problem, is to use the backslash escape character.

The backslash (\) escape character turns special characters into string characters:

Escape character Result Description

\' ' Single quote

\" " Double quote

\\ \ Backslash

The sequence \" inserts a double quote in a string:

Example

char txt[] = "We are the so-called \"Vikings\" from the north.";

The sequence \' inserts a single quote in a string:

Example

char txt[] = "It\'s alright.";

The sequence \\ inserts a single backslash in a string:

Example
char txt[] = "The character \\ is called backslash.";

Other popular escape characters in C are:

Escape Character Result

\n New Line

\t Tab

\0 Null

C String Functions

String Functions

C also has many useful string functions, which can be used to perform certain
operations on strings.

To use them, you must include the <string.h> header file in your program:

#include <string.h>

String Length

For example, to get the length of a string, you can use the strlen() function:

Example

char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

printf("%d", strlen(alphabet));

In the Strings chapter, we used sizeof to get the size of a string/array. Note
that sizeof and strlen behaves differently, as sizeof also includes the \0 character
when counting:

Example

char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

printf("%d", strlen(alphabet)); // 26
printf("%d", sizeof(alphabet)); // 27
It is also important that you know that sizeof will always return the memory size (in
bytes), and not the actual string length:

Example

char alphabet[50] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

printf("%d", strlen(alphabet)); // 26
printf("%d", sizeof(alphabet)); // 50

Concatenate Strings

To concatenate (combine) two strings, you can use the strcat() function:

Example

char str1[20] = "Hello ";

char str2[] = "World!";

// Concatenate str2 to str1 (result is stored in str1)

strcat(str1, str2);

// Print str1
printf("%s", str1);

Note that the size of str1 should be large enough to store the result of the two
strings combined (20 in our example).

Copy Strings

To copy the value of one string to another, you can use the strcpy() function:

Example

char str1[20] = "Hello World!";

char str2[20];

// Copy str1 to str2

strcpy(str2, str1);

// Print str2
printf("%s", str2);

Note that the size of str2 should be large enough to store the copied string (20 in our
example).
Compare Strings

To compare two strings, you can use the strcmp() function.

It returns 0 if the two strings are equal, otherwise a value that is not 0:

Example

char str1[] = "Hello";

char str2[] = "Hello";
char str3[] = "Hi";

// Compare str1 and str2, and print the result

printf("%d\n", strcmp(str1, str2)); // Returns 0 (the strings are equal)

// Compare str1 and str3, and print the result

printf("%d\n", strcmp(str1, str3)); // Returns -4 (the strings are not equal)

CALCULATE THE AVERAGE GRADES

#include <stdio.h>

int main() {

int grades[100], n, i;

float sum = 0.0, average;

printf("Enter the number of grades: ");

scanf("%d", &n);

// Input grades

printf("Enter the grades:\n");

for(i = 0; i < n; i++) {

printf("Grade %d: ", i + 1);

scanf("%d", &grades[i]);

sum += grades[i];

// Calculate average
 average = sum / n;

printf("Average grade: %.2f\n", average);

return 0;

OUPUT:

Enter the number of grades: 5

Enter the grades:

Grade 1: 80

Grade 2: 90

Grade 3: 75

Grade 4: 85

Grade 5: 95

Average grade: 85.00

FIBINOCCI SERIES

#include <stdio.h>

int main() {

int n, a = 0, b = 1, next, i = 1;

printf("Enter the number of terms: ");

scanf("%d", &n);

printf("Fibonacci Series: ");

while (i <= n) {

printf("%d ", a);

next = a + b;
 a = b;

b = next;

i++;

return 0;

OUTPUT :

Enter the number of terms: 7

Fibonacci Series: 0 1 1 2 3 5 8

ARMSTRONG NUMBERB

#include <stdio.h>

#include <math.h>

int main() {

int num, originalNum, remainder, n = 0;

float result = 0.0;

printf("Enter an integer: ");

scanf("%d", &num);

originalNum = num;

// Count the number of digits

while (originalNum != 0) {

originalNum /= 10;

n++;

originalNum = num;
 // Calculate the sum of nth powers of digits

while (originalNum != 0) {

remainder = originalNum % 10;

result += pow(remainder, n);

originalNum /= 10;

// Check if the number is Armstrong

if ((int)result == num)

printf("%d is an Armstrong number.\n", num);

else

printf("%d is not an Armstrong number.\n", num);

return 0;

OUTPUT:

Enter an integer: 153

153 is an Armstrong number.

PALINDROME NUMBER :

#include <stdio.h>

int main() {

int num, reversed = 0, remainder, original;

printf("Enter an integer: ");

scanf("%d", &num);
 original = num;

// Reverse the number

while (num != 0) {

remainder = num % 10;

reversed = reversed * 10 + remainder;

num /= 10;

// Check if original and reversed numbers are the same

if (original == reversed)

printf("%d is a palindrome number.\n", original);

else

printf("%d is not a palindrome number.\n", original);

return 0;

OUTPUT:

Enter an integer: 121

121 is a palindrome number.

What is a Palindrome Number?

A number is a palindrome if it reads the same backward as forward.

Examples:

 121 → Palindrome

 123 → Not a Palindrome

C Memory Address

Memory Address

When a variable is created in C, a memory address is assigned to the variable.

The memory address is the location of where the variable is stored on the computer.

When we assign a value to the variable, it is stored in this memory address.

To access it, use the reference operator (&), and the result represents where the
variable is stored:

Example

int myAge = 43;

printf("%p", &myAge); // Outputs 0x7ffe5367e044

Note: The memory address is in hexadecimal form (0x..). You will probably not get
the same result in your program, as this depends on where the variable is stored on
your computer.

You should also note that &myAge is often called a "pointer". A pointer basically
stores the memory address of a variable as its value. To print pointer values, we use
the %p format specifier.

Why is it useful to know the memory address?

Pointers are important in C, because they allow us to manipulate the data in the
computer's memory - this can reduce the code and improve the performance.

Pointers are one of the things that make C stand out from other programming
languages, like Python and Java.

Pointers

Creating Pointers

You learned from the previous chapter, that we can get the memory address of a
variable with the reference operator &:

Example

int myAge = 43; // an int variable

printf("%d", myAge); // Outputs the value of myAge (43)

printf("%p", &myAge); // Outputs the memory address of myAge (0x7ffe5367e044)
A pointer is a variable that stores the memory address of another variable as its
value.

A pointer variable points to a data type (like int) of the same type, and is created
with the * operator.

The address of the variable you are working with is assigned to the pointer:

Example

int myAge = 43; // An int variable

int* ptr = &myAge; // A pointer variable, with the name ptr, that stores the address
of myAge

// Output the value of myAge (43)

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

// Output the memory address of myAge (0x7ffe5367e044)

printf("%p\n", &myAge);

// Output the memory address of myAge with the pointer (0x7ffe5367e044)

printf("%p\n", ptr);

Example explained

Create a pointer variable with the name ptr, that points to an int variable (myAge).
Note that the type of the pointer has to match the type of the variable you're
working with (int in our example).

Use the & operator to store the memory address of the myAge variable, and assign
it to the pointer.

Now, ptr holds the value of myAge's memory address.

Dereference

In the example above, we used the pointer variable to get the memory address of a
variable (used together with the & reference operator).

You can also get the value of the variable the pointer points to, by using
the * operator (the dereference operator):

Example

int myAge = 43; // Variable declaration

int* ptr = &myAge; // Pointer declaration

// Reference: Output the memory address of myAge with the pointer

(0x7ffe5367e044)
printf("%p\n", ptr);
// Dereference: Output the value of myAge with the pointer (43)
printf("%d\n", *ptr);

Note that the * sign can be confusing here, as it does two different things in our
code:

 When used in declaration (int* ptr), it creates a pointer variable.

 When not used in declaration, it act as a dereference operator.

Good To Know: There are two ways to declare pointer variables in C:

int* myNum;
int *myNum;

Notes on Pointers

Pointers are one of the things that make C stand out from other programming
languages, like Python and Java.

They are important in C, because they allow us to manipulate the data in the
computer's memory. This can reduce the code and improve the performance. If you
are familiar with data structures like lists, trees and graphs, you should know that
pointers are especially useful for implementing those. And sometimes you even have
to use pointers, for example when working with files and memory management.

But be careful; pointers must be handled with care, since it is possible to damage
data stored in other memory addresses.

C Pointers and Arrays

Pointers & Arrays

You can also use pointers to access arrays.

Consider the following array of integers:

Example

int myNumbers[4] = {25, 50, 75, 100};

You learned from the arrays chapter that you can loop through the array elements
with a for loop:
Example

int myNumbers[4] = {25, 50, 75, 100};

int i;

for (i = 0; i < 4; i++) {

printf("%d\n", myNumbers[i]);
}

Result:

25
50
75
100

Instead of printing the value of each array element, let's print the memory address
of each array element:

Example

int myNumbers[4] = {25, 50, 75, 100};

int i;

for (i = 0; i < 4; i++) {

printf("%p\n", &myNumbers[i]);
}

Result:

0x7ffe70f9d8f0
0x7ffe70f9d8f4
0x7ffe70f9d8f8
0x7ffe70f9d8fc

Note that the last number of each of the elements' memory address is different,
with an addition of 4.

It is because the size of an int type is typically 4 bytes, remember:

Example

// Create an int variable

int myInt;

// Get the memory size of an int

printf("%zu", sizeof(myInt));
Result:

So from the "memory address example" above, you can see that the compiler
reserves 4 bytes of memory for each array element, which means that the entire
array takes up 16 bytes (4 * 4) of memory storage:

Example

int myNumbers[4] = {25, 50, 75, 100};

// Get the size of the myNumbers array

printf("%zu", sizeof(myNumbers));

Result:

16

How Are Pointers Related to Arrays

Ok, so what's the relationship between pointers and arrays? Well, in C, the name of
an array, is actually a pointer to the first element of the array.

Confused? Let's try to understand this better, and use our "memory address
example" above again.

The memory address of the first element is the same as the name of the array:

Example

int myNumbers[4] = {25, 50, 75, 100};

// Get the memory address of the myNumbers array

printf("%p\n", myNumbers);

// Get the memory address of the first array element

printf("%p\n", &myNumbers[0]);

Result:

0x7ffe70f9d8f0
0x7ffe70f9d8f0

This basically means that we can work with arrays through pointers!
How? Since myNumbers is a pointer to the first element in myNumbers, you can use
the * operator to access it:

Example

int myNumbers[4] = {25, 50, 75, 100};

// Get the value of the first element in myNumbers

printf("%d", *myNumbers);

Result:

25

To access the rest of the elements in myNumbers, you can increment the
pointer/array (+1, +2, etc):

Example

int myNumbers[4] = {25, 50, 75, 100};

// Get the value of the second element in myNumbers

printf("%d\n", *(myNumbers + 1));

// Get the value of the third element in myNumbers

printf("%d", *(myNumbers + 2));

// and so on..

Result:

50
75

Or loop through it:

Example

int myNumbers[4] = {25, 50, 75, 100};

int *ptr = myNumbers;
int i;

for (i = 0; i < 4; i++) {

printf("%d\n", *(ptr + i));
}

Result:
25
50
75
100

It is also possible to change the value of array elements with pointers:

Example

int myNumbers[4] = {25, 50, 75, 100};

// Change the value of the first element to 13

*myNumbers = 13;

// Change the value of the second element to 17

*(myNumbers +1) = 17;

// Get the value of the first element

printf("%d\n", *myNumbers);

// Get the value of the second element

printf("%d\n", *(myNumbers + 1));

Result:

13
17

This way of working with arrays might seem a bit excessive. Especially with simple
arrays like in the examples above. However, for large arrays, it can be much more
efficient to access and manipulate arrays with pointers.

It is also considered faster and easier to access two-dimensional arrays with

pointers.

And since strings are actually arrays, you can also use pointers to access strings.

For now, it's great that you know how this works. But like we specified in the
previous chapter; pointers must be handled with care, since it is possible to
overwrite other data stored in memory.