浅谈C中静态变量与全局变量初始化时间

合集下载

c语言的变量范围

c语言的变量范围C语言是一种强大而灵活的编程语言，它具有丰富的变量范围规则，这些规则决定了变量的可见性和生命周期。

在本文中，我将详细介绍C语言的变量范围，包括全局变量、局部变量和静态变量。

一、全局变量全局变量是在函数外部定义的变量，它可以在程序的任何地方使用。

全局变量的作用域从定义处开始，一直延伸到文件的末尾。

这意味着全局变量在整个程序中都是可见的，并且可以被多个函数共享和修改。

全局变量的好处是可以在不同的函数中共享数据，但同时也存在一些潜在的问题。

由于全局变量的可见性很高，所以可能会被意外地修改，导致程序出现错误。

另外，全局变量的使用也会增加程序的复杂性，不利于维护和调试。

因此，在使用全局变量时需要谨慎考虑。

二、局部变量局部变量是在函数内部定义的变量，它只能在定义它的函数内部使用。

局部变量的作用域仅限于所在的函数，一旦函数执行完毕，局部变量就会被销毁。

局部变量的生命周期取决于函数的调用和返回。

局部变量的作用是在函数内部临时存储数据，仅供该函数使用。

由于局部变量的作用域较小，所以不会被其他函数意外地修改，从而增加了程序的安全性。

此外，局部变量的使用也有助于提高代码的可读性和可维护性。

三、静态变量静态变量是在函数内部或者全局变量外部定义的变量，它与局部变量和全局变量有一些不同之处。

静态变量的作用域仍然是局部的，只能在定义它的函数内部或者全局范围内使用。

但静态变量的生命周期更长，它会在程序的整个运行过程中一直存在。

静态变量的特点是只能被初始化一次，即使函数退出，静态变量的值也会被保留。

这样可以实现在多次调用同一个函数时，静态变量的值可以被保持。

静态变量对于需要记录某些状态或计数的情况非常有用。

四、变量范围的注意事项在使用C语言的变量范围时，需要注意以下几点：1. 变量的命名要具有可读性和表达性，以便于理解和维护代码；2. 避免过多使用全局变量，尽量使用局部变量来实现数据的封装和保护；3. 在使用全局变量时，需要注意对其进行适当的封装和限制访问权限，以避免意外修改；4. 在使用静态变量时，需要注意初始化的时机和值的保持；5. 注意变量的生命周期，合理分配内存资源，避免内存泄漏和访问非法内存的情况。

静态变量和静态方法

静态变量和静态方法静态变量和静态方法是面向对象编程中常用的概念，它们在程序设计中起到了重要的作用。

本文将从静态变量和静态方法的概念、特点、使用方法和注意事项等方面进行详细介绍。

一、静态变量的概念和特点静态变量，也叫类变量，是指在类中以静态修饰符声明的变量。

与普通变量不同的是，静态变量属于类而不属于对象，它在整个程序运行期间只有一份拷贝，被所有对象共享。

静态变量的特点可以总结如下：1.1 生命周期长：静态变量的生命周期与整个程序的运行周期相同，当程序启动时被创建，直到程序结束才被销毁。

1.2 共享性强：静态变量被所有对象所共享，一旦被修改，所有对象都会受到影响。

1.3 存储位置固定：静态变量在内存中的存储位置固定，不会随着对象的创建和销毁而改变。

1.4 初始化一次：静态变量在类加载时进行初始化，只会执行一次。

二、静态变量的使用方法2.1 声明和定义：静态变量的声明和定义与普通变量类似，只需在变量名前加上static关键字即可。

2.2 访问和赋值：可以通过类名加点操作符来访问和赋值静态变量，也可以通过对象名加点操作符来访问静态变量。

2.3 静态变量的访问权限：与普通变量类似，静态变量可以设置不同的访问权限，如public、private、protected等。

三、静态方法的概念和特点静态方法，也叫类方法，是指在类中以静态修饰符声明的方法。

与普通方法不同的是，静态方法不依赖于任何对象，可以直接通过类名调用，它的特点可以总结如下：3.1 不依赖于对象：静态方法在执行时不需要创建对象，可以直接通过类名调用。

3.2 不能访问非静态成员：静态方法只能访问静态成员，不能访问非静态成员，因为非静态成员是依赖于对象的。

3.3 不能使用this和super关键字：静态方法中不能使用this和super关键字，因为它们需要依赖于对象。

3.4 可以重载：静态方法和普通方法一样，可以进行重载，即在同一个类中可以定义多个同名的静态方法，只要它们的参数列表不同即可。

静态成员变量的初始化，vector类型变量初始化

静态成员变量的初始化，vector类型变量初始化　某些情况下，在写C++类的时候，希望能通过⼀个静态初始化函数来对类的⼀些静态成员进⾏初始化。

⽐如，往静态的std::map成员或者std::vector成员⾥添加⼀些固定的内容等。

这在Java⾥通过static块很容易实现。

