C Introduction

What is C?
C is a general-purpose programming language created by Dennis Ritchie at
the Bell Laboratories in 1972.

It is a very popular language, despite being old.

C is strongly associated with UNIX, as it was developed to write the UNIX

operating system.

Why Learn C?

 It is one of the most popular programming language in the world

 If you know C, you will have no problem learning other popular
programming languages such as Java, Python, C++, C#, etc, as the
syntax is similar
 C is very fast, compared to other programming languages, like Java
and Python.
 C is very versatile; it can be used in both applications and
technologies

Get Started With C

To start using C, you need two things:

 A text editor, like Notepad, to write C code

 A compiler, like GCC, to translate the C code into a language that the
computer will understand

There are many text editors and compilers to choose from.

C Install IDE
An IDE (Integrated Development Environment) is used to edit AND compile
the code.

Popular IDE's include Code::Blocks, Eclipse, and Visual Studio. These are all
free, and they can be used to both edit and debug C code.

Note: Web-based IDE's can work as well, but functionality is limited.

We will use Code::Blocks in this course, which we believe is a good place to

start.

1
 You can find the latest version of Codeblocks at http://www.codeblocks.org/.
Download the mingw-setup.exe file, which will install the text editor with a
compiler.

C Quickstart
Let's create our first C file.

Open Codeblocks and go to File > New > Empty File.

Write the following C code and save the file as myfirstprogram.c (File >
Save File as):

In Codeblocks, it should look like this:

Then, go to Build > Build and Run to run (execute) the program. The
result will look something to this:

Hello World!
Process returned 0 (0x0) execution time : 0.011 s
Press any key to continue.

C Syntax
Example
#include <stdio.h>

int main() {
printf("Hello World!");

2
 return 0;
}

Example explained

Line 1: #include <stdio.h> is a header file library that lets us work with
input and output functions, such as printf() (used in line 4). Header files
add functionality to C programs.

Line 2: A blank line. C ignores white space. But we use it to make the code
more readable.

Line 3: Another thing that always appear in a C program, is main(). This is

called a function. Any code inside its curly brackets {} will be executed.

Line 4: printf() is a function used to output/print text to the screen. In

our example it will output "Hello World!".

Note that: Every C statement ends with a semicolon ;

Line 5: return 0 ends the main() function.

Line 6: Do not forget to add the closing curly bracket } to actually end the
main function.

Output (Print Text)

To output values or print text in C, you can use the printf() function:

You can use as many printf() functions as you want. However, note that
it does not insert a new line at the end of the output:

Example
#include <stdio.h>

int main() {
printf("Hello World!");
printf("I am learning C.");
return 0;
}

New Lines
To insert a new line, you can use the \n character:

#include <stdio.h>

int main() {
printf("Hello World!\n");
printf("I am learning C.");

3
 return 0;
}

What is \n exactly?
The newline character (\n) is called an escape sequence, and it forces the
cursor to change its position to the beginning of the next line on the screen.
This results in a new line.

Examples of other valid escape sequences are:

Escape Description
Sequence

\t Creates a horizontal tab

\\ Inserts a backslash character (\)

\" Inserts a double quote character

C Comments
Comments can be used to explain code, and to make it more readable. It can
also be used to prevent execution when testing alternative code.

Comments can be singled-lined or multi-lined.

Single-line Comments
Single-line comments start with two forward slashes (//).

Any text between // and the end of the line is ignored by the compiler (will
not be executed).

This example uses a single-line comment before a line of code:

Example
// This is a comment
printf("Hello World!");

C Multi-line Comments
Multi-line comments start with /* and ends with */.

Any text between /* and */ will be ignored by the compiler:

Example

4
/* The code below will print the words Hello World!
to the screen, and it is amazing */
printf("Hello World!");

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'. Char values are
surrounded by single quotes

Declaring (Creating) Variables

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

type variableName = value;

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;

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, you must use the
format specifier %d or %i surrounded by double quotes, inside
the printf() function:

5
Example
Print 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);

Change Variable Values

Note: 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;

6
// myNum is now 23, instead of 15
printf("%d", myNum);
Or copy values to empty variables:
// 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);

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
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:

7
Example
// Good
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

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 etc). This is done to
avoid confusion.

However, if you want a real-life example on how variables can be used, take
a look at the following, where we have made a program that stores different
data of 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);

C Data Types
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

8
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.

Data Size Description

Type

int 2 or 4 Stores whole numbers, without decimals

bytes

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

bytes Sufficient for storing 6-7 decimal digits

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

bytes Sufficient for storing 15 decimal digits

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 float

%lf double

%c char

%s Used for strings (text)

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;

9
printf("%f\n", myFloatNum); // Outputs 3.500000
printf("%lf", myDoubleNum); // Outputs 19.990000

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:

10
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) 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):

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

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

C 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;
const float PI = 3.14;

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

Example
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 are used to perform operations on variables and values.

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

12
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 Example

+ Addition Adds together two values x+y

- Subtraction Subtracts one value from x-y

another

* Multiplication Multiplies two values x*y

/ Division Divides one value by x/y

another

% Modulus Returns the division x%y

remainder

++ Increment Increases the value of a ++x

variable by 1

-- Decrement Decreases the value of a --x

variable by 1

Assignment Operators
Assignment operators are used to assign values to variables.

13
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.

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

Example

14
int x = 5;
int y = 3;
printf("%d", x > y); // returns 1 (true) because 5 is greater than 3
A list of all comparison operators:

Operator Name Example

== Equal to x == y

!= Not equal x != y

> Greater than x>y

< Less than x<y

>= Greater than or equal to x >= y

<= Less than or equal to x <= y

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:

Operator Name Description Example

&& Logical Returns true if both x < 5 && x < 10

and statements are
true

|| Logical or Returns true if one x < 5 || x < 4

of the statements
is true

! Logical Reverse the result, !(x < 5 && x < 10)

not returns false if the
result is true

Sizeof Operator
The memory size (in bytes) of a data type or a variable can be found with
the sizeof operator:

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

15
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.

C 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 only 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

16
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.

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> headerfile when working with bool

variables.

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.

17
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

old are allowed to vote!
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.");
}

18