Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/cpp/local-and-global-variables/ below:

Local and Global Variables - GeeksforGeeks

Last Updated : 21 Mar, 2024

Local variables are declared within a specific block of code, such as a function or method, and have limited scope and lifetime, existing only within that block. Global variables, on the other hand, are declared outside of any function and can be accessed from any part of the program, persisting throughout its execution.

Local variables are variables that are declared within a specific scope, such as within a function or a block of code. These variables are only accessible within that particular scope and are typically used for temporary storage of data or for performing calculations within a limited context. Once the scope in which a local variable is defined ends, the variable typically goes out of scope and its memory is released.

In many programming languages, local variables have a limited visibility and lifespan compared to global variables, which are accessible from any part of the program. This encapsulation of variables within specific scopes helps to organize code, prevent unintended modifications, and manage memory efficiently.

Here are the example of local variable in different language:

#include <iostream>
using namespace std;

void exampleFunction() {
    // Local variable declaration
    int x = 10;
    int y = 20;
    int z = x + y;
    cout << "The sum is: " << z << endl;
}

int main() {
    exampleFunction();
    return 0;
}

public class Main {
    public static void exampleFunction() {
        // Local variable declaration
        int x = 10;
        int y = 20;
        int z = x + y;
        System.out.println("The sum is: " + z);
    }

    public static void main(String[] args) {
        exampleFunction();
    }
}

using System;

public class Program {
    public static void ExampleFunction() {
        // Local variable declaration
        int x = 10;
        int y = 20;
        int z = x + y;
        Console.WriteLine("The sum is: " + z);
    }

    public static void Main(string[] args) {
        ExampleFunction();
    }
}

function exampleFunction() {
    // Local variable declaration
    var x = 10;
    var y = 20;
    var z = x + y;
    console.log("The sum is: " + z);
}

exampleFunction();

def example_function():
    # Local variable declaration
    x = 10
    y = 20
    z = x + y
    print("The sum is:", z)

example_function()

1. Encapsulation: Local variables help encapsulate data within specific functions or blocks, reducing the risk of unintended modification.
2. Memory Management: They promote efficient memory usage by automatically releasing memory once the scope exits.
3. Code Clarity: Local variables make code easier to read and understand by limiting the scope of variables to where they are needed.
4. Name Reusability: Local variables allow the reuse of variable names without causing conflicts with variables in other scopes.

1. Limited Accessibility: Local variables cannot be accessed outside of the scope in which they are defined, which may restrict their use in certain scenarios.
2. Potential for Shadowing Bugs: Shadowing, where a local variable hides another variable with the same name in an outer scope, can lead to bugs and confusion if not handled properly.
3. Lifetime Limited to Scope: Local variables cease to exist once the scope in which they are defined exits, which may be a disadvantage if persistent data storage is required.

Global variables are variables that are declared outside of any function or block of code and can be accessed from any part of the program. Unlike local variables, which have limited scope, global variables have a broader scope and can be used across multiple functions, modules, or files within a program. Here are some characteristics, features, advantages, disadvantages, and uses of global variables:

Here are the example of global variable in different language:

#include <iostream>
using namespace std;

// Global variable declaration
int global_var = 100;

void exampleFunction() {
    // Local variable declaration
    int x = 10;
    int y = 20;
    int z = x + y + global_var;
    cout << "The sum is: " << z << endl;
}

int main() {
    exampleFunction();
    return 0;
}

public class Main {
    // Global variable declaration
    static int global_var = 100;

    public static void exampleFunction() {
        // Local variable declaration
        int x = 10;
        int y = 20;
        int z = x + y + global_var;
        System.out.println("The sum is: " + z);
    }

    public static void main(String[] args) {
        exampleFunction();
    }
}

using System;

public class Program {
    // Global variable declaration
    static int global_var = 100;

    public static void ExampleFunction() {
        // Local variable declaration
        int x = 10;
        int y = 20;
        int z = x + y + global_var;
        Console.WriteLine("The sum is: " + z);
    }

    public static void Main(string[] args) {
        ExampleFunction();
    }
}

// Global variable declaration
var global_var = 100;

function exampleFunction() {
    // Local variable declaration
    var x = 10;
    var y = 20;
    var z = x + y + global_var;
    console.log("The sum is: " + z);
}

exampleFunction();

# Global variable declaration
global_var = 100

def example_function():
    # Local variable declaration
    x = 10
    y = 20
    z = x + y + global_var
    print("The sum is:", z)

example_function()

1. Accessibility: Global variables provide a convenient way to share data across different parts of the program without passing them as function arguments.
2. Ease of Use: They simplify the sharing of data between functions and modules, reducing the need for complex parameter passing mechanisms.
3. Persistence: Global variables retain their values throughout the entire execution of the program, making them suitable for storing persistent data.
4. Reduced Code Duplication: Global variables can help reduce code duplication by centralizing data that is used in multiple parts of the program.

1. Encapsulation Issues: Global variables can lead to encapsulation issues by allowing any part of the program to modify their values, potentially leading to unintended side effects.
2. Debugging Complexity: Since global variables can be accessed and modified from anywhere in the program, tracking down bugs related to their usage can be challenging.
3. Potential for Race Conditions: In multithreaded or concurrent programs, global variables can introduce race conditions if accessed and modified concurrently by multiple threads or processes.
4. Maintainability: Excessive use of global variables can make code harder to understand and maintain, as their effects may not be localized to specific functions or modules.

Local variables are declared within specific blocks of code and have limited scope, existing only within their block. Global variables, declared outside of any function, are accessible from any part of the program and persist throughout its execution. It's essential to use both judiciously, with local variables providing encapsulation and global variables offering shared data accessibility.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4