但在C++⾥该怎么办呢？如果要初始化⼀个普通的静态成员，只需要在实现⽂件（源⽂件）中定义该成员并赋予初始值即可，⽐如：class Test1 {public:static string emptyString;};string Test1::emptyString = "";// also can be// string Test1::emptyString;// string Test1::emptyString(""); 静态函数是不能像这样直接调⽤的。

但是，不妨利⽤⼀下C++初始化普通成员的特点来调⽤静态初始化函数。

当然，这需要定义⼀个额外的静态成员变量来辅助⼀下。

如：class Test2 {public:static vector<string> stringList;private:static bool __init;static bool init() {stringList.push_back("string1");stringList.push_back("string2");stringList.push_back("string3");return true;}};vector<string> Test2::stringList;bool Test2::__init = Test2::init(); 上⾯这个⽰例中初始化成静态成员__init的时候就“顺便”调⽤了静态初始化函数init()，达到预期⽬的。

c语言静态变量static清零

c语言静态变量static清零C语言是一种广泛应用于软件开发的编程语言，而静态变量(static)是C语言中一个重要的概念。

在程序运行过程中，静态变量的值会一直保持到程序结束，并且在每次调用函数时不会重新初始化。

本文将详细介绍C语言中静态变量的特性以及如何清零静态变量的方法。

在C语言中，声明一个静态变量只需要在变量名前加上关键字static。

静态变量与普通的局部变量不同，它的生命周期更长，不会随着函数的调用而释放。

静态变量的一个重要特性是在函数调用时不会重新初始化，即使函数被多次调用，静态变量也只会被初始化一次。

这使得静态变量在多次函数调用中保持了持久性，可以在函数多次调用时共享数据。

要清零静态变量，可以使用赋值操作符将其值设置为0。

在函数内部，可以通过赋值语句将静态变量的值重置为0，从而达到清零的效果。

例如，可以使用以下代码清零一个静态变量：```cvoid resetStaticVariable() {static int count = 0;count = 0; // 清零静态变量}```在上述代码中，函数`resetStaticVariable`中声明了一个静态变量`count`，并将其初始化为0。

然后，通过将`count`赋值为0，即可将静态变量清零。

静态变量的另一个特性是作用域仅限于声明它的函数内部。

这意味着其他函数无法直接访问该静态变量，从而确保了数据的封装性和安全性。

只有声明了静态变量的函数才能对其进行操作和修改。

除了在函数内部使用静态变量，静态变量也可以在全局范围内使用。

在全局范围内声明的静态变量与函数内部的静态变量有所不同。

全局范围的静态变量在整个程序的生命周期内都是可见的，但其作用域仅限于声明它的源文件。

这意味着其他源文件无法直接访问全局范围内的静态变量，从而保证了数据的私密性。

清零全局范围内的静态变量与清零函数内部的静态变量的方法相同，即通过赋值语句将其值设置为0。

例如，可以使用以下代码清零一个全局范围内的静态变量：```cstatic int count = 0; // 全局范围内的静态变量void resetStaticVariable() {count = 0; // 清零全局范围内的静态变量}```在上述代码中，全局范围内的静态变量`count`被初始化为0，然后在函数`resetStaticVariable`中将其赋值为0，实现了清零的效果。

CC++中局部全局变量初始值或默认值问题

CC++中局部全局变量初始值或默认值问题转载⽂章，仅供学习⽤，https://nd/2015/10/05/cpp-variable-init.html在C语⾔中的全局变量和静态变量都是会⾃动初始化为0，堆和栈中的局部变量不会初始化⽽拥有不可预测的值。

C++保证了所有对象与对象成员都会初始化，但其中基本数据类型的初始化还得依赖于构造函数。

下⽂来详细探讨C风格的”默认初始化”⾏为，以及C++中成员变量的初始化规则。

初始化的语法很多⼈⾄今不知道C++中如何正确地初始化⼀个变量，我们⾸先来解决语法的问题。

C语⾔中在声明时⽤=即可完成初始化操作。

但我们偏向于使⽤C++风格（本⽂中均指⾯向对象程序设计风格）来初始化内置类型：// C 风格int i = 3;int arr[] = {1, 2, 3};// C++ 风格int i(3);int i = int(3);int *p = new int(3);int* arr = new int[3] {1, 2, 3};在C语⾔中int a;表⽰声明了整型a但未初始化，⽽C++中的对象总是会被初始化的，⽆论是否写了圆括号或者是否写了参数列表，例如：int basic_var; // 未初始化：应⽤"默认初始化"机制CPerson person; // 初始化：以空的参数列表调⽤构造函数默认初始化规则定义基本数据类型变量（单个值、数组）的同时可以指定初始值，如果未指定C++会去执⾏默认初始化(default-initialization)。

那么什么是”默认初始化”呢？栈中的变量（函数体中的⾃动变量）和堆中的变量（动态内存）会保有不确定的值；全局变量和静态变量（包括局部静态变量）会初始化为零静态和全局变量的初始化所以函数体中的变量定义是这样的规则：//C++中int i; // 不确定值int i = int(); // 0int *p = new int; // 不确定值int *p = new int(); // 0静态和全局变量的初始化未初始化的和初始化为零的静态/全局变量编译器是同样对待的，把它们存储在进程的BSS段（这是全零的⼀段内存空间）中。

