Functions in C ++
Functions in C++ are fundamental building blocks that encapsulate code for specific tasks, promoting reusability and modularity. Here's a structured overview:
1. **Function Syntax**
- **Definition**:
```cpp
returnType functionName(parameters) {
// Code
return value; // Omitted if returnType is void
}
```
Example:
```cpp
int add(int a, int b) {
return a + b;
}
```
- **Declaration (Prototype)**:
```cpp
returnType functionName(parameters); // Informs the compiler about the function.
```
2. **Parameters and Arguments**
- **Pass by Value**: Copies arguments; changes inside the function don't affect the original.
- **Pass by Reference/Pointer**: Modifies the original variable.
```cpp
void increment(int &x) { x++; } // Reference
void swap(int *a, int *b) { ... } // Pointer
```
- **Default Parameters**:
```cpp
void greet(string name = "User") { ... }
greet(); // Uses "User"
```
3. **Return Types**
- Return any data type, including `void` (no return).
- Avoid returning pointers/references to local variables (they go out of scope).
4. **Function Overloading**
- Multiple functions with the same name but different parameters.
```cpp
int area(int side) { ... } // Square
int area(int length, int width) { ... } // Rectangle
```
5. **Inline Functions**
- Suggests the compiler replace calls with the function body for efficiency.
```cpp
inline int min(int a, int b) { return (a < b) ? a : b; }
```
6. **Recursion**
- A function calling itself with a base case to terminate.
```cpp
int factorial(int n) {
if (n == 0) return 1; // Base case
return n * factorial(n - 1);
}
```
7. **Templates (Generic Functions)**
- Write code for any data type.
```cpp
template <typename T>
T max(T a, T b) { return (a > b) ? a : b; }
```
8. **Lambda Expressions (C++11)**
- Anonymous functions for concise code, often used with algorithms.
```cpp
auto sum = [](int a, int b) { return a + b; };
```
9. **Special Functions**
- **`main()`**: Entry point of the program. Can accept command-line arguments:
```cpp
int main(int argc, char *argv[]) { ... }
```
- **Function Pointers**:
```cpp
void (*funcPtr)(int) = &myFunction; // Points to a function
```
10. **Best Practices**
- Single responsibility: One task per function.
- Use `const` for parameters that shouldn’t change.
- Pass large objects by `const &` to avoid copies.
- Meaningful names (e.g., `calculateInterest()` over `calc()`).
Example: Overloaded Functions
```cpp
// Print int
void print(int i) { cout << "Integer: " << i << endl; }
// Print string
void print(string s) { cout << "String: " << s << endl; }
```
Pitfalls to Avoid
- Infinite recursion (missing base case).
- Returning dangling references/pointers.
- Parameter type mismatches in overloading.
By mastering functions, you enhance code readability, reduce redundancy, and efficiently solve complex problems. 🚀
Comments
Post a Comment