Welcome to C++ Programming Tutorial

Your guide to getting started with C++ programming.

Code Example: Default Arguments

This example demonstrates the use of default arguments in C++. Below is the code:

#include <iostream>
using namespace std;

int add(int a, int b = 12) {
    int c;
    c = a + b;
    return c;
}

int multi(int num1, int num2 = 9, int num3) {
    int ans;
    ans = num1 * num2 * num3;
    return ans;
}

int main() {   
    cout << "ADDITION:" << add(5) << endl;
    cout << "ADDITION:" << add(64) << endl;
    cout << "Multiplication:" << multi(11, 3) << endl;
    return 0;
}

Explanation:

Default Arguments: In C++, a default argument is a value provided in a function declaration that is automatically assigned by the compiler if a corresponding argument is not passed during the function call.
Function `add`: The `add` function has two parameters, `a` and `b`, with `b` having a default value of `12`. If the function is called with only one argument, `b` will automatically take the value `12`, and the function will return the sum of `a` and `b`.
Function `multi`: The `multi` function has three parameters, `num1`, `num2`, and `num3`, with `num2` having a default value of `9`. When calling `multi(11, 3)`, you must provide a value for `num3` since there's no default value for it. The function will return the product of `num1`, `num2`, and `num3`.

Code Example: Function Overloading

This example demonstrates function overloading in C++. Below is the code:

#include <iostream>

using namespace std;

int add(int a, int b) {
    return a + b;
}

int add(int a, int b, int c) {
    return a + b + c;
}

float area(float l, float b, float h) {
   return l * b * h;
}

float area(float r, float pi = 3.14) {
    return pi * r * r;
}

int main() {
    cout << "Total: " << add(2, 4) << endl;
    cout << "Total: " << add(8, 5, 5) << endl;
    cout << area(3.44, 45.5, 53.33) << endl;
    cout << area(5.66) << endl;

    return 0;
}

Explanation:

Function Overloading: Function overloading allows you to define multiple functions with the same name but different parameter lists. The appropriate function is called based on the number and type of arguments passed.
Function `add`: The `add` function is overloaded with two versions: one that takes two parameters and another that takes three. Depending on how many arguments are passed, the correct version of the function is invoked.
Function `area`: The `area` function is also overloaded. The first version calculates the area of a rectangular prism using length, breadth, and height. The second version calculates the area of a circle using a default value for π (pi).

Code Example: Inline Functions

This example demonstrates inline functions in C++. Below is the code:

#include <iostream>

using namespace std;

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

int main() {
    cout << "Square of 5: " << square(5) << endl;
    cout << "Square of 10: " << square(10) << endl;

    return 0;
}

Explanation:

Inline Functions: An inline function is a function definition, usually small in size, which is expanded at the point of its invocation rather than being called. This can improve performance by eliminating the overhead of a function call, but it may increase the size of the binary code.
Function `square`: The `square` function is declared as `inline`, so the compiler may replace the function call with the actual code during compilation. This can result in faster execution for small, frequently called functions.

Code Example: Scope Resolution Operator

This example demonstrates the use of the scope resolution operator in C++. Below is the code:

#include <iostream>

using namespace std;

int x = 10; // Global variable

int main() {
    int x = 20; // Local variable
    cout << "Local x: " << x << endl;
    cout << "Global x: " << ::x << endl;

    return 0;
}

Explanation:

Scope Resolution Operator (`::`): The scope resolution operator in C++ is used to access global variables or functions when they are hidden by local variables or functions with the same name.
Global and Local `x`: In the example, there is a global variable `x` with a value of `10` and a local variable `x` with a value of `20`. The scope resolution operator `::` is used to access the global variable `x`, while the local variable `x` is accessed directly.