C/Cxx-静态数据类型_cxxc,czp-CSDN博客

本文链接：https://blog.csdn.net/qq_43656353/article/details/135636462

本文详细比较了C++中静态局部变量和普通局部变量在生命周期、作用域、初始化、存储位置以及适用场景的区别。静态局部变量用于跨函数调用的状态保持，而普通局部变量则每次函数调用时都会重新初始化。

摘要由CSDN通过智能技术生成

静态局部变量相比于普通的局部变量有什么区别？
近期自学Programming Abstractions in C++ pp.104时的困惑。经典使用

/*
 * Implementation notes: initRandomSeed
 * ------------------------------------
 * The initRandomSeed function declares a static variable that keeps track
 * of whether the seed has been initialized. The first time initRandomSeed
 * is called, initialized is false, so the seed is set to the current time.
 */
void initRandomSeed()
{
    static bool initialized = false;
    if(!initialized)
    {
        srand(int (time(NULL)));
        initialized = true;
    }
}

What is the difference between a static local variable and a regular local variable?

In C and C++, the key differences between a static local variable and a regular (non-static) local variable lie in their lifetime, scope, and initialization. Here’s a detailed comparison:
Lifetime
Static Local Variable:
Has a lifetime that extends across the entire runtime of the program.
It is initialized only once, the first time the control flow passes through its declaration, and retains its value between function calls.
Regular Local Variable:
Has a lifetime that is limited to the function call in which it is defined.
It is created when the function is called and destroyed when the function exits.
Each time the function is called, the variable is reinitialized.
Scope
Both static and regular local variables:
Have the same scope, which is limited to the function (or block) in which they are defined.
Cannot be accessed outside of that function.
Initialization
Static Local Variable:
If not explicitly initialized, it is automatically initialized to zero (for basic data types) or default-initialized (for class instances).
Regular Local Variable:
If not initialized, it contains an indeterminate value (usually garbage) unless it’s an object of a class with a constructor.
Storage
Static Local Variable:
Stored in a static or global data area, not on the stack.
Regular Local Variable:
Stored on the stack (unless optimized otherwise by the compiler).
Example
void function() {
   static int staticVar = 0; // Static local variable
   int regularVar = 0;       // Regular local variable

   staticVar++;
   regularVar++;

   std::cout << "Static: " << staticVar << ", Regular: " << regularVar << std::endl;
}
// Calling function multiple times
function(); // Output: Static: 1, Regular: 1
function(); // Output: Static: 2, Regular: 1
function(); // Output: Static: 3, Regular: 1
In this example, each call to function() increments both staticVar and regularVar. However, staticVar retains its value between calls (since it’s static), while regularVar is reinitialized to 0 each time the function is entered.
Use Cases
Static Local Variables: Useful for maintaining state within a function across multiple calls, such as for caching results, counting the number of times a function is called, or managing resources that need to persist across function calls.
Regular Local Variables: Used for calculations and operations that do not require persistence between different calls to the function.
In summary, the choice between a static local variable and a regular local variable depends on whether you need the variable to retain its value between function calls and exist for the duration of the program.