Lesson 12

C++ Functions and Variables Conclusion

In this module you learned the syntax, use, and scope of C++ functions and variables. In particular you learned:

How C++ uses function prototypes
How using default function arguments can save you time
What it means to overload a function
How to use the keyword inline to speed up programs
The difference between file scope and local scope
How the extern and static storage classes are useful in multifile programs
The rules of linkage for multifile programs
What namespaces are and why they are useful

The following describes how C++ functions and variables' scope are defined using the topics you’ve provided:

How C++ Uses Function Prototypes
- Function prototypes declare a function's signature before its definition. They allow the compiler to check function calls for correctness and enable functions to be called before they are defined in the file.
- Example:
```
#include <iostream>

// Function prototype
void greetUser(const std::string& name);

int main() {
    greetUser("Alice"); // Calls the function declared earlier
    return 0;
}

// Function definition
void greetUser(const std::string& name) {
    std::cout << "Hello, " << name << "!" << std::endl;
}
                
```
- Prototypes specify the function's name, return type, and parameter list.
- Ensures type safety during compilation.

How Using the "Default Function Arguments" Can Save You Time

Default function arguments allow you to assign default values to parameters. This eliminates the need to overload functions for minor variations.

Example:

#include <iostream>

void printMessage(const std::string& message, int repeat = 1) {
    for (int i = 0; i < repeat; ++i) {
        std::cout << message << std::endl;
    }
}

int main() {
    printMessage("Welcome!");         // Uses default repeat = 1
    printMessage("Hello!", 3);        // Overrides default repeat
    return 0;
}

Default arguments simplify function calls.
Saves time by reducing redundant function overloads.

How to Use the Keyword "inline" to Speed Up Programs
- The inline keyword suggests to the compiler to replace the function call with the actual function code during compilation. This reduces the overhead of a function call.
- Example:
```
#include <iostream>

inline int square(int x) {
    return x * x;
}

int main() {
    std::cout << "Square of 5: " << square(5) << std::endl;
    return 0;
}
                
```
- When to Use: For small, frequently called functions.
- Performance: Eliminates function call overhead, but can increase binary size if overused.
The Difference Between File Scope and Local Scope
- File Scope: Variables or functions declared outside of any function or class have file scope. They are accessible throughout the file.
  - Example:
```
int globalVar = 10; // File scope

void display() {
    std::cout << globalVar << std::endl; // Accessible anywhere in the file
}
                        
```
- Local Scope: Variables declared within a function or block are limited to that function or block.
  - Example:
```
void calculate() {
    int localVar = 20; // Local scope
    std::cout << localVar << std::endl;
}
                        
```
- Key Difference: File scope is global within a file, whereas local scope is confined to a specific function or block.
How the extern and static Storage Classes Are Useful in Multifile Programs
- Details were not provided in the prompt; expand as needed.

extern

The extern keyword declares a variable or function that is defined in another file. It allows sharing of global variables/functions across multiple files.

Example:

// File1.cpp
#include 
extern int sharedVar; // Declaration of an external variable

void printSharedVar() {
    std::cout << "Shared Variable: " << sharedVar << std::endl;
}

// File2.cpp
int sharedVar = 42; // Definition of the external variable

Use Case: Sharing data between multiple files in a project.

static
- The static keyword limits the visibility of a variable or function to the file in which it is declared. It provides internal linkage.
- Example:
```
// File1.cpp
#include 

static int counter = 0; // Internal linkage: visible only in this file

void incrementCounter() {
    ++counter;
    std::cout << "Counter: " << counter << std::endl;
}
                
```
- Use Case: Prevents name collisions in multifile programs by ensuring variables or functions are local to their file.

These features in C++ give you precise control over the scope and visibility of variables and functions, ensuring maintainable and efficient code.

Big C++

Function Overloading

Function overloading is the process of using the same name for two or more functions.The secret to overloading is that each redefinition of the function must use either different types of parameters or a different number of parameters. It is only through these differences that the compiler knows which function to call in any given situation. For example, this program overloads myfunc( ) by using different types of parameters.

#include <iostream>
using namespace std;
int myfunc(int i); // these differ in types of parameters
double myfunc(double i);
int main(){
 cout << myfunc(10) << " "; // calls myfunc(int i)
 cout << myfunc(5.4); // calls myfunc(double i)
 return 0;
}
double myfunc(double i){
 return i;
}
int myfunc(int i){
 return i;
}

The next program overloads myfunc( ) using a different number of parameters:

#include <iostream>
using namespace std;
int myfunc(int i); // these differ in number of parameters
int myfunc(int i, int j);
int main(){
 cout <<myfunc(10) << " "; // calls myfunc(int i)
 cout << myfunc(4, 5); // calls myfunc(int i, int j)
 return 0;
}
int myfunc(int i){
 return i;
}
int myfunc(int i, int j){
 return i*j;
}

As mentioned, the key point about function overloading is that the functions must differ in regard to the types and/or number of parameters. Two functions differing only in their return types cannot be overloaded. For example, this is an invalid attempt to overload myfunc( ):

int myfunc(int i); // Error: differing return types are
float myfunc(int i); // insufficient when overloading.

Sometimes, two function declarations will appear to differ, when in fact they do not. For example, consider the following declarations.

void f(int *p);
void f(int p[]); // error, *p is same as p[]

Remember, to the compiler *p is the same as p[ ]. Therefore, although the two prototypes appear to differ in the types of their parameter, in actuality they do not.

Functions Scope - Quiz

Click the Quiz link below to take a multiple-choice quiz covering the topics presented in this module.
Functions Scope - Quiz