静态变量static的用法

合集下载

static在c中的用法

static在C中的用法在C语言中，static是一个关键字，用于修饰变量、函数和块作用域。

它可以改变它所修饰实体的生命周期、作用域和可见性。

本文将介绍static关键字在C语言中的多种用法。

1. 静态变量使用static关键字修饰的变量被称为静态变量（Static Variables）。

静态变量具有以下特点：•静态变量存储在静态数据区，不随函数调用结束而销毁；•静态变量的作用域局限于定义它的代码块；•静态变量只能被初始化一次，在整个程序运行期间保持其值。

下面是一个示例，展示了静态变量的使用：#include <stdio.h>void increment() {static int count = 0; // 静态变量countcount++;printf("Count: %d\n", count);}int main() {increment(); // 输出：Count: 1increment(); // 输出：Count: 2increment(); // 输出：Count: 3return 0;}在上述示例中，函数increment()内部定义了一个静态变量count。

每次调用该函数时，count会自增，并输出当前值。

由于静态变量的生命周期不受函数调用的影响，所以每次调用increment()时，count的值都会被保留。

2. 静态函数使用static关键字修饰的函数被称为静态函数（Static Functions）。

静态函数具有以下特点：•静态函数只在定义它的源文件中可见，不能被其他源文件调用；•静态函数不能被其他源文件通过函数指针调用；•静态函数不会与其他源文件中同名的全局函数产生冲突。

下面是一个示例，展示了静态函数的使用：#include <stdio.h>static void printMessage() {printf("This is a static function.\n");}int main() {printMessage(); // 正常调用静态函数return 0;}在上述示例中，我们定义了一个静态函数printMessage()。

static在c语言中用法

static在c语言中用法static在C语言中的用法C语言是一种广泛应用于系统级编程的编程语言，因其简洁、高效的特点而被广泛采用。

其中，static是C语言中的一个关键字，具有多种用法和功能。

本文将逐步介绍static关键字在C语言中的不同用法和作用。

1. 静态变量static关键字可以用于声明静态变量。

静态变量与普通变量的不同之处在于，它们的生存周期会持续到整个程序的执行过程中，而不仅限于函数调用期间。

在函数内部使用static关键字声明的变量，其值会在函数调用结束后依然保持，下次函数调用时仍然可用。

以下是一个示例：c#include <stdio.h>void increment() {static int counter = 0;counter++;printf("Counter: d\n", counter);}int main() {increment();increment();increment();return 0;}运行结果将会输出：Counter: 1Counter: 2Counter: 3可以看到，每次调用increment函数时，静态变量counter的值都会保持，并在下次调用时继续递增。

2. 静态函数static关键字还可以用于声明静态函数。

静态函数与普通函数的区别在于，静态函数仅在声明它的源文件中可见，无法被其他源文件所调用。

这种封装的特性使得静态函数在模块化编程中起到了一定的作用。

以下是一个示例：c文件1：test1.c#include <stdio.h>static void static_function() {printf("This is a static function.\n");}void normal_function() {printf("This is a normal function.\n");}文件2：test2.cvoid normal_function();int main() {static_function(); 错误，static_function无法被该源文件所调用normal_function(); 正确，normal_function是全局函数return 0;}在上述示例中，test1.c声明了一个静态函数static_function()和一个全局函数normal_function()，而test2.c只能调用全局函数normal_function()，而无法调用静态函数static_function()。

c语言的static用法

c语言的static用法在C语言中，static关键字主要用于修饰局部变量、全局变量和函数。

以下是static在不同场景下的用法：1. 静态局部变量：静态局部变量是在函数内部定义的变量，使用static修饰。

在声明时，编译器会把它初始化为0。

与普通局部变量相比，静态局部变量的生命周期更长，它位于进程的全局数据区，即使函数返回，它的值也会保持不变。

示例：```c#include <stdio.h>void test(){static int a = 1; // 初始化为1printf("a = %d\n", a);}int main(){while (1){test();}return 0;}```2. 静态全局变量：静态全局变量定义在函数体外部，使用static修饰。

它位于进程的全局数据区，初始化为0。

静态全局变量在声明后，其值不会因为函数的调用而改变。