局部变量、全局变量、静态变量的含义及存储位置

局部变量、全局变量、静态变量的含义及存储位置1.局部变量在⼀个函数内部定义的变量是内部变量，它只在本函数范围内有效，也就是说只有在本函数内才能使⽤它们，在此函数以外时不能使⽤这些变量的，它们称为局部变量。

局部变量保存在动态数据区的栈中，只有在所在函数被调⽤时才动态地为变量分配存储单元。

1).主函数main中定义的变量也只在主函数中有效.2).不同函数中可以使⽤名字相同的变量，它们代表不同的对象，互不⼲扰.3).形参也是局部变量.4).在复合语句中定义的局部变量，这些变量只在本复合语句中有效.2.全局变量在函数外定义的变量是外部变量，外部变量是全局变量，全局变量可以为本⽂件中其它函数所共⽤，它的有效范围从定义变量的位置开始到本源⽂件结束。

全局变量位于静态数据区中。

1).设全局变量的作⽤：增加了函数间数据联系的渠道.2).建议不再必要的时候不要使⽤全局变量，因为a.全局变量在程序的全部执⾏过程中都占⽤存储单元.b.它使函数的通⽤性降低了3).如果外部变量在⽂件开头定义，则在整个⽂件范围内都可以使⽤该外部变量，如果不再⽂件开头定义，按上⾯规定作⽤范围只限于定义点到⽂件终了.如果在定义点之前的函数想引⽤该外部变量，则应该在该函数中⽤关键字extern作外部变量说明.4).如果在同⼀个源⽂件中，外部变量与局部变量同名，则在局部变量的作⽤范围内，外部变量不起作⽤.3.静态变量静态变量并不是说其就不能改变值，不能改变值的量叫常量。

其拥有的值是可变的，⽽且它会保持最新的值。

说其静态，是因为它不会随着函数的调⽤和退出⽽发⽣变化。

即static局部变量只被初始化⼀次，下⼀次依据上⼀次结果值;静态变量的作⽤范围要看静态变量的位置，如果在函数⾥，则作⽤范围就是这个函数。

静态变量属于静态存储⽅式，其存储空间为内存中的静态数据区（在静态存储区内分配存储单元），该区域中的数据在整个程序的运⾏期间⼀直占⽤这些存储空间（在程序整个运⾏期间都不释放），也可以认为是其内存地址不变，直到整个程序运⾏结束（相反，⽽auto⾃动变量，即动态局部变量，属于动态存储类别，占动态存储空间，函数调⽤结束后即释放）。

C#类变量初始化和局部变量初始化

注意：在C和C++中，未经初始化的变量是不能使用的。

在C#中，系统将为每个未经初始化的变量提供一个默认值。

这虽然一定程度上保证了程序的安全性，但对本应初始化为某个特殊值的变量忘记了初始化，也常常会导致程序的执行误入岐途，所以对变量进行显式的初始化，还是最安全的方法。

对于静态变量、非静态的对象变量和数组变量，这些变量自动初始化为本身的默认值。

对于所有引用类型的变量，默认值为null。

所有值类型的变量的默认值见下表所示：
表12-1 部分类型的域初始化的值
对于struct类型的变量，默认的初始化将对构成该结构的每一个值类型初始化为上表中的默认值，对构成其的每一个引用类型初始化为null。

如果在类中，没有显式地对域进行初始化，系统将赋予其一个默认值。

域的默认初始化分为两种情况：对于静态域，类在装载时对其进行初始化；对于非静态域，在类的实例创建时进行初始化。

在默认的初始化之前，域的值是不可预测的。

比如，下面的代码是合法的：
class Test
{
static int a=b+1;
static int b=a+1;
}
实际上等价于：
a=1,b=2
而下面的代码则是非法的：
class A
{
int x=1;
int y=x+1;
}
因为非静态变量x在类A实例化以前并没有初始化，代码y=x+1无法得到正确的x的值。

局部变量必须初始化，否则编译会出现问题。

静态变量特点

静态变量特点静态变量是指在程序运行过程中，其值不会发生改变的变量。

静态变量在C语言、C++、Java等编程语言中都有应用。

静态变量的特点主要包括作用域、生存期和初始值三个方面。

一、作用域1. 局部作用域在函数内部声明的静态变量具有局部作用域，只能在函数内部访问。

其它函数无法访问该变量。

2. 全局作用域在函数外部声明的静态变量具有全局作用域，可以被程序中任何一个函数所访问。

二、生存期1. 静态局部变量的生存期静态局部变量的生存期与程序运行周期相同，即从程序开始执行到程序结束。

当函数被调用时，该静态局部变量被分配内存空间，并初始化为0或者NULL等默认值。

当函数执行完毕后，该内存空间并不会被释放，而是一直存在于内存中，直到程序结束才会释放。

2. 静态全局变量的生存期静态全局变量与普通全局变量一样，在整个程序运行过程中都存在于内存中。

