### Inline Function in C++

An **inline function** in C++ is a function for which the compiler attempts

to expand the function's code in-place (i.e., at the point of the function
call), rather than performing a normal function call. This can potentially
reduce the overhead of function calls for small, frequently-used functions.

#### Syntax:

**Example:**

### Friend Function in C++

A **friend function** in C++ is a function that is not a member of a class
but is allowed to access its private and protected members. This is useful
for scenarios where you need to provide access to class internals from
outside the class without making those members public.

#### Syntax:

**Example:**
### Inline Functions

**Advantages:**

1. **Reduced Function Call Overhead:** Minimizes overhead by expanding

function code in place.

2. **Improved Code Readability:** Keeps code modular without sacrificing

performance.
3. **Potential for Optimization:** Enables compiler to optimize more
effectively.

**Disadvantages:**

1. **Increased Code Size:** Can cause code bloat if overused.

2. **Limited Complexity:** Best for small functions; complex functions

may not be effectively inlined.

3. **Less Flexibility for Debugging:** Inlining can complicate debugging

due to lack of clear function calls.

### Friend Functions

**Advantages:**

1. **Access to Private and Protected Members:** Can access class

internals not exposed to other parts of the program.

2. **Encapsulation of Complex Operations:** Allows complex operations

without exposing class details.

3. **Enhanced Flexibility:** Useful for implementing operators or utility

functions.

**Disadvantages:**

1. **Breaks Encapsulation:** Violates encapsulation by accessing private

data.

2. **Overuse Can Lead to Maintenance Issues:** Excessive use can

complicate code maintenance.

3. **Not Member of the Class:** Cannot be called using class instance

syntax, which can be less intuitive.
### Function Overloading in C++

**Function overloading** is a feature in C++ that allows the creation of

multiple functions with the same name, provided they differ in the type or
number of parameters. This is an example of polymorphism, one of the
key features of object-oriented programming (OOP), allowing functions to
behave differently based on the arguments provided.

### Why Function Overloading?

In complex programs, you may encounter situations where you need to

perform the same action but with different kinds or numbers of data.
Instead of defining new function names for each case, function
overloading allows you to use a single function name, which makes code
easier to understand and maintain.

### Rules for Function Overloading

1. **Different Number of Parameters**: Functions must differ by the

number of parameters.

2. **Different Types of Parameters**: Functions can have the same

number of parameters, but the parameter types must differ.

3. **Return Type Doesn't Matter**: The return type of the function is not
considered for function overloading. It must differ in the parameter list.

### Example of Function Overloading

Here’s an example to demonstrate how function overloading works:

### Explanation of Example

1. **First `add` Function**:

- Takes two integers and returns their sum.

- Example: `add(5, 10)` returns `15`.

2. **Second `add` Function**:

- Takes two floating-point numbers and returns their sum.

- Example: `add(2.5, 3.5)` returns `6.0`.

3. **Third `add` Function**:

- Takes three integers and returns their sum.

- Example: `add(1, 2, 3)` returns `6`.

In this example, the compiler decides which version of the function to call
based on the number and types of arguments passed.

### Key Benefits of Function Overloading

1. **Code Readability**: Overloaded functions use the same name,

making the code more readable and easier to understand.

2. **Maintainability**: Instead of creating multiple function names for

similar tasks, overloading allows the use of a single function name,
reducing complexity.

3. **Flexibility**: Overloading provides flexibility by allowing different

types and numbers of arguments while performing similar tasks.

4. **Reusability**: Code can be reused more efficiently, as you don't need

to write different function names for similar actions.

### Limitations of Function Overloading

1. **Ambiguity**: Overloaded functions with similar signatures may lead

to ambiguity, which can confuse the compiler and result in errors.

- Example:
2. **Complexity**: While overloading simplifies function names, too many
overloaded versions can sometimes lead to confusion about which
function version is being called.

3. **Not based on Return Type**: The return type alone cannot

differentiate overloaded functions. For example, this will result in a
compilation error:

### How Function Overloading Works Internally

When a function is called, the C++ compiler checks:

1. **Function Name**: It looks for all functions with the given name.