示例：```c#include <stdio.h>static int global_var = 0;void test(){global_var = 1; // 允许修改静态全局变量的值printf("global_var = %d\n", global_var);}int main(){test();return 0;}```3. 静态函数：静态函数是用static修饰的函数。

静态函数在程序内部只能被调用一次，即在程序生命周期内只能被初始化一次。

静态函数可以在任何地方定义，但在其他地方不能被直接调用。

示例：```c#include <stdio.h>static void static_func(){printf("This is a static function.\n");}void test(){static_func(); // 正确调用静态函数printf("Test function.\n");}int main(){test();return 0;}```总之，C语言中的static关键字用于定义静态局部变量、静态全局变量和静态函数，它们的值在程序生命周期内保持不变，且具有特定的初始化方式和调用限制。

static用法

static用法
static 是 C 语言和 C++ 语言中的一种修饰符，用它修饰的变量或者函数就具有一定的特性，它有以下几种用法：
1. static 修饰全局变量：全局变量被声明为 static 类型后，就只能在声明它的文件里使用，其它文件里不能使用它。

2. static 修饰局部变量：在函数体内，声明变量为 static 类型的话，就变成了静态变量，其值会一直保存，直到程序结束才会释放，但是它的作用域(可以访问的范围)仍然为定义它的函数内部。

3. static 修饰函数：函数被声明为静态的意思是它仅能在本文件中被调用，函数被声明为静态，可以节省空间，不会放入到全局表中去。

4. static 修饰类成员：声明类成员变量为 static 类型，意味着每一个该类对象都会共用一个公共的变量。

总而言之，static 可以将变量和函数的作用域范围限定在声明它们的文件中，减少各个文件之间的调用，使程序更有效率。

static变量用法

static变量用法
static变量用法：
1. 在类中定义的静态变量是与类本身紧密相关的变量，被所有该类的实例对象所共享。

无论创建多少该类的对象，静态变量只有一份拷贝。

2. 静态变量可以被类的所有方法访问，包括静态方法和非静态方法。

它属于类，在类被加载时就存在，无需创建对象就可以使用。

3. 静态变量的值可以被类的任何对象改变，一次改变，所有对象都会受到影响。

4. 静态变量可以通过类名来引用，也可以通过对象名来引用，但建议使用类名引用。

5. 静态变量的生命周期与类相同，在类被卸载时消失。

6. 静态变量通常用于存储与类相关的常量，如π、版本号等。

7. 静态变量一般使用public或private修饰符，public修饰符可以被其他类直接访问，private修饰符只能在类内部访问。

8. 静态变量可以用final修饰，表示常量，一旦赋值就不能改变，一般命名时使用全大写。

9. 静态变量可以不被初始化，默认值为0或null，具体取决于变量类型。

10. 静态变量可以有多个实例，每个实例的值不互相影响，仅仅在该类的所有实例中共享。

c语言的static用法

c语言的static用法在C语言中，static是一个非常重要的关键字，它可以用于变量或者函数的声明中，起到了不同于其他关键字的作用。

下面将探讨C语言中static的用法。

一、静态变量的声明与使用静态变量是在程序执行期间一直存在的变量，它的作用范围仅限于当前的函数或者文件。

在C语言中，我们可以通过在变量声明前加上static关键字来定义静态变量。

例如，我们想在一个函数中统计该函数被调用的次数，可以声明一个静态变量来实现：```cvoid function() {static int count = 0; // 静态变量count的初始值为0count++; // 每次调用函数，count加1printf("函数被调用了%d次\n", count);}```在上面的代码中，count是一个静态变量，它在函数每次被调用时都会保留上一次调用后的值。

如果count是一个普通的局部变量，每次函数调用完毕后都会被销毁，无法实现计数的功能。

静态变量的作用域仅限于当前函数或者文件，也就是说，如果在其他函数或者文件中声明相同名字的静态变量，它们不会相互影响。

二、静态函数的声明与使用与静态变量类似，我们还可以使用static关键字来声明静态函数。

静态函数只能在声明的文件中使用，不能被其他文件调用。

例如，我们有两个文件file1.c和file2.c，其中file1.c中定义了一个静态函数，file2.c中想调用这个函数是无效的。