但是，它们两者之间不同之处在于：普通全局变量可以被其它文件中的函数访问，而静态全局变量只能被定义该变量的文件中的函数访问。

三、初始值1. 静态局部变量的初始值静态局部变量的初始值可以是0或者NULL等默认值，也可以是用户自定义的初值。

如果用户没有为静态局部变量指定初值，则该变量默认为0或者NULL。

2. 静态全局变量的初始值静态全局变量与普通全局变量一样，如果没有初始化，则默认为0或者NULL等默认值。

但是，与普通全局变量不同之处在于：静态全局变量必须在定义时赋初值。

如果没有赋初值，则编译器会报错。

四、总结静态变量具有以下特点：1. 作用域：局部作用域和全局作用域两种。

2. 生存期：从程序开始执行到程序结束。

3. 初始值：可以是0或者NULL等默认值，也可以是用户自定义的初值。

在实际编程中，静态变量经常被用来保存程序中某些数据或状态信息。

它们具有不易被修改、不易被销毁等优点，在某些情况下可以提高程序运行效率和安全性。

C语言变量的初始化

C语⾔变量的初始化1. 全局变量的初始化对于不同编译单位的全局变量，其初始化的顺序没有任何的保证，因此对不同编译单位⾥的全局变量，在它们的初始化顺序之间建⽴依赖性都是不明智的。

此外也没办法捕捉到全局变量初始化抛出的异常，⼀般来说要减少全局变量的使⽤，特别是限制那些要求复杂初始化的全局变量。

1,尽量不⽤全局变量2,⽤静态变量,通过访问器进⾏访问例如：全局变量int a = 5;int b = a;如果a,和b定义在同⼀个⽂件⾥，那没什么问题,结果b等于5．如果a和b定义在不同⽂件⾥，就不能保证b也等于5,也就是说不能保证a先初始化．事实上，除了在同⼀个⽂件定义的全局对象的初始化是按照定义次序来进⾏的之外，其他全局或静态变量之间的初始化次序没有任何保障。

解决这种问题的⽅法是不直接使⽤全局变量，⽽改⽤⼀个包装函数来访问，例如int get_a(){static int a = 5;return a;}int get_b(){static int b = get_a();return b;}这样的话，⽆论get_a和get_b是否定义在同⼀个⽂件中，get_b总是能够返回正确的结果，原因在于，函数内部的静态变量是在第⼀次访问的时候来初始化。

任何时候，如果在不同的被编译单元中定义了"⾮局部静态对象",并且这些对象的正确⾏为依赖于它们被初始化的某⼀特定顺序，就会产⽣问题.你绝对⽆法控制不同被编译单元中⾮局部静态对象的初始化顺序.对于函数中的静态对象（即"局部"静态对象)它们在函数调⽤过程中初次碰到对象的定义时被初始化..注意：千万不要写出和编译顺序相关的程序来。

关于全局变量的初始化，C语⾔和C++是有区别的。

在C语⾔中，只能⽤常数对全局变量进⾏初始化，否则编译器会报错。

在C++中，如果在⼀个⽂件中定义了int a = 5;要在另⼀个⽂件中定义int b = a;的话，前⾯必须对a进⾏声明：extern int a;否则编译不通过.、即使是这样，int b = a;这句话也是分两步进⾏的：在编译阶段，编译器把b当作是未初始化数据⽽将它初始化为0；在执⾏阶段，在main被执⾏前有⼀个全局对象的构造过程， int b = a;被当作是int型对象b的拷贝初始化构造来执⾏。

c语言初始值

c语言初始值在C语言中，变量在声明时可以被赋予初始值。

如果没有为变量提供初始值，那么该变量的初始值将是未定义的，即它可能包含任意的值。

以下是一些关于C语言变量初始化的基本规则：1.局部变量：局部变量是在函数或代码块内部声明的变量。

如果没有显式提供初始值，局部变量的初始值是未定义的。

在C语言中，局部变量的值不会自动初始化，而是取决于存储在该变量所在内存位置上的值。

#include <stdio.h>int main() {int x; // 未定义的初始值printf("%d\n", x); // 输出可能是任意值return 0;}2.全局变量和静态变量：全局变量和静态变量在程序执行前就会被初始化为零 0）。

如果显式提供了初始值，则变量将被初始化为提供的值。

#include <stdio.h>int globalVar; // 全局变量，初始化为零int main() {static int staticVar = 5; // 静态变量，初始化为 5printf("%d\n", globalVar); // 输出 0printf("%d\n", staticVar); // 输出 5return 0;}3.常量变量：声明为`const`的常量变量必须在声明时进行初始化，而且一旦初始化后，其值不能被修改。

#include <stdio.h>int main() {const int constantVar = 10; // 常量变量，必须在声明时初始化printf("%d\n", constantVar); // 输出 10return 0;}总的来说，在C语言中，为变量提供初始值是一种良好的编程实践，以避免使用未定义的值。

在使用变量之前，最好先为其赋一个明确定义的初始值。

c的静态变量

