C语言 当我们可以以相同的成本获得全局变量时，静态局部变量有什么用？

What is the use of Static local variable when we can get a global variable at the same cost?

提问by Adi

In C ,what is the use of static storage class when an external variable can serve its purpose at the same cost ie. both occupy storage space in the data segment of the executable.

在 C 中，当外部变量可以以相同的成本实现其目的时，静态存储类的用途是什么？两者都占用可执行文件数据段的存储空间。

I have much better scope with external variable.If i want the scope of external variable to be specific file i do not declare this variable else where.i see a lot of flexibility with a global variable that static local variable

我有更好的外部变量范围。如果我希望外部变量的范围是特定文件，我不会在其他地方声明这个变量。我看到全局变量有很大的灵活性，静态局部变量

And we can refer to local static variable outside the function if we have the address of the variable.Memory for local static variable will be in Data segment not in the stack frame of the function.So unique feature does static storage class bring to the table.

如果我们有变量的地址，我们可以在函数外部引用局部静态变量。局部静态变量的内存将在数据段中，而不是在函数的堆栈帧中。因此静态存储类为表带来了独特的功能.

I just want to know whether static has any subtle purpose that i m not aware of.

我只想知道静态是否有任何我不知道的微妙目的。

回答by Eric Postpischil

You write that a global variable has a “better” scope. This is incorrect. It has a bigger scope. Bigger is not better.

您写道全局变量具有“更好”的作用域。这是不正确的。它有更大的范围。不是越大越好。

Bigger may be necessary, if you needan identifier to be visible in more places, but this is often not the case. But a bigger scope means more exposure to errors. Global variables muddle the semantics of routines by making it harder to see what program state they use and change, and it increases the probability of errors caused by failing to declare a local identifier and of other errors.

如果您需要一个标识符在更多地方可见，则可能需要更大，但通常情况并非如此。但是更大的范围意味着更多的错误。全局变量使例程的语义变得混乱，因为更难查看它们使用和更改的程序状态，并且增加了由于未能声明本地标识符和其他错误而导致的错误概率。

In particular, an identifier with external linkage will collide with identifiers in other libraries. Consider what happens when you are writing a physics application, have an external identifier named acceleration, and link with a physics library that also has an external identifier named acceleration. The program will fail. Because of this, external identifiers are usually bad design.

特别是，具有外部链接的标识符将与其他库中的标识符发生冲突。考虑一下当您编写一个物理应用程序时会发生什么，有一个名为 的外部标识符acceleration，并与一个也有一个名为 的外部标识符的物理库链接acceleration。程序会失败。因此，外部标识符通常是糟糕的设计。

A significant limit on our ability to develop and maintain complex software is human error. Much of programming language semantics limitsthe language to prevent errors. With a raw computer, you can add two pointers, trash your stack pointer, accidentally load the bytes of a floatinto an integer register, and so on. Good programming languages make these errors difficult to do by mistake.

我们开发和维护复杂软件的能力的一个重大限制是人为错误。许多编程语言语义限制了语言以防止错误。使用原始计算机，您可以添加两个指针、丢弃堆栈指针、意外将 a 的字节加载float到整数寄存器中，等等。好的编程语言使这些错误很难被误操作。

Global variables were a larger source of errors before scoping rules helped control them. Good programmers limit the scopes of their identifiers.

在范围规则帮助控制它们之前，全局变量是更大的错误来源。优秀的程序员会限制他们标识符的范围。

回答by msam

A global variable is well, global, it can be accessed from anywhere.

全局变量很好，是全局的，可以从任何地方访问。

A static local variable has local scope. It is static, so it's lifetime runs across the lifetime of the application however it can only be accessed from the local scope (whether that scope is a function, a block, or a file)

静态局部变量具有局部作用域。它是静态的，所以它的生命周期贯穿应用程序的生命周期，但它只能从本地范围访问（无论该范围是函数、块还是文件）

回答by Kinjal Patel

The basic difference is on scope of variable.

基本的区别在于变量的范围。

1) global variable is global for entire project. lets say your project has 10 different files then all 10 files can access the global variable(see how to use extern).

1) 全局变量对于整个项目是全局的。假设您的项目有 10 个不同的文件，那么所有 10 个文件都可以访问全局变量（请参阅如何使用 extern）。

2) static variable/function can be used by function/file within which it is defined. It cannot be used by any other file in your project.

2) 静态变量/函数可由定义它的函数/文件使用。它不能被项目中的任何其他文件使用。

yet, you can modify the static variable(defined in func1()) in func2() by passing reference of the variable. please look into below example,

但是，您可以通过传递变量的引用来修改 func2() 中的静态变量（在 func1() 中定义）。请看下面的例子，

void func2(int *i)
{
    (*i)++;
}

void func1()
{
    static int i;

    i=1;
    printf("%d\n", i);
    func2(&i);
    printf("%d\n", i);  
}

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

As you see above, func1() has static int iwhich cannot be directly manipulated by func2(), but if you pass reference of the variable you can still manipulate the variable like ordinary variable.

正如你在上面看到的，func1()static int i不能直接被 func2() 操作，但是如果你传递变量的引用，你仍然可以像普通变量一样操作变量。

hope it helps...

希望能帮助到你...

回答by unkulunkulu

Difference between localand globalfirst and foremost is the scope: you can access local variables only from within the block they're defined in, while global variables can be accessed from anywhere. Consequently, you can only have one variable with a given name in global scope, but you can have multiple local static variables in different functions.

局部和全局之间的区别首先是作用域：您只能从定义它们的块内访问局部变量，而可以从任何地方访问全局变量。因此，在全局范围内只能有一个具有给定名称的变量，但在不同的函数中可以有多个局部静态变量。

As with static global variables versus extern variables: yes, static global variables are local to the translation unit (i.e. the .c source file they're defined in).

对于静态全局变量与外部变量：是的，静态全局变量是翻译单元的本地变量（即定义它们的 .c 源文件）。

So the main concern here is the notion of scope, and the storage comes naturally from there.

所以这里的主要问题是范围的概念，存储自然而然地来自那里。

回答by Mppl

The reason you should use a local static variable is scope, and therefore avoiding some bug prone situations since using a local static variable you'll not be able to refer to it outside the function it was defined in.

您应该使用局部静态变量的原因是范围，因此避免了一些容易出错的情况，因为使用局部静态变量您将无法在定义它的函数之外引用它。

回答by user1627657

Here's a short program which demonstrates the difference:

这是一个演示差异的简短程序：

#include <stdio.h>

static int a=20;
void local()
{
   printf("%d,addr:%d \n", a, (void*)&a);
   a = 100;
}

int main()
{

      {
         static int a = 10;
         printf("%d,addr:%d \n", a, (void*)&a);
         local();
      }
      printf("%d addr:%d \n", a, (void*)&a);
}

Output:

输出：

10,addr:134518604   -- local static inside the braces
20,addr:134518600   -- this is referring the global static variable
100 addr:134518600  -- This is referring the global static variable which is outside of 
                       the braces.

Here braces also matters: if no braces in the main()function then it refers local static variable only.

这里大括号也很重要：如果main()函数中没有大括号，那么它只引用局部静态变量。