静态变量静态函数

合集下载

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()。

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关键字用于定义静态局部变量、静态全局变量和静态函数，它们的值在程序生命周期内保持不变，且具有特定的初始化方式和调用限制。

c++的static关键字用法

c++的static关键字用法C++中的`static`关键字有多种用法，在不同的场景下都有着不同的含义和作用。

本文将详细介绍C++中`static`关键字的用法及其相关特性，希望能对读者更好地理解和运用这个关键字。

一、`static`关键字概述`static`是C++中的一个关键字，它常用于指定函数、变量、类成员等的作用域和生命周期。

它的主要作用如下：1. 限定变量的作用域。

使用`static`关键字声明的变量具有静态的生存期和块作用域，即在整个程序运行期间都存在，并且只能在声明变量的源文件中访问。

2. 限定函数的作用域。

使用`static`关键字声明的函数具有静态的作用域，即只能在声明它的源文件中调用。

3. 限定类成员的作用域。

使用`static`关键字声明的类成员为静态成员，它不属于类的任何一个对象，而是属于整个类，可以通过类名或类对象来访问。

4. 防止符号重定义。

当在多个源文件中定义同名的全局变量或函数时，使用`static`关键字可以防止它们之间的符号重定义错误。

二、静态变量1. 全局静态变量使用`static`关键字声明的全局变量具有静态生存期和文件作用域，即它在程序运行期间一直存在，而且只能在声明它的源文件中访问。