file1.c：```cstatic void static_function() {printf("这是一个静态函数\n");}```file2.c：```c#include <stdio.h>int main() {static_function(); // 错误，无法调用file1.c中的静态函数return 0;}```静态函数可以保证函数的私有性，避免其他文件对该函数的访问和使用。

static的用法

static的用法
静态是指一个变量或函数在编译时就已经唯一确定，不允许再改变。

它是静止的，不能改变，并且可以在程序的任何地方被访问。

二、静态变量的使用
1.局静态变量
全局静态变量是指在程序的全局作用域（从程序的任何地方都可以使用）定义的静态变量。

例如，可以在程序的任何文件中定义一个全局静态变量 int counter，以便在应用程序的其他部分引用它，用于跟踪某个活动的次数。

2.局部静态变量
局部静态变量是指在函数内定义的静态变量。

它只在函数内可见，在函数调用结束后不会被释放，但只在函数内可以访问。

例如，可以在函数内定义一个静态变量 static int count，以便在函数调用后
依然能够访问它，以跟踪函数调用次数。

三、静态函数的使用
在一般常见的编程语言中，一个函数可以被声明为 static，使
得在整个程序中只有在该文件中的函数才能调用这个函数。

在同一文件中，static函数的调用可以省略 static键字，但在跨文件调用时将会报错，因为编译器无法在其他文件中找到这个函数。

总结：
静态（Static）是指一个变量或函数在编译时就已经唯一确定，不允许再改变。

它可以应用在全局静态变量和局部静态变量上，以及
静态函数上。

全局静态变量是指在程序的全局作用域定义的变量，局部静态变量是指在函数内定义的变量，静态函数则是在该文件中的函数可以调用的函数。

static 用法

static 用法static 用法1. static 变量•定义：在函数内部使用 static 关键字声明的变量称为静态变量。

•特点：–静态变量的生命周期在整个程序运行期间都存在，而不仅仅在函数调用时才存在。

–静态变量存储在静态存储区，不会在函数调用结束后释放内存。

•使用场景：–如果一个变量需要在多次函数调用之间保持其值不变，可以使用静态变量。

–静态变量通常用于计数器或者保存函数的返回值等场景。

•示例代码：#include <>int count() {static int counter = 0;counter++;return counter;}int main() {printf("%d\n", count()); // 输出1printf("%d\n", count()); // 输出2printf("%d\n", count()); // 输出3return 0;}2. static 函数•定义：在函数返回类型前面加上 static 关键字，使函数变为静态函数。

•特点：–静态函数只能在声明它的源文件内部调用，不能被其他源文件使用。

–静态函数不能被其他源文件中的函数调用，从而起到了隐藏的作用。

•使用场景：–当某个函数只在当前源文件内部使用时，可以将其声明为静态函数，以减少命名冲突和提高代码的模块化程度。

•示例代码：#include <>static int multiply(int a, int b) {return a * b;}int main() {int result = multiply(2, 3);printf("%d\n", result); // 输出6return 0;}3. static 类成员•定义：在类中声明的 static 成员属于类本身，而不是类的实例。

•特点：–所有的对象共享同一个静态成员，即静态成员对于所有的对象来说只有一份拷贝。

static的用法c语言

static的用法c语言
在C语言中，关键字static有多种用法和含义。

以下是一些常见的用法：
1. 声明静态变量：在函数内部使用static关键字声明的变量是静态变量。

静态变量与普通的局部变量不同，它们的生命周期延长到整个程序的执行期间，而不是在函数执行完毕后被销毁。

此外，静态变量的作用域仅限于声明的函数内部。

2. 声明静态全局变量：在函数外部使用static关键字声明的变量是静态全局变量。

静态全局变量与普通的全局变量不同，它们的作用域仅限于声明的源文件内，不能被其他源文件访问。

3. 声明静态函数：使用static关键字声明的函数是静态函数。

静态函数的作用域仅限于声明的源文件内，不能被其他源文件调用。

通常将不需要在其他文件中使用的函数声明为静态函数，以避免与其他文件中的函数命名冲突。

4. 限定函数的访问权限：在结构体或类中，使用static关键字可以限定函数的访问权限。