c的静态变量C语言中的静态变量是一种特殊的变量类型，它的生命周期与程序的整个运行周期相同，而不是像普通变量那样只在函数执行期间存在。

静态变量在C语言中有着广泛的应用，可以用来实现全局变量、计数器、缓存等功能。

在C语言中，静态变量的定义方式与普通变量有所不同。

静态变量需要在变量名前加上static关键字，这样编译器就会将其存储在静态数据区中，而不是在栈或堆中。

静态变量的初始化只会在程序运行时进行一次，之后每次调用函数时都会保留上一次的值。

静态变量的作用范围与普通变量也有所不同。

普通变量的作用范围只限于函数内部，而静态变量的作用范围可以是整个程序。

这意味着，静态变量可以在不同的函数之间共享数据，从而实现全局变量的功能。

例如，我们可以定义一个静态变量来记录程序运行的次数： ```int count() {static int num = 0;num++;return num;}```每次调用count函数时，静态变量num的值都会加1，从而实现了计数器的功能。

由于静态变量的作用范围是整个程序，因此即使在不同的函数中调用count函数，num的值也会保持一致。

除了实现全局变量和计数器之外，静态变量还可以用来实现缓存。

例如，我们可以定义一个静态数组来保存之前计算过的结果：```int fib(int n) {static int cache[100] = {0, 1};if (n < 2) {return cache[n];}if (cache[n] == 0) {cache[n] = fib(n-1) + fib(n-2);}return cache[n];}```在这个例子中，静态数组cache用来保存之前计算过的斐波那契数列的结果。

如果需要计算的数已经在cache中存在，就直接返回结果；否则，就递归计算并将结果保存在cache中。

这样可以避免重复计算，提高程序的效率。

静态变量是C语言中非常重要的一个概念，它可以用来实现全局变量、计数器、缓存等功能。

全局变量、成员变量、类变量、静态变量、实例变量、局部变量的定义与区别

全局变量、成员变量、类变量、静态变量、实例变量、局部变量的定义与区别private int i;//实例变量private static int j;//类变量实例变量总是通过对象来访问，因为它们的值在对象和对象之间有所不同。

⽽由static修饰的类变量(静态变量)在类装载的时候就会被初始化,也就是说⼀处修改多处改变.局部变量⽅法内定义的变量叫局部变量，因为只能在⽅法内部使⽤，固不可以⽤private，public，protect来修饰。

