Functions in C
Why Functions are important?
- In C programming, functions are blocks of code that perform a specific task or a set of related tasks.
- Functions are essential for breaking down complex programs into smaller, more manageable parts, making the code more organized, modular, and easier to understand.
Function Declaration
- A function declaration tells the compiler about the function's name, return type, and parameters.
- It provides enough information to the compiler to allow it to check the function's usage in the program. Here's how you declare a function:
Loading…
In this example, we declare a function named add that takes two integer parameters and returns an integer.
Function Definition
- Function definition is where you provide the actual implementation of the function.
- It includes the code that gets executed when the function is called.
Loading…
In this code, we define the add function to take two integers as parameters and return their sum.
Function Scope
- Function scope refers to the area of the code where a variable is accessible.
- In C, variables declared within a function have local scope, meaning they are only accessible within that function.
Loading…
In the example above, globalVar is accessible within both main and another Function, but localVar is only accessible within main.
Recursion
- Recursion is a programming technique in which a function calls itself to solve a problem.
- Here is an example of a recursive function that calculates the factorial of a number:
Loading…
The factorial function calls itself until n becomes 1, and then it returns the result.
Call by Value
- In C, function parameters are passed by value by default, which means a copy of the argument is passed to the function.
Loading…
The modify function modifies a copy of num, and the original num remains unchanged.
Call by Reference
- To modify the original values of variables within a function, you can use pointers.
- Here's an example of call by reference using pointers:
Loading…
In this case, we pass a pointer to num to the modify function, allowing it to change the original value.
Preprocessor Directives
- Preprocessor directives are commands that are executed by the C preprocessor before the code is compiled.
- They are indicated by # and are used for various purposes, including defining macros and conditional compilation.
#define
- The #define directive is used to create a macro.
- which is a way to replace a code snippet with a defined value or expression. Here's an example:
Loading…
In this code, MAX_VALUE is defined as 100, and it is used in the if statement.
Macros with Arguments
- You can create macros that take arguments by using #define.
- Here's an example of a macro that calculates the square of a number:
Loading…
The SQUARE macro takes an argument x and returns its square.
Nested Macros
- You can also nest macros within other macros.
Here's an example:
Loading…
In this code, the CUBE macro uses the SQUARE macro within its definition.
## Operator
- The ## operator in macros is used for token concatenation, allowing you to create new identifiers or values by combining tokens.
Here's an example:
Loading…
In this code, the MAKE_IDENTIFIER macro combines "var_" with the argument to create a new variable name.
Conditional Compilation
- Conditional compilation allows you to include or exclude parts of code based on preprocessor directives.
For example:
Loading…
Conclusion
- In C programming, functions are vital for code organization and modularity, simplifying complex tasks.
- Preprocessor directives and macros enhance flexibility and maintainability, ensuring efficient and adaptable code.