声明为static的函数只能在同一源文件中的其他函数调用，不能通过结构体或类的对象或指针访问。

5. 限定外部链接的变量：在声明全局变量时使用static关键字，可以将变量的链接属性变为内部链接，即只能在当前源文件中使用，其他源文件无法访问该变量。

需要注意的是，static关键字的具体用法和效果可能有所依赖于编译器和环境的差异。

因此，在具体开发项目中，应该深入了解并遵循所使用的编译器的规范和行为。

static的三种用法

static的三种用法`static` 是C、C++、Java、C# 等编程语言中的关键字，在不同的语境中具有不同的用法。

以下是`static` 的三种主要用法：1. 静态变量（Static Variables）：-在函数内部或在类中，使用`static` 关键字声明的变量称为静态变量。

静态变量的生命周期贯穿整个程序运行期间，而不仅仅是在声明它的作用域内。

-在C 语言中，静态变量在函数内的示例：```cvoid myFunction() {static int counter = 0; // 静态变量counter++;printf("Counter: %d\n", counter);}```-在C++ 类中，静态成员变量属于类而不是类的实例：```cppclass MyClass {public:static int staticVariable; // 静态成员变量};int MyClass::staticVariable = 0; // 静态成员变量的初始化int main() {MyClass::staticVariable++;return 0;}```2. 静态函数（Static Functions）：-在C 和C++ 中，使用`static` 关键字声明的函数成为静态函数。

静态函数只能在声明它的文件中访问，不能被其他文件调用。

-在C 中：```c// 在同一文件中声明和定义静态函数static void myStaticFunction() {printf("This is a static function.\n");}```-在C++ 中：```cpp// 在类中声明静态函数class MyClass {public:static void staticFunction() {printf("This is a static function.\n");}};int main() {MyClass::staticFunction();return 0;}```3. 静态类成员（Static Class Members）：-在C# 和Java 中，使用`static` 关键字声明的成员属于类而不是类的实例。

静态变量static的用法

静态变量static的用法在程序编写过程中，我们经常会遇到一些需要在多个函数间共享数据的情况，这时候我们可以使用全局变量来实现。

但是全局变量具有全局的作用域，容易造成命名冲突等问题，为了避免这些问题，我们可以使用静态变量。

静态变量是定义在函数或者文件的顶部的变量，并在程序运行时进行初始化并存在内存中。

静态变量具有以下特点：1. 静态变量只被初始化一次。

在第一次调用函数时，静态变量被初始化为0或者NULL，然后在后续的函数调用中，静态变量的值会被保留。

2. 静态变量的作用域仅限于定义它的函数内部。

虽然静态变量被存储在全局存储区，但是只能通过定义它的函数来访问它。

3. 静态变量的存储位置在全局数据区。

全局数据区是程序在运行期间分配的一块内存空间，存储静态变量和全局变量。

4. 静态变量默认被初始化为0或者NULL。

如果需要给静态变量赋初值，可以在定义时进行赋值操作。

下面我们来看一些静态变量的用法。

1. 静态局部变量在函数内部定义的静态变量称为静态局部变量。

静态局部变量和普通局部变量的区别在于，它只被初始化一次，在后续函数调用中保留其值。