例如：```cpp//file1.cpp#include <iostream>static int count = 10; //声明全局静态变量countvoid func() {static int i = 5; //局部静态变量i，生命周期为整个程序运行期间std::cout << "i is " <extern int count; //声明全局变量countvoid func2() {std::cout << "count is " << count << std::endl;}```编译器会报错：undefined reference to `count'。

C++类中的静态成员变量和静态成员函数的作用

数据成员可以分静态变量、非静态变量两种.静态成员：静态类中的成员加入static修饰符,即是静态成员.可以直接使用类名+静态成员名访问此静态成员,因为静态成员存在于内存,非静态成员需要实例化才会分配内存,所以静态成员不能访问非静态的成员..因为静态成员存在于内存,所以非静态成员可以直接访问类中静态的成员.非成静态员：所有没有加Static的成员都是非静态成员,当类被实例化之后,可以通过实例化的类名进行访问..非静态成员的生存期决定于该类的生存期..而静态成员则不存在生存期的概念,因为静态成员始终驻留在内容中..一个类中也可以包含静态成员和非静态成员,类中也包括静态构造函数和非静态构造函数..分两个方面来总结，第一方面主要是相对于面向过程而言，即在这方面不涉及到类，第二方面相对于面向对象而言，主要说明static在类中的作用。

一、在面向过程设计中的static关键字1、静态全局变量定义：在全局变量前，加上关键字static 该变量就被定义成为了一个静态全局变量。

特点：A、该变量在全局数据区分配内存。

B、初始化：如果不显式初始化，那么将被隐式初始化为0(自动变量是随机的,除非显式地初始化)。

C、访变量只在本源文件可见，严格的讲应该为定义之处开始到本文件结束。

例〔摘于C++程序设计教程---钱能主编P103〕：//file1.cpp//Example 1#include <iostream.h>void fn();static int n; //定义静态全局变量void main(){n=20;cout < <n < <endl;fn();}void fn(){n++;cout < <n < <endl;}D、文件作用域下声明的const的常量默认为static存储类型。

静态变量都在全局数据区分配内存，包括后面将要提到的静态局部变量。

对于一个完整的程序，在内存中的分布情况如以下图：代码区全局数据区堆区栈区一般程序的由new产生的动态数据存放在堆区，函数内部的自动变量存放在栈区。

C语言静态变量和静态函数

C语言静态变量和静态函数问题虽然是C语言中的静态变量，其实说起来在其他很多的编程语言中，静态变量的意义和用法都和C语言中差不多，所以搞懂了这个概念在以后学习其他的编程语言的时候是很有作用的。

我们就来说说C语言中的静态变量是什么样的一种，静态变量在它们自己的函数或者是文件中是永久的变量，说起来，静态变量很像是全局变量，但是他们之间是有差别的，静态变量在函数或者是文件中是不被知道的，他们在两次调用之间将保存自己的值，比如说，假如一个静态变量的值是1，在第一次调用静态变量之后，将他的值变为2，那么在我们第二次调用它的时候，它的值依然是2，而不会去初始化它，将它的值又看作是1。

Ex:c语言 static静态变量#include iostream.hint p(int x){static int y=1;y=y+1;return (x+y);}int main(){cout<<p(1)<<endl;cout<<p(2)<<endl;}答案是3和5，为什么不是3和4呢？c语言的static变量是在程序加载的时候就为之分配内存的，一直到程序结束，而不像普通变量那样函数执行一次分配一次。

所以当第一次执行p（1）的时候，y已经加1了，下次执行p（2）时，y不会恢复成1，还是2；你就当全局变量的功能处理就行，性能上有区别-----------------------------------------------------------------------------------------------------------------------以下是基础知识点-----------------------------------------------------------------------------------------------------------------------1. static 变量静态变量的类型说明符是static。

函数里面定义的static变量

函数中的静态变量特定函数在C++中，静态变量是一种与特定函数关联的变量类型，它与普通变量不同的是，静态变量的存储位置在程序的生命周期内保持不变，即使在函数调用结束后也不会销毁。

静态变量还具有特定函数的作用域，只在特定函数内部可见，并且不同的函数之间的静态变量是相互独立的。

我们可以使用static关键字来定义静态变量。

1. 静态变量的定义在函数内部使用static关键字定义的变量被称为静态变量。

语法格式如下：return_type function_name(parameters) {static variable_type variable_name;// 函数体}其中，function_name是函数的名称，parameters是函数的参数列表，return_type 是函数的返回类型，variable_type是静态变量的数据类型，variable_name是静态变量的名称。

例如，下面的示例代码定义了一个名为countCalls的函数，其中使用了静态变量count：#include <iostream>void countCalls() {static int count = 0;count++;std::cout << "This function has been called " << count << " times." << st d::endl;}int main() {countCalls();countCalls();countCalls();return 0;}输出结果为：This function has been called 1 times.This function has been called 2 times.This function has been called 3 times.2. 静态变量的特点和用途静态变量具有以下几个特点：2.1 存储位置固定静态变量的存储位置在程序的生命周期内保持不变。

static在c++语言中的用法

static在c++语言中的用法static是C++中的一个关键字，用于定义静态变量和静态函数。

静态变量和普通变量的区别在于，静态变量存储在数据区，生命周期与整个程序运行时间相同，在程序运行时只会被初始化一次。

而普通变量在程序运行时会被重复初始化和销毁，生命周期与函数调用时间相同。

1. 静态变量静态变量可以声明在函数体内和类内部。

当静态变量声明在函数体内时，该变量只在此函数中可见，即使此函数被多次调用，静态变量只会被初始化一次。

当静态变量声明在类内部时，它属于整个类，不需要通过对象来访问，可以直接通过类名+范围解析符（::）来访问。

如：静态变量在类内部的声明可以用于实现单例模式。

如下代码实现了只能创建一个MyClass对象的单例模式：2. 静态函数静态函数的另一个用途是实现工厂模式。

当我们需要创建一些对象并且它们的类型在编译时不能确定时，可以使用工厂模式来创建这些对象。

静态函数可以作为工厂函数，用于创建对象的实例。

如下代码：3. 静态成员变量和静态函数的限制1. 静态成员变量需要在类外部进行初始化。

即使不进行初始化，编译器也会为它自动赋值为0。

2. 静态成员变量的访问权限可以是public、protected或private。

3. 静态成员变量可以在类声明中提供初值，如`static int myStaticVar = 0;`。

4. 静态函数不能声明为const，因为const只能用于成员函数，而静态函数没有对象，无法成为成员函数。

5. 静态函数可以被继承，但不能被override（覆盖），因为静态函数与类名绑定在一起，无法被子类的同名函数所覆盖。

但是，如果子类中声明一个与父类中静态函数同名的静态函数，它并不会覆盖父类中的静态函数，而是在子类中新增一个同名函数。

6. 静态函数不能访问非静态的成员函数和变量。

如果需要访问非静态成员，必须通过对象来调用成员函数。

但是，由于静态函数没有对象，无法调用非静态成员函数。

c语言中static int的作用和用法

c语言中static int的作用和用法（原创版）目录1.static 关键字的作用2.static int 的用法3.static int 的作用4.示例代码正文一、static 关键字的作用在 C 语言中，static 关键字可以用来修饰变量和函数，它的作用主要体现在以下几个方面：1.静态变量：使用 static 修饰的变量被称为静态变量。

静态变量的生命周期和程序一样长，即在整个程序运行时间都存在。

在函数内部定义的静态变量，在函数调用结束后不会被销毁，而是保留其值，以便下一次函数调用时可以继续使用。

2.静态函数：使用 static 修饰的函数被称为静态函数。

静态函数只能在定义它的源文件中使用，不能被其他源文件中的函数调用。

静态函数的作用是限制函数的作用域，避免与其他源文件中的函数发生命名冲突。

二、static int 的用法static int 主要用于定义静态整型变量。

静态整型变量的生命周期和程序一样长，即在整个程序运行时间都存在。

在函数内部定义的静态整型变量，在函数调用结束后不会被销毁，而是保留其值，以便下一次函数调用时可以继续使用。

三、static int 的作用static int 主要用于保存程序运行过程中的一些全局变量或静态变量的值。

由于 static int 的值在程序运行过程中不会被重新初始化，因此可以利用它来保存一些需要长期保存的数据。

四、示例代码下面是一个使用 static int 的示例代码：```c#include <stdio.h>static int k = 0;void fun() {k++;printf("k = %d", k);}int main() {fun();fun();fun();printf("k = %d", k);return 0;}```在这个示例代码中，我们定义了一个静态整型变量 k，并在 fun 函数中对 k 进行自增操作。

