**Course Title:** Modern C++ Programming: Mastering C++ with Best Practices and Advanced Techniques **Section Title:** Functions and Modular Programming **Topic:** Write modular code using functions, with an emphasis on lambda expressions and constexpr. (Lab topic) **Introduction** In this topic, we will dive deeper into writing modular code using functions in C++. We will explore how to define and use functions effectively, and how to take advantage of lambda expressions and constexpr to write more modern and efficient code. By the end of this topic, you will be able to create well-structured and maintainable code that is easy to read and understand. **Defining and Using Functions** A function is a block of code that performs a specific task. It can take arguments and return values. Functions are useful for breaking down large codebases into smaller, more manageable pieces. This makes it easier to test and maintain your code. Here is an example of a simple function that adds two numbers: ```cpp int add(int a, int b) { return a + b; } ``` To use this function, you would call it with two arguments: ```cpp int result = add(2, 3); std::cout << "Result: " << result << std::endl; ``` This would output: `Result: 5` **Passing Arguments to Functions** When passing arguments to functions, you can choose between pass-by-value, pass-by-reference, or pass-by-const-reference. The choice depends on the specific use case and the desired behavior. Pass-by-value creates a copy of the argument and passes it to the function. This can be useful when you want to modify the argument within the function without affecting the original value. ```cpp void incrementByValue(int value) { value++; std::cout << "Value inside function: " << value << std::endl; } int main() { int x = 5; incrementByValue(x); std::cout << "Value outside function: " << x << std::endl; return 0; } ``` This would output: ``` Value inside function: 6 Value outside function: 5 ``` Pass-by-reference allows you to modify the original argument. ```cpp void incrementByReference(int& value) { value++; std::cout << "Value inside function: " << value << std::endl; } int main() { int x = 5; incrementByReference(x); std::cout << "Value outside function: " << x << std::endl; return 0; } ``` This would output: ``` Value inside function: 6 Value outside function: 6 ``` Pass-by-const-reference is used when you don't plan to modify the argument. ```cpp void printValue(const int& value) { std::cout << "Value inside function: " << value << std::endl; } int main() { int x = 5; printValue(x); std::cout << "Value outside function: " << x << std::endl; return 0; } ``` This would output: ``` Value inside function: 5 Value outside function: 5 ``` **Lambda Expressions** Lambda expressions are a concise way to define small, one-time-use functions. They are useful for tasks such as sorting or filtering data. ```cpp std::vector<int> numbers = { 3, 1, 4, 1, 5, 9, 2 }; std::sort(numbers.begin(), numbers.end(), [](int a, int b) { return a < b; }); ``` In this example, the lambda expression is used to sort the `numbers` vector in ascending order. **constexpr** `constexpr` is a keyword that allows you to evaluate expressions at compile-time. This can improve performance and reduce code size. ```cpp constexpr int PI = 3.14159; constexpr int calculateArea(int radius) { return PI * radius * radius; } ``` In this example, the `calculateArea` function is marked as `constexpr`, which means it can be evaluated at compile-time. This results in more efficient code. **Lab Exercise** Write a program that uses functions to perform the following tasks: * Calculate the area of a rectangle. * Calculate the circumference of a circle. * Sort a vector of integers in descending order using a lambda expression. * Use `constexpr` to define a constant PI value. Test your program with different inputs and verify the results. **Resources** * [C++ Lambda Expressions Tutorial by tutorialspoint](https://www.tutorialspoint.com/cplusplus/cpp_lambda_expression.htm) * [C++ Constexpr Tutorial by tutorialspoint](https://www.tutorialspoint.com/cplusplus/cpp_constexpr.htm) **Conclusion** In this topic, we covered how to write modular code using functions, including pass-by-value, pass-by-reference, and pass-by-const-reference. We also explored lambda expressions and `constexpr` keyword for more efficient and modern C++ programming. Do you have any questions or need further clarification on any of the concepts covered in this topic? Leave a comment below or ask for help. Next, we will cover **Understanding classes and objects in C++** in the Object-Oriented Programming (OOP) in C++ section.