Functions
A function is a block of code which only runs when it is called.
You can pass data, known as parameters, into a function.
Functions are used to perform certain actions, and they are
important for reusing code: Define the code once, and use it
many times.
Predefined Functions
So it turns out you already know what a function is. You have
been using it the whole time while studying this tutorial!
For example, main() is a function, which is used to execute
code, and printf() is a function; used to output/print text to
the screen :
int main() {
printf("Hello World!");
return 0;
}
Create a Function
To create (often referred to as declare) your own function,
specify the name of the function, followed by parentheses ()
and curly brackets {} :
Syntax : void myFunction() {
// code to be executed
}
Syntax Explained
myFunction() is the name of the function
void means that the function does not have a return value.
You will learn more about return values later in the next
chapter
Inside the function (the body), add code that defines what
the function should do
Call a Function
Declared functions are not executed immediately. They are
"saved for later use", and will be executed when they are
called.
To call a function, write the function's name followed by two
parentheses () and a semicolon ;
In the following example, myFunction() is used to print a text
(the action), when it is called :
Example : Inside main, call myFunction() :
// Create a function
void myFunction() {
printf("I just got executed!");
}
int main() {
myFunction(); // call the function
return 0;
}
// Outputs "I just got executed!"
A function can be called multiple times :
Example :
void myFunction() {
printf("I just got executed!");
}
int main() {
myFunction();
myFunction();
myFunction();
return 0;
}
// I just got executed!
// I just got executed!
// I just got executed!
Parameters and Arguments
Information can
be passed to functions as a parameter.
Parameters act as variables inside the function.
Parameters are specified after the function name, inside the
parentheses. You can add as many parameters as you want, just
separate them with a comma :
Syntax :
returnType functionName(parameter1, parameter2,
parameter3) {
// code to be executed
}
The following function that takes a string of characters with
name as parameter. When the function is called, we pass along
a name, which is used inside the function to print "Hello" and
the name of each person.
Example :
void myFunction(char name[]) {
printf("Hello %s\n", name);
}
int main() {
myFunction("Liam");
myFunction("Jenny");
myFunction("Anja");
return 0;
}
// Hello Liam
// Hello Jenny
// Hello Anja
When a parameter is passed to the function, it is called an
argument. So, from the example above: name is a parameter,
while Liam, Jenny and Anja are arguments.
Multiple Parameters
Inside the function, you can add as many parameters as you
want.
Example :
void myFunction(char name[], int age) {
printf("Hello %s. You are %d years old.\n", name,
age);
}
int main() {
myFunction("Liam", 3);
myFunction("Jenny", 14);
myFunction("Anja", 30);
return 0;
}
// Hello Liam. You are 3 years old.
// Hello Jenny. You are 14 years old.
// Hello Anja. You are 30 years old.
Note that when you are working with multiple parameters, the
function call must have the same number of arguments as there
are parameters, and the arguments must be passed in the same
order.
Pass Arrays as Function Parameters
You can also pass arrays to a function :
void myFunction(int myNumbers[5]) {
for (int i = 0; i < 5; i++) {
printf("%d\n", myNumbers[i]);
}
}
int main() {
int myNumbers[5] = {10, 20, 30, 40, 50};
myFunction(myNumbers);
return 0;
}
Example Explained
Note that when you are working with multiple parameters, the
function call The function (myFunction) takes an array as its
parameter (int myNumbers[5]), and loops through the array
elements with the for loop.
When the function is called inside main(), we pass along the
myNumbers array, which outputs the array elements.
Note that when you call the function, you only need to use the
name of the array when passing it as an argument
myFunction(myNumbers). However, the full declaration of the
array is needed in the function parameter (int myNumbers[5]).
have the same number of arguments as there are parameters,
and the arguments must be passed in the same order.
Return Values
The void keyword, used in the previous examples, indicates that
the function should not return a value. If you want the function
to return a value, you can use a data type (such as int or float,
etc.) instead of void, and use the return keyword inside the
function :
int myFunction(int x) {
return 5 + x;
}
int main() {
printf("Result is: %d", myFunction(3));
return 0;
}
// Outputs 8 (5 + 3)
This example returns the sum of a function with two
parameters :
int myFunction(int x, int y) {
return x + y;
}
int main() {
printf("Result is: %d",
myFunction(5, 3));
return 0;
}
// Outputs 8 (5 + 3)
You can also store the result in a variable :
int myFunction(int x, int y) {
return x + y;
}
int main() {
int result = myFunction(5, 3);
printf("Result is = %d", result);
return 0;
}
// Outputs 8 (5 + 3)
Function Declaration and Definition
You just learned that you can create and call a function in the
following way :
Example
// Create a function
void myFunction() {
printf("I just got executed!");
}
int main() {
myFunction(); // call the function
return 0;
}
Output : I just got executed!
A function consist of two parts :
Declaration : the function's name, return type, and
parameters (if any)
Definition : the body of the function (code to be executed)
void myFunction() { // declaration
// the body of the function
(definition)
}
For code optimization, it is recommended to separate the
declaration and the definition of the function.
You will often see C programs that have function declaration
above main(), and function definition below main(). This will
make the code better organized and easier to read :
// Function declaration
void myFunction();
// The main method
int main() {
myFunction(); //call the function
return 0;
}
// Function definition
void myFunction() {
printf("I just got executed!");
}
Another Example
int myFunction(int x, int y) {
return x + y;
}
int main() {
int result = myFunction(5, 3);
printf("Result is = %d", result);
return 0;
}
// Outputs 8 (5 + 3)
For code optimization, it is recommended to separate the
declaration and the definition of the function.
You will often see C programs that have function declaration
above main(), and function definition below main(). This will
make the code better organized and easier to read :
// Function declaration
void myFunction();
// The main method
int main() {
myFunction(); //call the function
return 0;
}
// Function definition
void myFunction() {
printf("I just got executed!");
}
Another Example
int myFunction(int x, int y) {
return x + y;
}
int main() {
int result = myFunction(5, 3);
printf("Result is = %d", result);
return 0;
}
// Outputs 8 (5 + 3)
Recursion
Recursion is the technique of making a function call itself. This
technique provides a way to break complicated problems down
into simple problems which are easier to solve.
Recursion may be a bit difficult to understand. The best way to
figure out how it works is to experiment with it.
Recursion Example
Adding two numbers together is easy to do, but adding a range
of numbers is more complicated. In the following example,
recursion is used to add a range of numbers together by
breaking it down into the simple task of adding two numbers :
int sum(int k);
int main() {
int result = sum(10);
printf("%d", result);
return 0;
}
int sum(int k) {
if (k > 0) {
return k + sum(k - 1);
} else {
return 0;
}
}
Example Explained
When the sum() function is called, it adds parameter k to the
sum of all numbers smaller than k and returns the result. When
k becomes 0, the function just returns 0. When running, the
program follows these steps :
10 + sum(9)
10 + ( 9 + sum(8) )
10 + ( 9 + ( 8 + sum(7) ) )
...
10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 + sum(0)
10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 + 0
Since the function does not call itself when k is 0, the program
stops there and returns the result.
The developer should be very careful with recursion as it can
be quite easy to slip into writing a function which never
terminates, or one that uses excess amounts of memory or
processor power. However, when written correctly recursion
can be a very efficient and mathematically-elegant approach to
programming.
Math Functions
There is also a list of math functions available, that allows you
to perform mathematical tasks on numbers.
To use them, you must include the math.h header file in your
program :
#include <math.h>
Square Root
To find the square root of a number, use the sqrt() function :
printf("%f", sqrt(16));
Output : 4.000000
Round a Number
The ceil() function rounds a number upwards to its nearest
integer, and the floor() method rounds a number downwards to
its nearest integer, and returns the result :
printf("%f", ceil(1.4));
printf("%f", floor(1.4));
Output : 2.000000
1.000000
Power
The pow() function returns the value of x to the power of y
(xy) :
printf("%f", pow(4, 3));
Output : 64.000000
Other Math Functions
A list of other popular math functions (from the <math.h>
library) can be found in the table below :
Function Description
abs(x) Returns the absolute value of x
acos(x) Returns the arccosine of x
asin(x) Returns the arcsine of x
atan(x) Returns the arctangent of x
cbrt(x) Returns the cube root of x
cos(x) Returns the cosine of x
exp(x) Returns the value of E^x
sin(x)
Returns the sine of x (x is in radians)
tan(x) Returns the tangent of an angle
File Handling
In C, you can create, open, read, and write to files by declaring
a pointer of type FILE, and use the fopen() function :
FILE *fptr
fptr = fopen(filename, mode);
FILE is basically a data type, and we need to create a pointer
variable to work with it (fptr). For now, this line is not
important. It's just something you need when working with
files.
To actually open a file, use the fopen() function, which takes
two parameters :
Parameter Description
filename The name of the actual file you want to
open (or create), like filename.txt
mode A single character, which represents what
you want to do with the file (read, write or
append) :
w - Writes to a file
a - Appends new data to a file
r - Reads from a file
Create a File
To create a file, you can use the w mode inside the fopen()
function.
The w mode is used to write to a file. However, if the file does
not exist, it will create one for you.
Example
FILE *fptr;
// Create a file
fptr = fopen("filename.txt", "w");
// Close the file
fclose(fptr);
Note : The file is created in the same directory as your other
C files, if nothing else is specified.
On our computer, it looks like this :
Tip : If you want to create the file in a specific folder, just
provide an absolute path :
fptr = fopen("C:\directoryname\filename.txt", "w");
Closing the file
Did you notice the fclose() function in our example above?
This will close the file when we are done with it.
It is considered as good practice, because it makes sure that :
Changes are saved properly
Other programs can use the file (if you want)
Clean up unnecessary memory space
Write To a File
Let's use the w mode from the previous chapter again, and
write something to the file we just created.
The w mode means that the file is opened for writing. To insert
content to it, you can use the fprint() function and add the
pointer variable (fptr in our example) and some text.
Example
FILE *fptr;
// Open a file in writing mode
fptr = fopen("filename.txt", "w");
// Write some text to the file
fprintf(fptr, "Some text");
// Close the file
fclose(fptr);
As a result, when we open the file on our computer, it looks like
this :
Note : If you write to a file that already exists, the old content is
deleted, and the new content is inserted. This is important to
know, as you might accidentally erase existing content.
For example :
fprintf(fptr, "Hello World!");
As a result, when we open the file on our computer, it says
"Hello World!" instead of "Some text" :
Append Content To a File
If you want to add content to a file without deleting the old
content, you can use the a mode.
The a mode appends content at the end of the file.
Example
FILE *fptr;
// Open a file in append mode
fptr = fopen("filename.txt", "a");
// Append some text to the file
fprintf(fptr, "\nHi everybody!");
// Close the file
fclose(fptr);
As a result, when we open the file on our computer, it looks like
this :
Note : Just like with the w mode; if the file does not exist,
the a mode will create a new file with the "appended"
content.
Read a File
Earlier we wrote a file using w and a modes inside the fopen()
function.
.
To read from a file, you can use the r mode
Example
FILE *fptr;
// Open a file in read mode
fptr = fopen("filename.txt", "r");
This will make the filename.txt opened for reading.
It requires a little bit of work to read a file in C. Hang in there!
We will guide you step-by-step.
Next, we need to create a string that should be big enough to
store the content of the file.
For example, let's create a string that can store up to 100
characters:
FILE *fptr;
// Open a file in read mode
fptr = fopen("filename.txt", "r");
// Store the content of the file
char myString[100];
In order to read the content of filename.txt, we can use the
fgets() function.
The fgets() function takes three parameters:
Example
fgets(myString, 100, fptr);
1. The first parameter specifies where to store the file
content, which will be in the myString array we just
created.
2. The second parameter specifies the maximum size of data
to read, which should match the size of myString (100).
3. The third parameter requires a file pointer that is used to
read the file (fptr in our example).
Now, we can print the string, which will output the content of
the file.
Example Output : Hello World!
FILE *fptr;
// Open a file in read mode
fptr = fopen("filename.txt", "r");
// Store the content of the file
char myString[100];
// Read the content and store it inside myString
fgets(myString, 100, fptr);
// Print the file content
printf("%s", myString);
// Close the file
fclose(fptr);
Note : The fgets function only reads the first line of the file.
If you remember, there were two lines of text in
filename.txt.
To read every line of the file, you can use a while loop.
Example
FILE *fptr;
// Open a file in read mode
fptr = fopen("filename.txt", "r");
// Store the content of the file
char myString[100];
// Read the content and print it
while(fgets(myString, 100, fptr)) {
printf("%s", myString);
}
// Close the file
fclose(fptr);
Output : Hello World!
Hi everybody!
Good Practice
If you try to open a file for reading that does not
exist, the fopen() function will return NULL.
Note : As a good practice, we can use an if statement to test
for NULL, and print some text instead (when the file
does not exist).
Example
FILE *fptr;
// Open a file in read mode
fptr = fopen("loremipsum.txt", "r");
// Print some text if the file does not exist
if(fptr == NULL) {
printf("Not able to open the file.");
}
// Close the file
fclose(fptr);
If the file does not exist, the following text is printed :
Not able to open the file.
With this in mind, we can create a more sustainable
code if we use our "read a file" example above again
Structures
Structures (also called structs) are a way to group several
related variables into one place. Each variable in the structure
is known as a member of the structure
.
Unlike an array, a structure can contain many different data
types (int, float, char, etc.).
Create a Structure
You can create a structure by using the struct keyword and
declare each of its members inside curly braces :
struct MyStructure { // Structure declaration
int myNum; // Member (int variable)
char myLetter; // Member (char variable)
}; // End the structure with a semicolon
To access the structure, you must create a variable of it.
Use the struct keyword inside the main() method, followed by
the name of the structure and then the name of the structure
variable.
Create a struct variable with the name "s1":
struct myStructure {
int myNum;
char myLetter;
};
int main() {
struct myStructure s1;
return 0;
}
Access Structure Members
To access members of a structure, use the dot syntax (.) :
Example
// Create a structure called myStructure
struct myStructure {
int myNum;
char myLetter;
};
int main() {
// Create a structure variable of myStructure called
s1
struct myStructure s1;
// Assign values to members of s1
s1.myNum = 13;
s1.myLetter = 'B';
// Print values
printf("My number: %d\n", s1.myNum);
printf("My letter: %c\n", s1.myLetter);
return 0;
}
Now you can easily create multiple structure variables with
different values, using just one structure.
Example
// Create different struct variables
struct myStructure s1;
struct myStructure s2;
// Assign values to different struct variables
s1.myNum = 13;
s1.myLetter = 'B';
s2.myNum = 20;
s2.myLetter = 'C';
What About Strings in Structures?
Remember that strings in C are actually an array of characters,
and unfortunately, you can't assign a value to an array like this :
Example
struct myStructure {
int myNum;
char myLetter;
char myString[30]; // String
};
int main() {
struct myStructure s1;
// Trying to assign a value to the string
s1.myString = "Some text";
// Trying to print the value
printf("My string: %s", s1.myString);
return 0;
}
An error will occur :
prog.c:12:15: error: assignment to expression with
array type
However, there is a solution for this! You can use the strcpy()
function and assign the value to s1.myString, like this :
Example
struct myStructure {
int myNum;
char myLetter;
char myString[30]; // String
};
int main() {
struct myStructure s1;
// Assign a value to the string using the strcpy
function
strcpy(s1.myString, "Some text");
// Print the value
printf("My string: %s", s1.myString);
return 0;
}
Output : My string: Some text
Simpler Syntax
You can also assign values to members of a structure variable
at declaration time, in a single line.
Just insert the values in a comma-separated list inside curly
braces {}. Note that you don't have to use the strcpy() function
for string values with this technique.
Example
// Create a structure
struct myStructure {
int myNum;
char myLetter;
char myString[30];
};
int main() {
// Create a structure variable and assign values to
it
struct myStructure s1 = {13, 'B', "Some text"};
// Print values
printf("%d %c %s", s1.myNum, s1.myLetter,
s1.myString);
return 0;
}
Note : The order of the inserted values must match the order
of the variable types declared in the structure (13 for
int, 'B' for char, etc).
Copy Structures
You can also assign one structure to another.
In the following example, the values of s1 are copied to s2 :
Example
struct myStructure s1 = {13, 'B', "Some text"};
struct myStructure s2;
s2 = s1;
Modify Values
If you want to change/modify a value, you can use the dot
syntax (.).
And to modify a string value, the strcpy() function is useful
again.
struct myStructure { Output : 30 C Something else
int myNum;
char myLetter;
char myString[30];
};
int main() {
// Create a structure variable and assign values to it
struct myStructure s1 = {13, 'B', "Some text"};
// Modify values
s1.myNum = 30;
s1.myLetter = 'C';
strcpy(s1.myString, "Something else");
// Print values
printf("%d %c %s", s1.myNum, s1.myLetter, s1.myString);
return 0;
}
Modifying values are especially useful when you copy structure
values :
Example
// Create a structure variable and assign values to it
struct myStructure s1 = {13, 'B', "Some text"};
// Create another structure variable
struct myStructure s2;
// Copy s1 values to s2
s2 = s1;
// Change s2 values
s2.myNum = 30;
s2.myLetter = 'C';
strcpy(s2.myString, "Something else");
// Print values
printf("%d %c %s\n", s1.myNum, s1.myLetter, s1.myString);
printf("%d %c %s\n", s2.myNum, s2.myLetter, s2.myString);
Output : 13 B Some text
30 C Something else
Ok, so, how are structures useful?
Imagine you have to write a program to store different
information about Cars, such as brand, model, and year. What's
great about structures is that you can create a single "Car
template" and use it for every cars you make. See below for a
real life example.
Real Life Example
Use a structure to store different information about Cars :
Example
struct Car {
char brand[50];
char model[50];
int year;
};
int main() {
struct Car car1 = {"BMW", "X5", 1999};
struct Car car2 = {"Ford", "Mustang", 1969};
struct Car car3 = {"Toyota", "Corolla", 2011};
printf("%s %s %d\n", car1.brand, car1.model, car1.year);
printf("%s %s %d\n", car2.brand, car2.model, car2.year);
printf("%s %s %d\n", car3.brand, car3.model, car3.year);
return 0;
}
Output : BMW X5 1999
Ford Mustang 1969
Toyota Corolla 2011
Enums
An enum is a special type that represents a group of constants
(unchangeable values).
To create an enum, use the enum keyword, followed by the
name of the enum, and separate the enum items with a comma.
enum Level {
LOW,
MEDIUM,
HIGH
};
Note that the last item does not need a comma.
It is not required to use uppercase, but often considered as
good practice.
Enum is short for "enumerations", which means "specifically
listed".
To access the enum, you must create a variable of it.
Inside the main() method, specify the enum keyword, followed
by the name of the enum (Level) and then the name of the
enum variable (myVar in this example):
enum Level myVar;
Now that you have created an enum variable (myVar), you can
assign a value to it.
The assigned value must be one of the items inside the enum
(LOW, MEDIUM or HIGH) :
enum Level myVar = MEDIUM;
By default, the first item (LOW) has the value 0, the second
(MEDIUM) has the value 1, etc.
If you now try to print myVar, it will output 1, which represents
MEDIUM :
int main() {
// Create an enum variable and assign a value to it
enum Level myVar = MEDIUM;
// Print the enum variable
printf("%d", myVar);
return 0;
}
Output : 1
Change Values
As you know, the first item of an enum has the value 0. The
second has the value 1, and so on.
To make more sense of the values, you can easily change them.
enum Level {
LOW = 25,
MEDIUM = 50,
HIGH = 75
};
printf("%d", myVar); // Now outputs 50
Output : 50
Note that if you assign a value to one specific item, the next
items will update their numbers accordingly :
enum Level {
LOW = 5,
MEDIUM, // Now 6
HIGH // Now 7
};
Output : 6
Enum in a Switch Statement
Enums are often used in switch statements to check for
corresponding values :
enum Level {
LOW = 1,
MEDIUM,
HIGH
};
int main() {
enum Level myVar = MEDIUM;
switch (myVar) {
case 1:
printf("Low Level");
break;
case 2:
printf("Medium level");
break;
case 3:
printf("High level");
break;
}
return 0;
}
Output : Medium level
Why And When To Use Enums?
Enums are used to give names to constants, which makes the
code easier to read and maintain.
Use enums when you have values that you know aren't going to
change, like month days, days, colors, deck of cards, etc.