JS中类的静态方法，静态变量，实例方法，实例变量区别与用法实例分析

JS中类的静态⽅法，静态变量，实例⽅法，实例变量区别与⽤法实例分析本⽂实例讲述了JS中类的静态⽅法，静态变量，实例⽅法，实例变量区别与⽤法。

分享给⼤家供⼤家参考，具体如下：1.类的静态⽅法先来段代码之后分析// JS类静态函数function BaseClass() {}// 类添加add函数BaseClass.add = function() {console.log("BaseClass add()⽅法被调⽤");};// 类⽅法(类的静态函数)直接调⽤// 类名.类⽅法名BaseClass.add(); //BaseClass add()⽅法被调⽤var instance = new BaseClass();// 实例不能调⽤类⽅法(即类的静态⽅法)//instance.add();a.类的静态⽅法通过[类名.类⽅法名称]赋值；b.调⽤时⽤[类名.类⽅法名称()]直接调⽤；C.类的实例⽆法调⽤类的静态函数。

原因：因在js中function也是对象，即给函数对象添加了⼀个函数2.类的静态成员先来段代码之后分析// JS类的静态成员变量function BaseClass(params) {}// 类添加静态变量nameTestTest = "jadeshu";// 类的静态变量直接调⽤// 类名.类变量名console.log(Test); // jadeshuvar instance = new BaseClass();// 实例不能调⽤类的静态成员变量)console.log(Test); // undefineda.类的静态变量通过[类名.类变量名称]赋值；b.调⽤时⽤[类名.类变量名称]直接调⽤；C.类的实例调⽤类的静态变量为undefined。

