Functions in C++ Programming

C++ Function

✔ 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.
 Create a Function

✔ C++ provides some pre-defined functions, such as main(), which is used to

execute code. But you can also create your own functions to perform certain
actions.
✔ To create (often referred to as declare) a function, specify the name of the
function, followed by parentheses ():
Syntax:
void myFunction() {
// code to be executed
}

Example 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 later, 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:

Syntax:

myFunction();
Function: Example

Example: Output:
// Create a function I just got executed!
void myFunction() {
cout << "I just got executed!";
}

int main() {
myFunction(); // call the function
return 0;
}

// Outputs "I just got executed!"

Function: Example

Example: Output:
void myFunction() { I just got executed!
cout << "I just got executed!\n"; I just got executed!
} I just got executed!

int main() {
myFunction();
myFunction();
myFunction();
return 0;
}
Function Declaration and Definition

If a user-defined function, such as myFunction() is declared after

the main() function, an error will occur. It is because C++ works from top to
bottom; which means that if the function is not declared above main(), the
program is unaware of it:

Example: // Function declaration

void myFunction();

// The main method

int main() {
myFunction(); // call the function
return 0;
}

// Function definition
void myFunction() {
cout << "I just got executed!";
}
Function Parameter 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:
void functionName(parameter1, parameter2, parameter3) {
// code to be executed
}
Function Parameter and arguments

The following example has a function that takes a string called fname as
parameter. When the function is called, we pass along a first name, which is used
inside the function to print the full name:
Example: Output:
void myFunction(string fname) { Liam Welcome
cout << fname << " Welcome\n"; Jenny Welcome
} Anja Welcome

int main() {
myFunction("Liam");
myFunction("Jenny");
myFunction("Anja");
return 0;
}
Function Overloading

With function overloading, multiple functions can have the same name with
different parameters:

Example:
int myFunction(int x)
float myFunction(float x)
double myFunction(double x, doubl
e y)
Function Overloading
With function overloading, multiple functions can have the same name with
different parameters:
Example: Output:
int plusFunc(int x, int y) { Int : 13
return x + y; Double : 10.56
}

double plusFunc(double x, double y) {

return x + y;
}

int main() {
int myNum1 = plusFunc(8, 5);
double myNum2 = plusFunc(4.3, 6.26);
cout << "Int: " << myNum1 << "\n";
cout << "Double: " << myNum2;
return 0;
}
C++ Pointers
You learned from the previous chapter, that we can get the memory address of
a variable by using the & operator:
Example:
string food = "Pizza"; // A food variable of type string

cout << food; // Outputs the value of food (Pizza)

cout << &food; // Outputs the memory address of food (0x6dfed4)
 C++ Pointers
✔ A pointer however, is a variable that stores the memory address as its value.
✔ A pointer variable points to a data type (like int or string) of the same type, and is
created with the * operator. The address of the variable you're working with is
assigned to the pointer:
Example:
string food = "Pizza"; // A food variable of type string
string* ptr = &food; // A pointer variable, with the name ptr,
that stores the address of food

// Output the value of food (Pizza)

cout << food << "\n";

// Output the memory address of food (0x6dfed4)

cout << &food << "\n";

// Output the memory address of food with the pointer (0x6dfed4)

cout << ptr << "\n";
 C++ Dereference
✔ we used the pointer variable to get the memory address of a variable (used
together with the & reference operator).
✔ However, you can also use the pointer to get the value of the variable, by using
the * operator (the dereference operator):
Example:
string food = "Pizza"; // Variable declaration Pointer Variable
string* ptr = &food; // Pointer declaration

// Reference: Output the memory address of food with the pointer (0x6dfed4)
cout << ptr << "\n";

// Dereference: Output the value of food with the pointer (Pizza)

cout << *ptr << "\n";

Dereference Operator
 C++ Modify Pointers
✔ You can also change the pointer's value. But note that this will also change the
value of the original variable:
Example: string food = "Pizza";
string* ptr = &food;
// Output the value of food (Pizza)
cout << food << "\n";
// Output the memory address of food (0x6dfed4)
cout << &food << "\n";
// Access the memory address of food and output its value (Pizza)
cout << *ptr << "\n";
// Change the value of the pointer
*ptr = "Hamburger";
// Output the new value of the pointer (Hamburger)
cout << *ptr << "\n";
// Output the new value of the food variable (Hamburger)
cout << food << "\n";
C++ Use of pointers
Example:

1. WAP to swap two numbers using pointers.

Output:
Number_1 = 1
Number_2 = 2

After Swapping

Number_1 = 2
Number_2 = 1