下面是一个简单的例子：```c#include <stdio.h>int sum(int num) {static int sum = 0; // 定义静态局部变量sumsum += num; // 对sum进行累加操作return sum;}在上面的代码中，我们定义了一个静态局部变量sum来存储运行时的累加结果。

在每次调用sum函数时，都会对静态变量sum进行累加操作。

由于静态变量只会被初始化一次，因此在后续的函数调用中，sum保留了之前的值。

在文件的顶部定义的静态变量称为静态全局变量。

与普通全局变量相比，静态全局变量只能在定义它的文件中被访问。

这样就避免了命名冲突等问题。

下面是一个例子：static int num = 5; // 定义静态全局变量num3. 静态函数在函数定义的时候，加上static关键字，可以将这个函数变为静态函数，也称为内部函数。

static 的用法描述

static 的用法描述"Static" 是一个在编程领域中常用的术语，其用法可以取决于编程语言和上下文。

以下是一些常见的用法描述：1. 静态变量(Static Variables):-在函数内部声明的变量，但其生命周期超出了函数的执行。

即使函数执行完毕，静态变量的值仍然会保持，直到程序结束。

-在C和C++中，使用`static` 关键字声明静态变量。

在Java中，可以使用`static` 关键字声明静态成员变量。

```cvoid exampleFunction() {static int staticVar = 0;// staticVar 在函数调用之间保持其值staticVar++;}```2. 静态方法(Static Methods):-在类中使用`static` 关键字声明的方法。

这样的方法属于类而不是类的实例，可以直接通过类名调用，而不需要创建类的对象。

-在Java和C++等语言中，静态方法不能直接访问非静态成员，因为它们没有隐含的this 指针。

```javapublic class ExampleClass {static void staticMethod() {// 静态方法的实现}}```3. 静态类(Static Class):-在某些语言中，可以使用`static` 关键字声明静态类。

这表示该类不能被实例化，通常包含静态成员和方法。

-例如，C# 中的静态类：```csharpstatic class StaticExample {public static void StaticMethod() {// 静态方法的实现}}```4. 静态块(Static Block):-在一些语言中，可以使用`static` 关键字创建静态块，这是在类加载时执行的一些代码块。

在Java中，静态块用于初始化静态成员。

```javapublic class ExampleClass {static {// 静态块的代码}}```5. 静态导入(Static Import):-在Java中，使用`import static` 语句可以导入类的静态成员，使得可以直接使用静态成员而无需使用类名引用。

c语言static静态变量的用法

c语言static静态变量的用法
C 语言中的 static 关键字可以用于静态变量的声明，它可以改变变量的生命周期和作用域。

静态变量在程序运行期间只会被初始化一次，它们会一直存在于内存中直到程序结束。

首先，static 可以用于函数内部的局部变量。

当一个变量被声明为 static 时，它的生命周期会延长到整个程序的执行期间，而不是仅在函数被调用时存在。

这意味着即使函数执行结束，该变量的值也会被保留，下次调用该函数时，该变量的值仍然有效。

其次，static 也可以用于全局变量。

当一个全局变量被声明为static 时，它的作用域会被限制在声明它的文件内，其他文件无法访问该变量。

这样可以避免在其他文件中意外修改该变量的值，增强了代码的安全性和可维护性。

另外，static 还可以用于函数的声明。

当一个函数被声明为static 时，它的作用域也会被限制在声明它的文件内，其他文件无法调用这个函数。

这样可以避免函数被其他文件意外调用，提高了代码的封装性和安全性。

总的来说，C 语言中的 static 关键字可以用于静态变量的声明，可以改变变量的生命周期和作用域，增强了代码的安全性和可维护性。

通过合理使用 static 关键字，可以更好地控制变量和函数的作用范围，提高程序的可靠性和可移植性。

c语言static关键字的用法

C语言static关键字的用法1.概述在C语言中，st at ic关键字是一种用来修饰变量和函数的关键字。

它可以改变变量和函数的作用域和生命周期，并具有一些特殊的用法和效果。

本文将详细介绍C语言中st at ic关键字的用法和注意事项。

2.静态变量2.1定义静态变量在C语言中，st at ic关键字可以用来定义静态变量。

静态变量在程序运行期间保持其值不变，且作用域限制在定义它的函数内部。

通过使用s t at ic关键字，可以在每次函数调用时保持变量的值。

2.2静态变量的初始化和作用域静态变量的初始化只会在第一次定义时进行，之后的调用不会再次初始化。

静态变量的作用域局限于定义它的函数内部，可以在函数内部的任何地方使用，并且可以在函数调用结束后仍然保持其值。

2.3静态变量与全局变量的区别静态变量与全局变量类似，但是它们的作用域不同。

全局变量的作用域是整个程序，而静态变量的作用域局限于定义它的函数内部。

另外，全局变量在定义它的文件外也可以被访问，而静态变量只能在定义它的函数内部被访问。

3.静态函数3.1定义静态函数与静态变量类似，st a ti c关键字也可以用来定义静态函数。

静态函数的作用域限制在当前文件内部，其他文件无法访问。

3.2静态函数的优势使用静态函数可以避免与其他文件中的同名函数产生冲突。

此外，静态函数还可以提高程序的安全性，因为它们只能在当前文件内被调用。

3.3静态函数与全局函数的区别静态函数与全局函数类似，但是它们的作用域不同。

全局函数可以在其他文件中被访问和调用，而静态函数只能在当前文件内部被调用。

4.静态变量和静态函数的应用场景4.1限制作用域静态变量和静态函数可以将其作用域限制在当前文件内部，避免命名冲突和不必要的访问。

这在大型程序中尤为重要，可以提高代码的可读性和可维护性。

4.2保持变量值使用静态变量可以在函数调用之间保持变量的值，方便处理需要记忆状态的情况，如递归计算、迭代等。

static静态变量用法

static静态变量用法在 C++ 和许多其他编程语言中，`static` 关键字用于创建静态变量。

静态变量的特点是其生命周期与程序运行周期相同，并且在内存中只有一份副本，无论创建了多少个类实例或函数调用。

在 C++ 中，`static` 关键字可以应用于以下几个地方：1. 静态成员变量（类变量）：class MyClass {public:static int count; // 声明静态成员变量MyClass() {count++; // 每次创建对象实例时，静态变量 count 递增}};int MyClass::count = 0; // 初始化静态成员变量int main() {MyClass obj1;MyClass obj2;// 此时 MyClass::count 的值为 2return 0;}静态成员变量在类的所有对象之间共享，并且可以通过类名访问（例如 `MyClass::count`）。

2. 静态局部变量：void myFunction() {static int localVar = 0; // 声明静态局部变量localVar++; // 静态局部变量在函数调用之间保持其值}静态局部变量在函数中只初始化一次，在函数调用之间保持其值不变。

3. 静态成员函数：class MyClass {public:static void myStaticFunction() {// 静态成员函数可以直接访问静态成员变量，但不能访问非静态成员变量// 例如：this->nonStaticMember; // 错误，无法访问非静态成员变量}};静态成员函数可以直接通过类名调用，它们无法访问非静态成员变量，因为没有隐式的 `this` 指针传递。

总结：- 静态变量在其声明的作用域内保持其值。

- 静态成员变量被类的所有对象所共享。

- 静态成员函数不依赖于任何特定的对象，可通过类名直接调用。

python static变量的用法

一、python static变量的定义在python中，可以使用关键字static来定义静态变量。

静态变量是指在类中定义的变量，它的值对所有实例都是共享的。

二、python static变量的作用静态变量的作用是在类中保存一些共享的数据，可以在类的所有实例中使用。

它可以用来保存一些不会因实例的不同而改变的数据，如常数、配置信息等。

三、python static变量的使用方法在python中，可以通过以下方法来定义和使用静态变量：1. 在类中直接定义静态变量class MyClass:static_var = 10这样定义的静态变量可以直接通过类名访问，也可以通过实例名访问。

2. 使用staticmethod装饰器class MyClass:staticmethoddef static_method():print("This is a static method")通过staticmethod装饰器定义的静态方法可以在类的所有实例中共享。

3. 使用类方法class MyClass:classmethoddef class_method(cls):cls.static_var = 20通过类方法来修改静态变量的值。

四、python static变量的注意事项在使用静态变量时需要注意一些事项：1. 静态变量的值对所有实例都是共享的，所以如果一个实例修改了静态变量的值，会影响到其他实例。

2. 静态变量的值是在类加载时就已经存在的，所以在访问静态变量时不需要先创建实例。

3. 静态变量的命名通常使用大写字母，并且在类外部访问时可以通过类名.静态变量名来访问。

五、python static变量的实际应用静态变量在实际应用中有着广泛的用途，例如：1. 保存一些固定的配置信息，如数据库连接字符串、日志级别等。

2. 计数器，统计某个类的实例个数。

3. 常数，如圆周率、自然对数等。

六、结语静态变量是python中一个重要的概念，它可以为我们在类中共享一些数据提供了便利。

c语言中的static的用法

c语言中的static的用法在C语言中，static关键字有以下几种用法：1. 静态局部变量：在函数内部声明的变量前加上static关键字，使该变量在函数调用结束后仍然保持原有的值。

静态局部变量只会被初始化一次，并且仅在声明它的函数中可见。

cvoid function() {static int count = 0;count++;printf("count: %d\n", count);}int main() {function(); 输出count: 1function(); 输出count: 2function(); 输出count: 3return 0;}2. 静态全局变量：在函数外部声明的变量前加上static关键字，使该变量仅在声明它的文件内可见。

静态全局变量只会被初始化一次，并且在整个程序运行期间保持其值。

cfile1.cstatic int count = 0;void function1() {count++;printf("count in function1: %d\n", count);}file2.cextern void function1();int main() {function1(); 输出count in function1: 1function1(); 输出count in function1: 2return 0;}3. 静态函数：在函数声明前加上static关键字，使该函数只在当前文件内可见，不能被其他文件调用。

cfile1.cstatic void function1() {printf("This is a static function.\n");}file2.cextern void function1();int main() {function1(); 编译错误：undefined reference to `function1'return 0;}4. 静态参数：在函数声明时，加上static关键字，表示该函数的参数在函数调用期间将一直保持不变。

static的用法

static的⽤法static，意为静态的，是⼀个状态修饰符。

1.修饰变量static修饰的变量称为静态变量，可以使⽤类名.变量名直接调⽤，并且该变量只存在⼀份，被所有的实例共享。

（1）类名.变量名调⽤静态变量：例：package com.dh.oop;public class StaticField {public static int num = 1;}package com.dh.oop;public class StaticFieldApplication {public static void main(String[] args) {//类名调⽤System.out.println(StaticField.num);}}（2）静态变量只存在⼀份，被所有的实例共享：例：package com.dh.oop;public class StaticField {public static int num = 1;}package com.dh.oop;public class StaticFieldApplication {public static void main(String[] args) {//实例化两个变量，并分别为num赋值StaticField staticField1 = new StaticField();staticField1.num = 2;StaticField staticField2 = new StaticField();staticField2.num = 3;System.out.println(staticField1.num);System.out.println(staticField2.num);}}通过以上代码，若所有实例共享⼀份静态变量的话，输出的值应该都为3，否则，为2，3可以看到，结果为两个3，由此可证，所有实例共享⼀份静态变量。

2.修饰⽅法被static修饰的⽅法称为静态⽅法。

php中static静态变量的使用方法详解

php中static静态变量的使⽤⽅法详解php中的变量作⽤范围的另⼀个重要特性就是静态变量（static 变量）。

静态变量仅在局部函数域中存在且只被初始化⼀次,当程序执⾏离开此作⽤域时，其值不会消失,会使⽤上次执⾏的结果。

看看下⾯的实例：复制代码代码如下:<?phpfunction Test(){$w3sky = 0;echo $w3sky;$w3sky++;}>本函数每次调⽤时都会将 $w3sky 的值设为 0 并输出 "0"。

将变量加⼀的 $w3sky++ 没有其到效果，因为⼀旦退出本函数则变量 $w3sky 就不存在了。

要写⼀个不会丢失本次计数值的计数函数，要将变量 $w3sky 定义为静态(static)的：如下:复制代码代码如下:<?phpfunction Test(){static $w3sky = 0;echo $w3sky;$w3sky++;}>本函数每调⽤Test()都会输出 $w3sky 的值并加⼀。

静态变量也提供了⼀种处理递归函数的⽅法。

递归函数是⼀种⾃⼰调⽤⾃⼰的⽅法。

写递归函数时要⼩⼼，因为可能会⽆穷递归下去,没有出⼝.务必确保有⽅法来中⽌递归。

以下这个简单的函数递归计数到 10，使⽤静态变量 $count 来判断何时停⽌：静态变量与递归函数的例⼦:复制代码代码如下:<?PHPfunction Test(){static $count = 0;$count++;echo $count;if ($count < 10) {Test();}$count--;}>注: 静态变量可以按照上⾯的例⼦声明。

如果在声明中⽤表达式的结果对其赋值会导致解析错误。

声明静态变量例⼦:复制代码代码如下:<?PHPfunction foo(){static $int = 0;// correctstatic $int = 1+2; // wrong (as it is an expression)static $int = sqrt(121); // wrong (as it is an expression too)$int++;echo $int;}>。