Use of Functions in a Programming Language

What is a Function ?

A chunk of code that only executes when called is termed a function.

A function can take parameters, or data, as input.
Functions are crucial for code reuse because they are used to carry out certain tasks: Use the code frequently after defining it once.

We have functions that are predefined/built-in

For instance, the functions main() and printf() are used to run code and output/print text to the screen, respectively:

We have also functions that are not predefined/built-in which are in programming terms is termed as User-defined. 

How to Create a function in  Programming ?

To construct (also known as declare) your own function, enter the function name, followed by curly brackets {} and parenthesis ().

We are taking example here of C Language: 

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. 

Inside the function (the body), add code that defines what kind of work you want to perform.

Invoke a Function
Declared functions take time to perform. They are "saved for later use" and will be released upon request.

In order to invoke a function, write its name, two parentheses (), and a semicolon.

In the example that follows, myFunction() is invoked to print a text (the action):

For instance, call myFunction() inside main:

void myFunction() { 

    printf("I just got processed!!");

 } // Create a function

int main() {

    myFunction(); // invoke the function; 

    return 0; 

}   

Output/Results:  "I just got executed!"

You can invoke a function more than once:

void myFunction() {

  printf("I just got executed!");

}

int main() {

  myFunction(); // invoke the function; 

  myFunction(); // invoke the function; 

  myFunction(); // invoke the function; 

  return 0;

}

Output/Results: 

// I just got executed!

// I just got executed!

// I just got executed!

This was merely an illustration of a basic function using several C statements.

Functions are used everywhere in a programming languages whether its C, C++, Python, PHP etc. only the difference remains in defining the syntax, execution and working principle remains the same.

Programming Functions
In programming, functions are modular code segments created to carry out particular operations. They enable code organization and reuse by encapsulating a set of instructions. The fundamentals of functions, their significance, many function kinds, etc., will all be covered in this article.

What Do Programming Functions Mean?
In programming, a function is a block of code that contains a single task or a related set of tasks. Functions have names, parameters, and the ability to return values. The fundamental concept of functions is to divide a huge program into smaller, easier-to-manage components (or functions), each of which carries out a distinct purpose.

Functions are essential to programming for a number of reasons, including the following:

1. Code modularity: 

Programming functions assist in dividing a program into more manageable, smaller parts. Because each function can be created, tested, and debugged separately, the program as a whole becomes more structured and understandable.

Example: 

#include <iostream>

using namespace std;

// Function to subtract two numbers

int subtct(int x, int y) {

    return x - y;

}

int main() {

    int result = subtct(9, 7);

    cout << "Subtract: " << result << endl;

    return 0;

}

Output

Sum: 2

2. Abstraction: 

Programmers can abstract the specifics of a given activity using functions. Programmers can use functions with clear interfaces and rely on their functionality without having to comprehend the internal complexity of the implementation. Functions enable the programmer to think more abstractly by concealing the specifics of how they work.

Example

#include <iostream>

using namespace std;

// Abstracting the details of a very complicated operation

int squarenum(int y) {

    // Complex logic or implementation details

    return (y*y);

}

int main() {

    // Using the abstracted of functions without knowing their implementations outside main 

    int result = square(4);

    // Displaying the results in variable result

    cout << "Result of square: " << result << endl;

    return 0;

}

Output

Result of square: 16

3. Code Reusability: 

By encapsulating a particular functionality, functions in programming allow code to be reused. A function can be called repeatedly from various sections of the program once it has been defined, which eliminates redundancy and encourages effective code maintenance. Code duplication can be minimized by calling functions more than once.

#include <iostream>

using namespace std;

// Function for subtraction

int subtract(int x, int y) {

    return x - y;

}

// Function for multiplication

int mult(int x, int y) {

    return x * y;

}

int main() {

    // Reusing the subtraction function

    int result1 = subtract(7, 3);

    cout << "Subtracted value: " << result1 << endl;

    // Reusing the multiplication function

    int result2 = mult(10, 2);

    cout << "Multiplied value: " << result2 << endl;

    return 0;

}

Output

Subtracted value:  4

Multiplied value: 20

4. Readability and also having Maintainability:

 By separating particular responsibilities and offering a clear structure, well-designed functions improve code readability. This facilitates code comprehension and maintenance for programmers, particularly in larger projects where complexity can be a problem.

