C++ c和c+环境中静态、自动、全局和局部变量之间的差异+；

我对

静态

、

自动

、

全局

和

局部

变量有点困惑

在某个地方，我读到一个

静态

变量只能在函数中访问，但在函数返回后它们仍然存在（保留在内存中）

---

但是，我也知道一个

局部变量也有同样的作用，那么有什么区别呢？
函数终止后，局部变量在内存中不存在。

但是
静态
变量在程序的整个生命周期内保持在内存中分配，而与任何功能无关

此外，根据您的问题，
静态
变量可以在
类
或函数范围中本地声明，也可以在
命名空间
或文件范围中全局声明。它们从头到尾都被分配了内存，只是初始化迟早会发生。
首先，我说你应该用谷歌搜索，因为它在很多地方都有详细的定义


本地

这些变量只存在于创建它们的特定函数中。其他函数和主程序都不知道它们。因此，它们通常使用堆栈实现。一旦创建局部变量的函数完成，局部变量就不再存在。每次执行或调用函数时都会重新创建它们。



全球

构成程序的任何函数都可以访问（即已知）这些变量。它们是通过将内存位置与变量名关联来实现的。如果调用函数，则不会重新创建它们。

/* Demonstrating Global variables  */
    #include <stdio.h>
    int add_numbers( void );                /* ANSI function prototype */

    /* These are global variables and can be accessed by functions from this point on */
    int  value1, value2, value3;

    int add_numbers( void )
    {
        auto int result;
        result = value1 + value2 + value3;
        return result;
    }

    main()
    {
        auto int result;
        value1 = 10;
        value2 = 20;
        value3 = 30;        
        result = add_numbers();
        printf("The sum of %d + %d + %d is %d\n",
            value1, value2, value3, final_result);
    }


    Sample Program Output
    The sum of 10 + 20 + 30 is 60

/*演示全局变量*/
#包括
整数加上数字（空）；/*ANSI函数原型*/
/*这些都是全局变量，从现在起函数就可以访问它们*/
int值1、值2、值3；
整数加整数（空）
{
自动整型结果；
结果=值1+值2+值3；
返回结果；
}
main（）
{
自动整型结果；
值1=10；
值2=20；
值3=30；
结果=添加_个数字（）；
printf（“%d+%d+%d之和为%d\n”，
值1、值2、值3、最终结果）；
}
示例程序输出
10+20+30之和是60

可以通过仔细放置声明来限制全局变量的范围。它们在声明中可见，直到当前源文件结束

#include <stdio.h>
void no_access( void ); /* ANSI function prototype */
void all_access( void );

static int n2;      /* n2 is known from this point onwards */

void no_access( void )
{
    n1 = 10;        /* illegal, n1 not yet known */
    n2 = 5;         /* valid */
}

static int n1;      /* n1 is known from this point onwards */

void all_access( void )
{
    n1 = 10;        /* valid */
    n2 = 3;         /* valid */
}

#包括
无效无访问权（无效）；/*ANSI函数原型*/
使所有访问无效（无效）；
静态整数n2；/*从这一点开始，n2是已知的*/
无效无访问权限（无效）
{
n1=10；/*非法，n1未知*/
n2=5；/*有效*/
}
静态int n1；/*从这一点开始就知道n1*/
使所有访问无效（无效）
{
n1=10；/*有效*/
n2=3；/*有效*/
}

静态：
静态对象是一个从构建到程序结束的对象。因此，堆栈和堆对象被排除在外。但是全局对象、命名空间范围内的对象、类/函数内声明为静态的对象以及文件范围内声明的对象都包含在静态对象中。当程序停止运行时，静态对象将被销毁。
我建议您


自动：C，C++

（称为自动变量。）

默认情况下，代码块中声明的所有变量都是自动的，但这可以通过auto关键字显式显示。[注意1]未初始化的自动变量具有未定义的值，直到为其分配了其类型的有效值。[1]

使用存储类寄存器而不是auto是一种提示，提示编译器将变量缓存在处理器寄存器中。除了不允许在变量或其任何子组件上使用引用运算符（&）之外，编译器可以自由忽略提示

<>在C++中，执行变量到达声明位置时调用自动变量的构造函数。析构函数在到达给定程序块的末尾时被调用（程序块被花括号包围）。这个特性通常用于管理资源分配和分配，比如打开和自动关闭文件或释放内存。
 < P> <代码> static < /C> >是C和C++中的一个严重重载的词。函数上下文中的代码>静态

变量是在调用之间保存其值的变量。它们在课程期间一直存在

局部变量仅在函数的生命周期内或其封闭范围内存在。例如：

void foo()
{
    int i, j, k;
    //initialize, do stuff
} //i, j, k fall out of scope, no longer exist

有时此作用域用于

{}

块：

{ 
   int i, j, k;
   //...
} //i, j, k now out of scope

在程序期间存在全局变量

---

<> >代码> Audio在C和C++中不同。C中的code>auto是一种（多余的）指定局部变量的方法。在C++11中，

auto

现在用于自动派生值/表达式的类型

不同之处在于静态变量是那些变量：它允许从一个函数调用到另一个函数调用保留一个值。 但对于局部变量，作用域一直到块/函数生命周期

例如：

#include <stdio.h>

void func() {
    static int x = 0; // x is initialized only once across three calls of func()
    printf("%d\n", x); // outputs the value of x
    x = x + 1;
}

int main(int argc, char * const argv[]) {
    func(); // prints 0
    func(); // prints 1
    func(); // prints 2
    return 0;
}

#包括
void func（）{
静态int x=0；//x仅在三次调用func（）时初始化一次
printf（“%d\n”，x）；//输出x的值
x=x+1；
}
int main（int argc，char*const argv[]{
func（）；//打印0
func（）；//打印1
func（）；//打印2
返回0；
}

这里有两个独立的概念：

• 作用域，它确定可以访问名称的位置，以及
• 存储持续时间，用于确定创建变量的时间

  void f() {
      int i;
      i = 1; // OK: in scope
  }
  void g() {
      i = 2; // Error: not in scope
  }
  

  int i;
  void f() {
      i = 1; // OK: in scope
  }
  void g() {
      i = 2; // OK: still in scope
  }
  

  for (int i = 0; i < 5; ++i) {
      int n = 0;
      printf("%d ", ++n);  // prints 1 1 1 1 1  - the previous value is lost
  }
  

  for (int i = 0; i < 5; ++i) {
      static int n = 0;
      printf("%d ", ++n);  // prints 1 2 3 4 5  - the value persists
  }
  

  #include<iostream.h>
  #include<conio.h>
  class test
  {
      void fun()
      {
          static int a=0;
          a++;
          cout<<"Value of a = "<<a<<"\n";
      }
  };
  void main()
  {
      clrscr();
      test obj1;
      test obj2;
      test obj3;
      obj1.fun();
      obj2.fun();
      obj3.fun();
      getch();
  }
  

  Value of a = 1
  Value of a = 2
  Value of a = 3
  

  Value of a = 1
  Value of a = 1
  Value of a = 1