-----原因：因在js中function也是对象，即给函数对象添加了⼀个属性3.实例⽅法(两种情况)I.单个实例的⽅法// JS的单个实例⽅法function BaseClass() {}var instance1 = new BaseClass();// 单个实例添加成员⽅法instance1.add = function (params) {console.log("BaseClass类实例的add⽅法被调⽤" + params);};instance1.add(11222); // BaseClass类实例的add⽅法被调⽤11222var instance2 = new BaseClass();//instance2.add(); // Error: instance2.add is not a functionII.所有实例创建时都创建了同名的⽅法// JS所有实例的共享⽅法function BaseClass() {// 所有实例创建时都创建了同名的⽅法this.add = function (params) {console.log("BaseClass类实例的add⽅法被调⽤" + params);};}var instance1 = new BaseClass();instance1.add(11); // BaseClass类实例的add⽅法被调⽤11var instance2 = new BaseClass();//实例1和实例2各有⼀个add函数的本地⽅法instance2.add(22); // BaseClass类实例的add⽅法被调⽤22console.log(instance1.add === instance2.add); // false⽅法也是每个实例各存在⼀个，占⽤内存，这既没有必要，⼜浪费系统资源，所以不建议这样添加实例的本地⽅法，或者在外部定义函数，然后直接赋给⼀个变量即可，就可以做到所有创建的实例都引⽤⼀份代码，但这样做代码不优雅。

static静态变量和静态代码块的执行顺序