5. Testing and having Debugging:

 Compared to huge code blocks, functions greatly simplify testing and debugging. Individual code units are simpler to isolate and test since functions contain particular functionalities. The process of debugging becomes more function-specific, making it easier to find and fix problems.

Function Declaration and its Definition : 

A function declaration provides the compiler with information about the parameters, return type, and name of a function. The fundamental characteristics of a function are provided by a function declaration, which also acts as a prototype for the function that can be called elsewhere in the program. A declaration for a function informs the compiler that the specified function is defined elsewhere in the program.

The body of a function and its declaration are both included in the function definition. The function's work is carried out via a block of statements called the body. This example's declared identifiers, which are both declarations and definitions, allocate storage.

Example :

#include <iostream>

using namespace std;

// function declaration here

int sum(int x, int y, int z);

// function definition here

int sum(int x, int y, int z) {

    return x + y + z;

}

int main() {

    cout << sum(4, 5, 4);

    return 0;

}

Output

 13

Programming Function Calling: 

A function can be utilized or "called" by its name after it has been declared. Upon calling a function, the program's control shifts to that function, which subsequently runs its code. The control returns to the section of the program that called the function after it has completed running, and the program proceeds from there.

#include <iostream>

using namespace std;

// Function Definition here

void greeting() { 

    cout << "Hello, World this is programming!" << endl;

 }

int main()

{

    // Calling the function here

    greeting();

    return 0;

}

Output

 Hello, World this is programming!

Return values and Parameters: 

In programming, functions can accept parameters, which are values you give them so they can use them to perform an action. In the function declaration, these parameters are enclosed in parenthesis.

Programming functions can also give the caller a value. The function declaration specifies the return type. The return value is specified inside the function using the return statement.

Example:

#include <iostream>

using namespace std;

// Function with parameters and return value here

int sub(int x, int y) { 

    return x - y;

 }

int main()

{

    int sub = sub(5, 3);

    cout << "The subtracted value is :  " << sub ;

    return 0;

}

Output

 The subtracted value is :  2

Built-in Functions vs User-defined : 

A library of built-in functions that carry out standard operations is included with the majority of programming languages. For instance, input/output processing, text manipulation, and mathematical operations.

Built-in Functions: The C++ standard library offers built-in functions, which are easily usable without the need for extra declarations.

Example:

#include <iostream>

#include <cmath>

using namespace std;

int main() {

    // Built-in functions here

    double squareRootResponse= sqrt(16);

    cout << "Square Root of a number: " << squareRootResponse<< endl;

    return 0;

}

Output: 

Square Root of a number: 4

In contrast, User-defined Functions are those that the programmer defines to carry out certain activities related to their software. These functions' definitions might make use of built-in functions.

#include <iostream>

// Using namespace std to avoid prefixing with std:: in C++

using namespace std;

int main() {

    // Now we can use cout and cin directly without std:: here which is good 

    cout << "Hello, Programming World!" << endl;

    int number;

    cout << "Enter your number here: ";

    cin >> num;

    cout << "Your number is: " << num << endl;

    return 0;

}

Output: 

Hello, Programming World!

Enter your number here: 12

Your number is: 12

Function Recursion:

In programming, recursion is the process by which a function calls itself to resolve an issue. Smaller instances of the same problem are solved by a recursive function.

Example:

#include <iostream>;

using namespace std;

// Recursive function to calculate factorial of a number here

int factorial(int num)

{

    if (num == 0) {

        return 1;

    }

    else {

        return num * factorial(num - 1);

    }

}

int main()

{

    int result1 = factorial(5);

    cout<< "The factorial of a number  is " << result1;

    return 0;

}

Output:

The factorial of a number  is: 120;

Advice on Programming Functions:
Always establish a base case since recursive functions can result in indefinite recursion if they don't have a suitable basis case.
Using Return Statements Correctly: Make sure that a function's code paths that are supposed to return a value do so.
Steer clear of global variables: Ideally, functions should depend on their input parameters rather than on outside variables.
The Single Responsibility Principle states that every function should focus on one task and perform it effectively.

Conclusion:

In conclusion, programming functions are a basic idea that allow for modularity, abstraction, and code reuse. Writing code that is clear, effective, and manageable requires an understanding of how to use functions.