2. **Number of Arguments**: It then looks for functions that have the

same number of arguments as provided in the function call.

3. **Argument Types**: Lastly, it looks for functions whose argument

types match the types of arguments passed to the function.

If it finds an exact match, it calls that function. If there are multiple

matches, it uses a process called **type promotion** to convert
arguments to the appropriate types, if possible, to resolve the function
call.
### Real-World Application

Imagine you are writing a program that handles arithmetic operations for
different data types like integers, floats, and doubles. Without function
overloading, you would need to write separate functions like `addInt()`,
`addDouble()`, etc. Function overloading simplifies this by allowing you to
use the same function name but with different parameter types.

For example:

- `add(int a, int b)` could be used for integers.

- `add(double a, double b)` could be used for floating-point numbers.

This makes the code more intuitive and easier to manage.

### Conclusion

Function overloading is a powerful tool in C++ that enhances the

versatility and readability of programs by allowing multiple functions with
the same name to perform different tasks based on their argument list.
This feature, while useful, must be carefully managed to avoid ambiguity
and maintain clarity in your code. It is an essential aspect of object-
oriented programming that supports polymorphism and is widely used in
real-world applications.
### Default Arguments in C++

**Default arguments** in C++ allow functions to be called with fewer

arguments than those specified in the function declaration. Default values
are provided for some or all of the parameters, which simplifies function
calls and provides flexibility.

#### Syntax:

**Example:**
**Explanation:**

In the `add` function:

- `int add(int a, int b = 5, int c = 10)` has default values of `5` for `b` and
`10` for `c`.

- If fewer arguments are provided, the default values are used.

**Usage of Default Arguments:**

1. **Simplify Function Calls:**

- Allows functions to be called with varying numbers of arguments,

reducing the need for multiple overloads.

2. **Increase Flexibility:**
 - Provides flexibility in how functions are used, as users can skip optional
parameters when they are not needed.

3. **Enhance Code Readability:**

- Makes code cleaner and more readable by avoiding redundant function

overloads for similar operations.

**Key Points:**

1. **Default Values from Right to Left:**

- Default arguments must be specified from right to left. You cannot

provide a default value for an argument without providing default values
for all subsequent arguments.

2. **Can Be Used in Combination with Overloading:**

- Default arguments can be used alongside function overloading to

provide additional flexibility in function calls.

3. **Default Values Must Be Constant Expressions:**

- Default values must be constants or constant expressions that can be

evaluated at compile time.

By using default arguments effectively, you can create more versatile

functions and simplify the process of function calls.
### Constant Arguments in C++

**Constant arguments** refer to parameters that are declared as `const`

within a function. This means that the values of these parameters cannot
be modified by the function. Using constant arguments enhances code
safety by ensuring that the function does not alter the arguments passed
to it.

#### Syntax:
**Example:**

```

**Explanation:**

In the `printSum` function:

- `const int a` and `const int b` ensure that the values of `a` and `b`
cannot be modified within the function.

- Attempting to change the value of `a` or `b` inside the function results
in a compilation error.

### Usage of Constant Arguments:

1. **Prevent Modification:**

- Ensures that the function does not alter the values of arguments,
which is important for maintaining data integrity.

2. **Improve Readability and Intent:**

- Indicates to users and maintainers of the code that the function is

intended to only read the values, not modify them.

3. **Enable Compiler Optimization:**

- Allows the compiler to perform certain optimizations knowing that the

arguments will not change, which can lead to more efficient code.

**Key Points:**

1. **Applies to Both Value and Reference Parameters:**

- `const` can be applied to value parameters (e.g., `const int a`) and
reference parameters (e.g., `const int& a`), but in the latter case, it
indicates that the reference will not modify the referred object.

2. **Const Correctness:**

- Using `const` is part of "const correctness," a practice that ensures

that objects intended to remain unchanged are not accidentally modified.

3. **Default Arguments with Const:**

- Default arguments can also be `const`. For example, `void func(const

int x = 10)` will use the default value of `10` for `x`, which cannot be
changed within the function.

In summary, constant arguments provide safety and clarity by

guaranteeing that the values passed to functions are not modified, which
is crucial for robust and maintainable code.