static静态变量和静态代码块的执⾏顺序众所周知在android中static 修饰的会被称之为静态常量，静态变量，静态⽅法，还有就是静态代码块，⽤static{ // 代码块⾮static修饰的⽅法，变量，常量，是不能再静态代码块中使⽤的 } 表⽰。

static修饰的是跟着类⾛的，⽽不是跟随对象，这个⼤家都是知道的。

那么⼤家是否知道它们之间的运⾏顺序的关系呢？今天，我就给⼤家简单讲解⼀下吧。

静态常量，静态变量，静态⽅法，⼤家都知道是通过类名直接调⽤的（例如：Demo.getStatic() ）。

但是静态代码块⼤家都没有主动调⽤过对吧。

那它到底什么时候被执⾏呢？让我来揭晓吧，其实只要你的代码在任意地⽅，动⽤了静态代码块所属的类中的任意东西，那么该静态代码块就会马上执⾏（说⽩了就是静态代码块是这个类最先执⾏的代码，但前提是你要使⽤这个类，不使⽤的话，这个类中的静态代码块是不会执⾏的与静态变量相⽐就是看代码编写的前后顺序，和静态⽅法有很⼤的区别）。

当⼀个类中有多个静态代码块的时候，是按照代码编写的上下顺序先后执⾏的。

静态代码块与静态变量之间的关系：如果你想正确使⽤两者的话，个⼈建议你必须把静态变量定义在静态代码块的前⾯，因为两个的执⾏是会根据代码编写的顺序来决定的。

这个⽐较难理解，我来举个例⼦吧，情况下⾯代码：public class Demo{public static int i;static{i = 20;//这⾥的i，是可以被⽤作运算的。

}}这时候如果你在main函数输出i，那么i=20；public class Demo{static{i = 20;//这⾥的i，是不能被⽤作运算的，因为本质上 i 还未被定义}public static int i;}这时候如果你在main函数输出i，那么i=20；public class Demo{static{i = 20;//这⾥的i，是不能被⽤作运算的，因为本质上 i 还未被定义}public static int i = 1;}//但是如果我们给静态的i附上⼀个初始值后，那么结果就变了。

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

全局变量、成员变量、类变量、静态变量、实例变量、局部变量的定义与区别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用法C语言中的static关键字用法在C语言中，static是一个非常重要的关键字。

它可以应用于不同的上下文，具有不同的功能。

下面将逐一介绍几种常见的static用法。

1. 静态变量:在函数内部，使用static关键字声明的变量被称为静态变量。

与普通的局部变量不同，静态变量在程序运行期间只分配一次内存，即使函数执行结束后仍然保留其值。

静态变量存储在全局数据区，具有全局生存周期和局部作用域。

这使得静态变量在多次调用函数时能够保留之前的值。

2. 静态函数:使用static关键字声明的函数被称为静态函数。

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

静态函数的作用是限制函数的作用域，防止与其他文件中的同名函数冲突，也增加了代码的安全性。

3. 静态全局变量:在函数外部、全局作用域中使用static关键字声明的变量被称为静态全局变量。

与普通全局变量相比，静态全局变量只能在声明它的源文件中访问，其他源文件无法使用extern关键字引用它。

因此，静态全局变量的作用域仅限于当前源文件，避免了不必要的全局命名冲突。

4. 静态成员变量:在面向对象的程序设计中，使用static关键字声明的类成员变量被称为静态成员变量。

与普通的成员变量不同，静态成员变量属于整个类，而不是类的实例。

这意味着即使创建多个类的实例，静态成员变量的内存空间也只分配一次。

静态成员变量可以通过类名直接访问，无需通过对象来引用。

总结：通过以上介绍，我们可以看到static关键字在C语言中具有多种用法。

它可用于声明静态变量、静态函数、静态全局变量以及静态成员变量。

static的使用能够有效地控制变量和函数的作用域，增加程序的安全性和可读性。

熟练掌握static的用法对于写出高效、可靠的C语言程序非常重要。

PHPstatic静态变量和函数方法

PHPstatic静态变量和函数方法变量范围的另一个重要特性是静态变量（static variable）。

静态变量仅在局部函数域中存在，但当程序执行离开此作用域时，其值并不丢失。

看看下面的例子：例子演示需要静态变量的例子function test(){$a = 0;echo $a;$a++;}本函数没什么用处，因为每次调用时都会将 $a 的值设为 0 并输出"0"。

将变量加一的$a++ 没有作用，因为一旦退出本函数则变量$a 就不存在了。

要写一个不会丢失本次计数值的计数函数，要将变量$a 定义为静态的：例子使用静态变量的例子function Test(){static $a =0;echo$a;$a++;}Test(); //调用 0Test(); //调用 1现在，每次调用 Test() 函数都会输出 $a 的值并加一。

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

递归函数是一种调用自己的函数。

写递归函数时要小心，因为可能会无穷递归下去。

必须确保有充分的方法来中止递归。

一下这个简单的函数递归计数到10，使用静态变量 $count 来判断何时停止：例子静态变量与递归函functionTest(){static $count =0;$count++;echo$count;if ($count< 10) {Test();}$count--;}注: 静态变量可以按照上面的例子声明。

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

例子声明静态变量functionfoo(){static $int =0;// correctstatic $int =1+2; // wrong (asit is an expression_r)static $int =sqrt(121); // wrong (as it is an expression_r too)$int++;echo $int;}Class Person{//定义静态成员属性publicstatic $country = "中国";//定义静态成员方法publicstatic function myCountry() {// 内部访问静态成员属性echo "我是".self::$country."人";}}class Student extends Person {functionstudy() {echo "我是". parent::$country."人";}}// 输出成员属性值echo Person::$country.""; // 输出：中国$p1 = new Person();//echo$p1->country; //错误写法// 访问静态成员方法Person::myCountry(); //输出：我是中国人// 静态方法也可通过对象访问：$p1->myCountry();// 子类中输出成员属性值echo Student::$country.""; //输出：中国外部访问静态成员属性和方法$t1 = new Student(); //生成对象$t1->study(); // 输出：我是中国人小结在类内部访问静态成员属性或者方法，使用self::（注意不是$slef），如：代码如下slef:: $countryslef:: myCountry()在子类访问父类静态成员属性或方法，使用parent::（注意不是$parent），如：代码如下parent:: $countryparent:: myCountry()外部访问静态成员属性和方法为类名/子类名:: ，如：代码如下Person::$countryPerson::myCountry()Student::$country但静态方法也可以通过普通对象的方式访问。

C#静态变量及静态函数

C#静态变量及静态函数静态变量使⽤ static 修饰符进⾏声明，在类被实例化时创建，通过类进⾏访问不带有 static 修饰符声明的变量称做⾮静态变量。

static变量在对象被实例化时创建，通过对象进⾏访问⼀个类的所有实例的同⼀C#静态变量都是同⼀个值，同⼀个类的不同实例的同⼀⾮静态变量可以是不同的值。

静态函数的实现⾥不能使⽤⾮静态成员，如⾮静态变量、⾮静态函数等。

class StaticTest{static int x = 0;int y = 0;public void SetX(int a){x = a;}public void SetY(int a){y = a;}public void Print(){Console.WriteLine("x = {0} y = {1}", x, y);}static void Main(string[] args){StaticTest st = new StaticTest();StaticTest st1 = new StaticTest();st.SetX(10); //将10赋给x；st.SetY(10); //将10赋给y；st.Print(); //显⽰：x=10 y=10st1.SetX(20); //将20赋给xst1.SetY(20); //将20赋给xst1.Print(); //显⽰：x=20 y=20st.Print(); //由于x是静态变量，所以在此调⽤第⼀次初始化实例st时，静态变量已经变为20，输出：x=20 y=10st.SetX(30); st.SetY(30); st.Print(); //由于x是静态变量，所以在此调⽤初始化实例st时，静态变量已经变为30，输出：x=30 y=30st1.Print(); //由于x是静态变量，所以在此调⽤st1实例时，静态变量已经变为30，输出：x=30 y=20}}静态类：声明为static，它仅包含静态成员，不能⽤new静态类的实例。

静态变量和静态函数

静态变量和静态函数
静态变量和静态函数是C++中非常有用的概念。

静态变量是在程序运行期间始终保持其值不变的变量，而静态函数则是在整个程序中共享的函数。

这两个概念常常被使用在类和结构体中。

静态变量的声明使用关键字“static”，其在声明时会分配一次内存，而在程序生命周期内一直存在。

在函数内部声明的静态变量，它们的值会一直保持不变，直到下一次调用该函数。

静态变量还可以用于在函数调用之间保留状态信息，例如计算函数的平均值或记录函数调用次数。

静态函数的声明同样使用关键字“static”，其通常用于在类或结构体中创建一些全局函数。

这些函数不会被绑定到特定的对象上，而是可以在整个程序中被调用，从而方便共享和重用。

静态函数通常用于实现一些通用的算法或共享一些数据。

总之，静态变量和静态函数是C++中非常重要的概念。

它们可以帮助我们保留状态信息和共享数据和算法，从而提高程序的效率和可维护性。

- 1 -。

java之静态函数和静态变量

java之静态函数和静态变量静态变量：
静态变量好似⼀种成员变量，它的特点是前⾯有static。

普通变量会有多份，它在每个对象当中都存在，但是静态变量只有⼀份，它是属于类的。

静态变量的调⽤⽅法：
1.类名.变量名
= "中南⼤学"
2.对象名.类名
= "中南⼤学"第⼆种更加的常见
普通变量静态变量
类名.访问不可以可以
对象名.访问可以可以
静态成员函数：
在成员函数前加上static
1.静态成员函数能被类名.成员变量和对象名.静态成员变量。

2.静态成员函数只能够调⽤静态成员变量，不能访问普通变量。

发明静态函数的⽬的：操作静态变量，执⾏⼀些和特定对象⽆关的内容
静态变量普通变量
静态函数可以不可以
普通函数可以可以——————————————————————————————————————————-。

PHP中的静态变量及static静态变量使用详解

PHP中的静态变量及static静态变量使⽤详解静态变量只存在于函数作⽤域内，也就是说，静态变量只存活在栈中。

⼀般的函数内变量在函数结束后会释放，⽐如局部变量，但是静态变量却不会。

就是说，下次再调⽤这个函数的时候，该变量的值会保留下来。

只要在变量前加上关键字static，该变量就成为静态变量了。

<?phpfunction test(){static $nm = ;$nm = $nm * ;print $nm." ";}// 第⼀次执⾏，$nm =test();// 第⼀次执⾏，$nm =test();// 第⼀次执⾏，$nm =test();>程序运⾏结果：122438函数test()执⾏后，变量$nm的值都保存了下来了。

在class中经常使⽤到静态属性，⽐如静态成员、静态⽅法。

Program List：类的静态成员静态变量$nm属于类nowamagic，⽽不属于类的某个实例。

这个变量对所有实例都有效。

::是作⽤域限定操作符，这⾥⽤的是self作⽤域，⽽不是$this作⽤域，$this作⽤域只表⽰类的当前实例，self::表⽰的是类本⾝。

<?phpclass nowamagic{public static $nm = ;function nmMethod(){self::$nm += ;echo self::$nm . ' ';}}$nmInstance = new nowamagic();$nmInstance -> nmMethod();$nmInstance = new nowamagic();$nmInstance -> nmMethod();>程序运⾏结果：1325Program List：静态属性<?phpclass NowaMagic{public static $nm = '';public function nmMethod()return self::$nm;}}class Article extends NowaMagic{public function articleMethod(){return parent::$nm;}}// 通过作⽤于限定操作符访问静态变量print NowaMagic::$nm . " ";// 调⽤类的⽅法$nowamagic = new NowaMagic();print $nowamagic->nmMethod() . " ";print Article::$nm . " ";$nmArticle = new Article();print $nmArticle->nmMethod() . " ";>程序运⾏结果：Program List：简单的静态构造器PHP没有静态构造器，你可能需要初始化静态类，有⼀个很简单的⽅法，在类定义后⾯直接调⽤类的Demonstration()⽅法。

C#类中静态变量静态构造函数执行顺序

C#类中静态变量静态构造函数执⾏顺序我们常常在⽹上看到说我们类中如果有静态变量和静态构造函数，那么先执⾏静态变量，然后静态函数。

但是为什么呢？真的是这样吗？例⼦代码：public class BaseClass{public static int s1 = 10;static BaseClass(){s1 = 11;}}static void Main(string[] args){BaseClass.s1 = 5;}我们定义⼀个类并调⽤：我们都知道s1结果是 5;单点调试时第⼀步：BaseClass.s1 = 5;第⼆步： public static int s1 = 10;第三步： s1 = 11;这样看说先执⾏先执⾏静态变量，然后静态函数好像也没问题。

我们通过IL⾔语发现其实不然：.method private hidebysig specialname rtspecialname staticvoid .cctor() cil managed{// 代码⼤⼩ 16 (0x10).maxstack 8IL_0000: ldc.i4.s 10IL_0002: stsfld int32 ConsoleAppTest.BaseClass::s1IL_0007: nopIL_0008: ldc.i4.s 11IL_000a: stsfld int32 ConsoleAppTest.BaseClass::s1IL_000f: ret} // end of method BaseClass::.cctor发现了什么，构造函数中把对 s1 = 10;的赋值放到了构造函数中。

总结：运⾏时s1分配内存空间并赋默认值，然后执⾏构造函数，但是构造函数中静态变量的赋值是有顺序的。

先赋值10再11。

Matlab中的静态（持久）变量和全局变量

Matlab中的静态（持久）变量和全局变量1、静态变量（persistent）在函数中声明的变量，当函数调⽤完之后就会释放。

如果想保留这个变量的值（供该函数下⼀次调⽤），可以把这个变量声明为静态变量。

静态变量不能在声明的时候赋值，⽽且只能在function⾥声明,且只有这个function才能认识它（main函数也不⾏）。

x声明后是[],就是⼀个空的array。

声明后需初始化，注意不能直接⽤persistent x=2;⽽是⽤isempty(x)判断x是否已经赋值。

如：1 function y=test()2 persistent x;3if isempty(x)4 x=0;5 endmatlab可以在function⾥声明静态变量，⽅法：1 persistent x;注意它只能在function⾥声明,且只有这个function才能认识它。