{int k;//局部变量}类变量类变量：⼜叫静态变量⽤static修饰它可以直接⽤类名调⽤也可以⽤对象调⽤⽽且所有对象的同⼀个类变量都是共享同⼀块内存空间的.实例变量实例变量：不⽤static修饰它只能通过对象调⽤⽽且所有对象的同⼀个实例变量是共享不同的内存空间的.下⾯是它们之间的思维导图关系。

全局变量和局部变量的区别全局变量：1、成员变量定义在类中，在整个类中都可以被访问。

2、成员变量随着对象的建⽴⽽建⽴，随着对象的消失⽽消失，存在于对象所在的堆内存中。

(实例变量)3、成员变量有默认初始化值。

局部变量：1、局部变量只定义在局部范围内，如：函数内，语句内等，只在所属的区域有效。

2、局部变量存在于栈内存中，作⽤的范围结束，变量空间会⾃动释放。

3、局部变量没有默认初始化值实例变量和类变量的区别1、两个变量的⽣命周期不同实例变量随着对象的创建⽽存在，随着对象的回收⽽释放。

静态变量随着类的加载⽽存在，随着类的消失⽽消失。

2、调⽤⽅式不同实例变量只能被对象调⽤。

静态变量可以被对象调⽤，还可以被类名调⽤。

3、数据存储位置不同实例变量存储在堆内存的对象中，所以也叫对象的特有数据。

静态变量数据存储在⽅法区（共享数据区）的静态区，所以也叫对象的共享数据。

C语言中static变量详解

C语⾔中static变量详解Static翻译出来是“静态”“静⽌”的意思，在C语⾔中的意思其实和它的本意差不多，表⽰“静态”或者“全局”的意思，⽤来修饰变量和函数。

经static修饰过后的变量或者函数的作⽤域或者存储域会发⽣变化，⽽由static修饰的变量在初始值⽅⾯也会表现出static关键字的优势。

想知道经static修饰过后的变量或者函数的作⽤域或者存储域发⽣了什么变化吗，发⽣变化的原因是什么吗？请⼤家继续往下看！⼀、c程序的内存分布既然static是⽤来修饰变量和函数的，⽽变量和函数⼜是组成c程序必不可少的，C程序的内存分布图如下。

C程序由下⾯5部分组成： 1）正⽂段——CPU执⾏的机器指令部分；⼀个程序只有⼀个副本；只读，防⽌程序由于意外事故⽽修改⾃⾝指令； 2）初始化数据段（数据段）——在程序中所有赋了初值的全局变量，存放在这⾥。

3）⾮初始化数据段（bss段）——在程序中没有初始化的全局变量；内核将此段初始化为0。

4）栈——增长⽅向：⾃顶向下增长；⾃动变量以及每次函数调⽤时所需要保存的信息（返回地址；环境信息）。

5）堆——动态存储区。

是向⾼地址扩展的数据类型，是⾃下向上的扩展⽅式。

c程序内存分布图上⾯的C程序分布图很明显的告诉我们，变量是存储在栈区或者堆区或者bss段或者data段，变量的存储域为什么会有所不同呢？其实原因很简单，说⽩了就是与他们定义在程序的不同地⽅，有没有static关键字修饰有关啦，定义在不同的地⽅也说明了他们有着不同的作⽤域。

⼆、static修饰的变量1. 全局静态变量在全局变量之前加上关键字static，全局变量就被定义成为⼀个全局静态变量。

1）内存中的位置：静态存储区（静态存储区在整个程序运⾏期间都存在） 2）初始化：未经初始化的全局静态变量会被程序⾃动初始化为0（⾃动对象的值是任意的，除⾮他被显⽰初始化） 3）作⽤域：全局静态变量在声明他的⽂件之外是不可见的。

c语言局部变量静态局部变量全局变量与静态全局变量

c语⾔局部变量静态局部变量全局变量与静态全局变量基本概念：作⽤域：起作⽤的区域，也就是可以⼯作的范围。

代码块：所谓代码块，就是⽤{}括起来的⼀段代码。

数据段：数据段存的是数，像全局变量就是存在数据段的代码段：存的是程序代码，⼀般是只读的。

栈(stack)：先进后出。

C语⾔中局部变量就分配在栈中。

局部变量普通的局部变量定义的时候直接定义或者在前⾯加上autovoid func1(void){int i = 1;i++;printf("i = %d.\n", i);}局部变量i的解析：在连续三次调⽤func1中，每次调⽤时，在进⼊函数func1后都会创造⼀个新的变量i，并且给它赋初值1，然后i++时加到2，然后printf输出时输出2.然后func1本次调⽤结束，结束时同时杀死本次创造的这个i。

这就是局部变量i的整个⽣命周期。

下次再调⽤该函数func1时，⼜会重新创造⼀个i，经历整个程序运算，最终在函数运⾏完退出时再次被杀死。

静态局部变量(static)静态局部变量定义时前⾯加static关键字。

总结：1、静态局部变量和普通局部变量不同。

静态局部变量也是定义在函数内部的，静态局部变量定义时前⾯要加static关键字来标识，静态局部变量所在的函数在多调⽤多次时，只有第⼀次才经历变量定义和初始化，以后多次在调⽤时不再定义和初始化，⽽是维持之前上⼀次调⽤时执⾏后这个变量的值。

本次接着来使⽤。

2、静态局部变量在第⼀次函数被调⽤时创造并初始化，但在函数退出时它不死亡，⽽是保持其值等待函数下⼀次被调⽤。

下次调⽤时不再重新创造和初始化该变量，⽽是直接⽤上⼀次留下的值为基础来进⾏操作。

3、静态局部变量的这种特性，和全局变量⾮常类似。

它们的相同点是都创造和初始化⼀次，以后调⽤时值保持上次的不变。

不同点在于作⽤域不同全局变量定义在函数外⾯的变量，就叫全局变量。

普通全局变量普通全局变量就是平时使⽤的，定义前不加任何修饰词。

C语言实用中什么是静态变量

c语言中什么是静态变量静态变量是属于静态存储方式，但是属于静态存储方式的量不一定就是静态变量，下面是应届毕业生小编为大家整理的关于c语言中静态变量的介绍，希望可以帮到大家哦。

c语言静态变量的概念定义“静态变量”这一术语有两个容易混淆的定义：语言无关的通用定义：与程序有着相同生命周期(英语：Objectlifetime)的变量;C族语言特有的定义：以存储类声明的变量。

而在以Pascal为代表的许多程序语言中，所有局部变量都由系统自动分配存储空间，而所有全局变量的存储空间则以静态分配的方式获取(对应“静态变量”)，因此由于实际上“局部变量”和“全局变量”这两个术语已足以涵盖所有的情况，在这些程序语言中通常不使用“静态变量”这一术语，而直接以“全局变量”代之。

一般来说，在这些程序语言中，静态变量就是全局变量，而即使在有明确区分全局和静态变量的程序语言中，在编译后的代码里二者也以相同的方式获取存储空间。

而今术语“静态变量”的概念则主要基于C族语言的“static”的定义(即定义2)。

c语言静态变量的常量使用静态变量也可以用于存储常数。

具体来说，静态变量(全局变量及汇编语言里定义的符号亦同)可用const，constant或final(根据语言决定)等关键字标识，这时其值就会在编译时(英语：Compiletime)设定，并且无法在运行时改变。

编译器通常将静态常量与文本一起置于目标文件的文本区域，而非常量初始化数据则置于数据区;而如若有需要，有些编译器还可选择为其开辟专用区;为防止常数变量被错误的指针写入覆盖，亦可在这块区域启用内存保护机制。

c语言静态变量的变量特点静态局部变量静态局部变量属于静态存储方式，它具有以下特点：(1)静态局部变量在函数内定义，但不像自动变量那样，当调用时就存在，退出函数时就消失。

静态局部变量始终存在着，也就是说它的生存期为整个源程序。

(2)静态局部变量的生存期虽然为整个源程序，但是其作用域仍与自动变量相同，即只能在定义该变量的函数内使用该变量。

c语言static int的用法

c语言static int的用法在C语言中，关键字static可以用于声明静态变量。

静态变量是存储在静态存储区的变量，其生命周期从程序开始时创建，直到程序结束时销毁。

静态变量在函数内部声明时，只会被初始化一次，并且在函数调用结束后仍然保持其值。

使用static int的主要目的是限制变量的作用域，并且在多次调用函数时，该变量的值会被保留。

静态变量应该在函数内部进行声明，并且在声明时会被初始化。

静态变量的作用域仅限于声明它的函数内部，其他函数无法直接访问该静态变量。

然而，静态变量在函数调用之间保持其值，这意味着当下一次调用函数时，静态变量将保持之前的值。

下面是一个示例，展示了static int的用法：```c#include <stdio.h>void increment() {static int count = 0; // 静态变量count声明和初始化count++;printf("Count: %d\n", count);}int main() {increment(); // 输出：Count: 1increment(); // 输出：Count: 2increment(); // 输出：Count: 3return 0;}```在上述示例中，我们声明了一个名为count的静态变量，并在increment函数内部初始化为0。

每次调用increment函数时，count递增，并输出递增后的值。

由于count是静态变量，因此它保持在函数调用之间的值，在每次调用increment函数时保留。

总结起来，使用static int的用法可以使变量的作用域限制在声明它的函数内部，并保持变量的值在函数调用之间的保留。

这在某些情况下是非常有用的，特别是在需要跟踪某些值的变化时。

C++static、const和staticconst类型成员变量声明以及初始化菜鸟教程

C++static、const和staticconst类型成员变量声明以及初始化菜鸟教程const 定义的常量在超出其作用域之后其空间会被释放，而 static 定义的静态常量在函数执行后不会释放其存储空间。

static 表示的是静态的。

类的静态成员函数、静态成员变量是和类相关的，而不是和类的具体对象相关的。

即使没有具体对象，也能调用类的静态成员函数和成员变量。

一般类的静态函数几乎就是一个全局函数，只不过它的作用域限于包含它的文件中。

在 C++ 中，static 静态成员变量不能在类的内部初始化。

在类的内部只是声明，定义必须在类定义体的外部，通常在类的实现文件中初始化，如：double Account::Rate = 2.25;static 关键字只能用于类定义体内部的声明中，定义时不能标示为static。

在 C++ 中，const 成员变量也不能在类定义处初始化，只能通过构造函数初始化列表进行，并且必须有构造函数。

const 数据成员只在某个对象生存期内是常量，而对于整个类而言却是可变的。

因为类可以创建多个对象，不同的对象其const 数据成员的值可以不同。

所以不能在类的声明中初始化const 数据成员，因为类的对象没被创建时，编译器不知道const 数据成员的值是什么。

const 数据成员的初始化只能在类的构造函数的初始化列表中进行。

要想建立在整个类中都恒定的常量，应该用类中的枚举常量来实现，或者static cosnt。

class Test{ public: Test():a(0){} enum {size1=100,size2=200}; private: const int a;//只能在构造函数初始化列表中初始化 static int b;//在类的实现文件中定义并初始化conststatic int c;//与static const int c;相同。

}; int Test::b=0;//static成员变量不能在构造函数初始化列表中初始化，因为它不属于某个对象。

static静态局部变量初始化问题

static静态局部变量初始化问题第⼀次写博客之类的东西，主要是为了记录⾃⼰的学习过程，以便于记忆的加深和与各位⼤神进⾏探讨，学习更多的东西。

本次上传主要是关于静态局部变量的初始化问题。

⾸先，静态局部变量和全局变量⼀样，数据都存放在全局区域，所以在主程序之前，编译器已经为其分配好了内存，但在C和C++中静态局部变量的初始化节点⼜有点不太⼀样。

在C中，初始化发⽣在代码执⾏之前，编译阶段分配好内存之后，就会进⾏初始化，所以我们看到在C语⾔中⽆法使⽤变量对静态局部变量进⾏初始化，在程序运⾏结束，变量所处的全局内存会被全部回收。

⽽在C++中，初始化时在执⾏相关代码时才会进⾏初始化，主要是由于C++引⼊对象后，要进⾏初始化必须执⾏相应构造函数和析构函数，在构造函数或析构函数中经常会需要进⾏某些程序中需要进⾏的特定操作，并⾮简单地分配内存。

所以C++标准定为全局或静态对象是有⾸次⽤到时才会进⾏构造，并通过atexit()来管理。

在程序结束，按照构造顺序反⽅向进⾏逐个析构。

所以在C++中是可以使⽤变量对静态局部变量进⾏初始化的。

后⾯再来谈谈另⼀个问题，假如我们在⼀个循环中，定义了⼀个静态局部变量并进⾏初始化，循环过程中，编译器怎么知道当前的静态局部变量已经初始化过了呢？这个问题C和C++的处理⽅式也是不⼀样的。

C中编译器会直接跳过这⼀个语句，因为在编译的时候已经对静态局部变量进⾏过分配空间并初始化，所以代码执⾏过程中根本不需要再次执⾏。

⽽在C++中，编译器会在编译器分配内存后，在全局区域（当前静态局部变量的地址）附近同样分配⼀块空间，进⾏记录变量是否已经进⾏过初始化。

之所以说附近是根据编译器不同，处理⽅式不同导致的。

在⽹上有博客介绍某种编译器（该吧主并没有透露编译器名字），会在当前变量后⾯的⼀个字节进⾏改变，具体上代码：(Ps:若编译器已经发现当前变量初始化，则直接将整⾏代码跳过，若等式后⾯为n++，则不会继续执⾏++命令)从地址内存中我们可以看到在变量地址的后⾯⼀个字节中，有⼀个01⽤来记载当前静态变量是否初始化。

C++类的静态成员变量一定要初始化（分配内存）

C++类的静态成员变量⼀定要初始化（分配内存）⽂章转载⾃我们知道C++类的静态成员变量是需要初始化的，但为什么要初始化呢。

其实这句话“静态成员变量是需要初始化的”是有⼀定问题的，应该说“静态成员变量需要定义”才是准确的，⽽不是初始化。

两者的区别在于：初始化是赋⼀个初始值，⽽定义是分配内存。

静态成员变量在类中仅仅是声明，没有定义，所以要在类的外⾯定义，实际上是给静态成员变量分配内存。

可以通过以下⼏个例⼦更形象的说明这个问题：//test.cpp#include <stdio.h>class A {public:static int a; //声明但未定义，还未分配内存};int main() {printf("%d", A::a);return0;}编译以上代码会出现“对‘A::a’未定义的引⽤”错误。

这是因为静态成员变量a未定义，也就是还没有分配内存，显然是不可以访问的。

再看如下例⼦：//test.cpp#include <stdio.h>class A {public:static int a; //声明但未定义};int A::a = 3; //定义了静态成员变量，同时初始化。

也可以写"int A:a;"，即不给初值，同样可以通过编译int main() {printf("%d", A::a);return0;}这样就对了，因为给a分配了内存，所以可以访问静态成员变量a了。

因为类中的静态成员变量仅仅是声明，暂时不需分配内存，所以我们甚⾄可以这样写代码：//a.cppclass B; //这⾥我们使⽤前置声明，完全不知道B是什么样⼦class A {public:static B bb;//声明了⼀个类型为B的静态成员，在这⾥编译器并未给bb分配内存。

//因为仅仅是声明bb,所以编译器并不需要知道B是什么样⼦以及要给其对应的对象分配多⼤的空间。

C#静态变量总结

C#静态变量总结在C#程序中，没有全局变量的概念，这意味着所有的成员变量只有该类的实例才能操作这些数据，这起到了“信息隐藏”的作⽤。

但有些时候，这样做却不是个明智的选择。

假设我们要定义⼀个图书类，要求该类能保存图书的数量，即每增加⼀本图书（定义⼀个实例），图书的数量应该加1。

如果没有静态变量，我们需要将图书的数量保存在每本图书（实例）⾥，然⽽，这样的变量要在不同图书（实例）⾥重复存储，图书（实例）数量少的话，我们还能接受，如果图书（实例）数量较多的话，⽐如成千上万，我们⽆法想象这要造成多少资源（如内存、磁盘空间）的浪费，更让⼈⽆法忍受的是：因为图书（实例）的数量要保存在每本图书（实例）⾥，该值肯定是不同的。

要使这些图书（实例）中保存的图书（实例）数量⼀致，我们必须在每增加⼀本新书（⽣成⼀个新实例）时，修改其他所有图书（实例）中保存的该值。

Oh,My God!你会重新向往⾯向过程的程序设计⽅法，向往拥有全局变量的时代。

但，这种局⾯不会出现，因为C#中为你准备好了另外⼀种变量类型：静态变量。

它在类中类似全局变量，保存类的公共信息，所有该类的实例（对象）共享该值。

声明静态变量的语法如下：<访问修饰符>static 数据类型变量名;这⾥的访问修饰符跟类的其它成员⼀样，可以是public,protected,private或internal等。

在普通的成员变量前加static关键字，就变成了静态变量。

静态变量和实例变量存储⽅式不同，静态变量在声明开始，就⼀直存储在内存中，直到整个程序终⽌。

⽽实例成员在创建对象时分配内存，并存储⼀个数据副本。

所以静态成员变量认为是属于类的，⽽不是对象。

静态变量与实例变量的区别如下：1.内存分配静态变量在应⽤程序初始化时，就存在于内存当中,直到它所在的类的程序运⾏结束时才消亡；⽽实例变量需要被实例化后才会分配内存。

2.⽣存周期静态变量⽣存周期为应⽤程序的存在周期；实例变量的存在周期取决于实例化的类的存在周期。