精华内容
下载资源
问答
  • 问题描述:学习static定义静态变量的用法。 程序源码: #include"stdio.h" varfunc() { int var=0; static int static_var=0; printf("\40:var equal %d \n",var); printf("\40:static ...

    问题描述:学习static定义静态变量的用法。

    程序源码:

    #include"stdio.h"
    varfunc()
    {
    int var=0;
    static int static_var=0;
    printf("\40:var equal %d \n",var);
    printf("\40:static var equal %d \n",static_var);
    printf("\n");
    var++;
    static_var++;
    }
    void main()
    {int i;
     for(i=0;i<3;i++)
      varfunc();
    }

     

    展开全文
  • 例题:学习static定义静态变量的用法。 代码如下: #include"stdio.h" void varfunc() { int var=0;//定义一个变量var static int static_var=0;//定义一个变量static_var printf("var =%d \n",var); printf(...

    例题:学习static定义静态变量的用法。

    代码如下:

    #include"stdio.h"
    void varfunc()
    {
    	int var=0;//定义一个变量var
    	static int static_var=0;//定义一个变量static_var
    	printf("var =%d \n",var);
    	printf("static var =%d \n",static_var);
    	printf("\n");
    	var++;
    	static_var++;
    }
    void main()
    {
    	int i;
    	for(i=0;i<3;i++)
    	varfunc();
    }
    

    输出运行窗口如下:
    在这里插入图片描述
    本周其他练习

    C语言程序设计专栏

    C语言编程>第四周 ① 学习static定义静态变量的用法。

    C语言编程>第四周 ② 学习使用static的另一用法。

    C语言编程>第四周 ③ 学习使用auto定义变量的用法。

    C语言编程>第四周 ④ 学习使用external的用法。

    C语言编程>第四周 ⑤ 学习使用register定义变量的方法。

    C语言编程>第四周 ⑥ 利用#define命令求一个数的平方。

    C语言编程>第四周 ⑦ 用fillellipse画椭圆。

    C语言编程>第四周 ⑧ 从键盘输入一个字符,判断它是否为数字。

    越努力越幸运!
    加油,奥力给!!!

    展开全文
  • static定义静态变量的使用方式

    千次阅读 2018-08-16 16:00:14
    static定义静态变量用的,在程序执行中他只会被初始化一次。 比如程序运行过程中a的值被改变后,又执行到static int a=1,这句,此时这句将不会被执行,a不会第二次被初始化。 如果是动态变量,int a=1,此时a...

    static 是定义静态变量用的,在程序执行中他只会被初始化一次。

    比如程序运行过程中a的值被改变后,又执行到static int a=1,这句,此时这句将不会被执行,a不会第二次被初始化。

    如果是动态变量,int a=1,此时a便会被重新赋值为1

    #include <stdio.h>
    int fun(int *p){
    	static int t=0;
    	t=*p+t;
    	return t;
    }
    int main(void){
    	int a[5]={1,3,5,7,9},i,m;
    	for(i=0;i<5;i++){
    		m=fun(a+i);
    		printf("%4d",m);
    	}
    	printf("\n");
    	return 0;
    }

     

    展开全文
  • 本文实例讲述了C#中static静态变量的用法。分享给大家供大家参考。具体如下: 使用 static 修饰符声明属于类型本身而不是属于特定对象的静态成员static修饰符可用于类、字段、方法、属性、运算符、事件和构造函数,...
  • static的三种用法,定义静态变量,静态函数,静态代码块!
    static的三种用法,定义静态变量,静态函数,静态代码块!
    1、定义静态变量
    class PersonStatic
    {
    //静态变量的特点
    //1.静态变量无需生成对象就可被调用,可以使用类名和对象两种方法调用
    //2.静态变量是全局变量
    //3.任何一个对象修改静态变量的值,那么所有的该类的对象的静态成员变量的值都改变
    static int i;
    String name;

    2、静态函数
    //静态函数的特点
    //1.静态函数无需生成对象就可被调用
    //2.静态函数不能直接调用非静态的成员变量
    //3.不能使用this引用
    static void fun()
    {
    System.out.println("我是静态函数,我的i值为 " + i);
    }
    /*static void talk()
    {
    System.out.println("My name is " + name);//此时会出错
    }*/ 

    3、静态代码块
    //静态代码块
    //静态代码块在装载类的时候就被执行,主要为静态成员变量赋初值
    static{
    System.out.println("我是静态代码块");
    }

    }


    /******************************************************************************************************************************/

    数据成员可以分为静态变量、非静态变量两种。

    (1)静态成员:静态类中的成员加入static修饰符,即是静态成员,可以使用类名+静态成员名访问此静态成员,因为静态成员存在于内存,非静态成员需要实例化才会分配内存,所以 静态成员不能访问非静态成员,因为静态成员存在于内存,所以非静态成员可以直接访问类中的静态成员。

    (2)非静态成员:所以没有加static的成员都是非静态成员,当类被实例化后,可以通过实例化的类名进行访问,非静态成员的生存期决定于该类的生存期,而静态成员则不存在生存期的概念,因为静态成员始终驻留在内存中。

    一个类中可以包含静态成员和非静态成员,类中也包括静态构造函数和非静态构造函数。

    以下分两方面来说,第一方面主要是相对于面向过程而言,在这方面不涉及类;另一方面相对于面向对象来说,主要说明static在类中的作用。

    一、在面向过程设计中的static关键字

    1、静态全局变量

    定义:在全局变量前加上关键字static,该变量就被定义成一个静态全局变量。

    特点:

             A 、该变量在全局数据区分配内存

             B、初始化:如果不显式初始化,那么将被饮食初始化为0(自动变量是随机的,除非是显式初始化)

             C、该变量只在本源文件可见,严格地讲,应该从定义之处开始到本文件结束。

    Example 1

    [cpp]  view plain  copy
    1. #include <iostream>  
    2.   
    3. using namespace std;  
    4.   
    5. void fun();  
    6.   
    7. static int n;  
    8.   
    9. void main()  
    10. {  
    11.     n = 20;  
    12.     cout<<n<<endl;  
    13.     fun();  
    14.       
    15. }  
    16.   
    17. void fun()  
    18. {  
    19.     n++;  
    20.     cout<<n<<endl;  
    21. }  

                  D、文件作用域下声明的const的常量默认为static存储类型。

    静态变量都在全局数据区分配内存,包括静态局部变量。对于一个完整的程序,在内存中的分布情况如下:

    (1)代码区

    (2)全局数据区

    (3)堆区

    (4)栈区

    一般在程序中,由new产生的动态数据区放在堆区中,函数内部的自动变量存放在栈区。自动变量一般会随着函数的退出而释放空间,静态数据(即使是函数内部的静态局部变量)也存放在全局数据区中。全局数据区的数据并不会因为函数的退出而释放空间。

    如果把Example 1中的

    static int n;修改为

    int n;//全局变量。它可以实现变量在文件中的共享

    但是静态全局变量有以下好处:

    在其他文件中可以定义相同名字的变量,而不会发生冲突。

    Example 2

    [cpp]  view plain  copy
    1. FILE 1   
    2. #include <iostream>  
    3.   
    4. using namespace std;  
    5.   
    6. void fun();  
    7.   
    8. static int n;  
    9.   
    10. void main()  
    11. {  
    12.     n = 20;  
    13.     cout<<n<<endl;  
    14.     fun();  
    15.       
    16. }  
    17.   
    18.   
    19. FILE 2  
    20. #include <iostream>  
    21.   
    22. using namespace std;  
    23.   
    24. extern int n;  
    25.   
    26. void fun()  
    27. {  
    28.     n++;  
    29.     cout<<n<<endl;  
    30. }  

    2、静态局部变量

    定义:在局部变量前加上static关键字时,就定义了静态局部变量。

    [cpp]  view plain  copy
    1. FILE 3   
    2. #include <iostream>  
    3.   
    4. using namespace std;  
    5.   
    6. void fun();  
    7.   
    8. void main()  
    9. {  
    10.     fun();  
    11.     fun();  
    12.     fun();  
    13.       
    14. }  
    15.   
    16. void fun()  
    17. {  
    18.     static int n = 10;  
    19.     n++;  
    20.     cout<<n<<endl;  
    21. }  

    通常,在函数体内定义了一个变量,每当程序运行到该语句时都会给该局部变量分配栈内存,但随着程序退出函数体,系统就会收回栈内存,局部变量也相应失效。但是有时候我们需要在两次调用之间对变量的值进行保存,通常的想法是定义一个全局变量来实现,但是这样一来,变量已经不再属于函数本身了,不再仅受函数的控制,给程序的维护带来不便。

    静态局部变量正好可以解决这个问题。静态局部变量保存在全局数据区,而不是保存在栈中,每次的值保持到下一次调用,直到下次赋新值。

    特点:

            A、该变量在全局数据区分配内存

            B、初始化:如果不是显式初始化,那么将被隐式初始化为0,以后的函数调用不再进行初始化。

            C、它始终驻留在全局数据区,直到程序运行结束。但其作用域为局部作用域。当定义它的函数或语句块结束                    时,其作用域也随之结束。

    3、静态函数与普通函数不同,它只能在声明它的文件当中可见,不能被其他文件使用。

    Example 4

    [cpp]  view plain  copy
    1. FILE 4   
    2. #include <iostream>  
    3.   
    4. using namespace std;  
    5.   
    6. static void fun();  
    7.   
    8. void main()  
    9. {  
    10.     fun();  
    11.       
    12. }  
    13.   
    14. void fun()  
    15. {  
    16.     int n = 10;  
    17.     n++;  
    18.     cout<<n<<endl;  
    19. }  
    定义静态函数的好处:静态函数不能被其他文件使用。在其他文件中可以定义相同名字的函数,不会发生冲突。

    二、面向对象的static关键字

    1、静态数据成员

    在类内数据成员的声明前加上关键字static,该数据成员就是类内的静态数据成员。

    [cpp]  view plain  copy
    1. #include <iostream>  
    2.   
    3. using namespace std;  
    4.   
    5. class MyClass  
    6. {  
    7. public:  
    8.     MyClass(int a, int b, int c);  
    9.     void fun();  
    10. private:  
    11.     int a,b,c;  
    12.     static int sum;//声明静态数据成员  
    13. };  
    14.   
    15.  int MyClass::sum = 0;  
    16. MyClass::MyClass(int a, int b, int c)  
    17. {  
    18.     this->a = a;  
    19.     this->b = b;  
    20.     this->c = c;  
    21.     sum += a+b+c;  
    22. }  
    23.   
    24. void MyClass::fun()  
    25. {  
    26.     cout<<"sum = "<<sum<<endl;  
    27. }  
    28. void main()  
    29. {  
    30.     MyClass M(1,2,3);  
    31.     M.fun();  
    32.   
    33.     MyClass N(4,5,6);  
    34.     N.fun();  
    35. }  

    从以上的程序可以看出,静态数据成员有以下特点:

    (1)对于非静态数据成员,每个类对象都有自己的拷贝。而静态数据成员被当作是类的成员。无论这个类的对象定义了多少个,静态数据成员在程序中也只有一份拷贝,由该类型的所有对象共享访问。即静态数据成员是该类的所有对象所共有的。对该类的多个对象来说,静态数据成员只分配一次内存,供所有对象共用。所以,静态数据成员的值对每个对象都是一样的,它的值可以更新。

    (2)静态数据成员存储在全局数据区,静态数据成员定义时要分配空间,所以不能在类声明中定义。应该在类外定义。

    (3)静态数据成员和普通数据成员一样遵从public、private、protected访问规则。

    由于静态数据成员在全局数据区分配内存,属于本类的所有对象共享,它不属于特定的类对象,在没有产生类对象时作用域就可见。即在没有产生类的实例时,我们就可以操作它。

    静态数据成员的初始化与一般数据成员的初始化不同,即它的初始化格式为:

    <数据类型><类名>::<静态数据成员> = <值>

    类的静态数据成员有两种访问方式:

    如果静态数据成员的访问权限允许的话,即为public成员,可在程序中,按上述格式来引用静态数据成员;

    静态数据成员主要用在各个对象都有相同的某项属性的时候。比如对一个存款类,每个实例的利息都是相同的,所以把利息可以设为存款类的静态数据成员。这有两个好处,一是不管定义多少个存款类对象,利息数据成员都共享分配在全局数据区的内存,所以节省了存储空间。二是一旦利息需要改变时,只要改变一次,则所有存款类对象的利息全改变过来了。

    同全局变量相比,使用静态数据成员有两个优势:

    (1)静态数据成员没有进入程序的全局名字空间,因此不存在与程序中其他全局名字冲突的可能性;

    (2)可以实现信息隐藏。静态数据成员可以使private成员,而全局变量不能。

    2、静态成员函数

    与静态数据成员一样,我们也可以创建一个静态成员函数,它为类的全部服务,而不是为某一个类的具体对象服务。静态成员函数与静态数据成员一样,都是在类的内部实现,属于类定义的一部分。普通的成员函数一般都隐藏了一个this指针,this指针指向类的对象本身,因为普通成员函数总是具体的属于某个类的具体对象的。通常情况下,this指针是缺省的、但是与普通函数相比,静态成员函数由于不是与任何的对象相联系,因此它不具有this指针,从这个意义上讲,它无法访问属于类对象的非静态数据成员,也无法访问非静态成员函数,它只能调用其余的静态成员函数。

    Example 6

    [cpp]  view plain  copy
    1. #include <iostream>  
    2.   
    3. using namespace std;  
    4.   
    5. class MyClass  
    6. {  
    7. public:  
    8.     MyClass(int a, int b, int c);  
    9.     static void fun();  
    10. private:  
    11.     int a,b,c;  
    12.     static int sum;//声明静态数据成员  
    13. };  
    14.   
    15.  int MyClass::sum = 0;  
    16. MyClass::MyClass(int a, int b, int c)  
    17. {  
    18.     this->a = a;  
    19.     this->b = b;  
    20.     this->c = c;  
    21.     sum += a+b+c;  
    22. }  
    23.   
    24. void MyClass::fun()  
    25. {  
    26.     cout<<"sum = "<<sum<<endl;  
    27. }  
    28. void main()  
    29. {  
    30.     MyClass M(1,2,3);  
    31.     M.fun();  
    32.   
    33.     MyClass N(4,5,6);  
    34.     N.fun();  
    35.     MyClass::fun();//静态成员函数的访问  
    36. }  

    关于静态成员函数,可以总结以下几点:

    (1)出现在类体外的函数不能指定关键字static;

    (2)静态成员之间可以互相访问,包括静态成员函数访问静态数据成员和访问静态成员函数;

    (3)非静态成员函数可以任意地访问静态成员函数和静态数据成员;

    (4)静态成员函数不能访问非静态成员函数和非静态数据成员;

    (5)由于没有this指针的额外开销,因此静态成员函数与类的全局函数相比,速度上会有少许的增长;

    (6)调用静态成员函数,可以用成员访问操作符(.)和(->)为一个类的对象或指向类对象的指调用静态成员函数。


    展开全文
  • (一)静态变量:线程非安全 1、静态变量:使用static关键字定义的变量。static可以修饰变量和方法,也有static静态代码块。被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说,它不依赖类特定的...
  • 如果定义成局部变量,则必须定义静态局部变量静态局部变量是在编译时赋初值的,只赋初值一次,以后每次调用函数时不再重新赋初值而只是保留上次函数调用结束时的值。
  • 1、定义静态变量 2、静态函数 3、静态代码块
  • C# static静态变量用法

    千次阅读 2017-04-25 15:05:41
    静态函数的实现里不能使用非静态成员,如非静态变量、非静态函数等。 静态全局变量 定义:在全局变量前,加上关键字 static 该变量就被定义成为了一个静态全局变量。 特点:  A、该变量在全局数据区分配内存...
  • Java static(一) - 静态变量

    千次阅读 2017-10-14 00:47:31
    方法区(永久代)与Java堆一样,是各个线程共享的内存区域,它用于存储已经被虚拟机加载类的类信息、常量、静态变量static variable)等 2. static变量被static修饰的类的变量,也称为静态变量。非静态变量也称为...
  • kotlin定义静态变量、方法可以采用伴生对象companion object的方式。 下面这篇文章主要给大家介绍了关于Kotlin使用静态变量与静态方法的相关资料,需要的朋友可以参考下
  • kotlin 定义静态变量

    千次阅读 2019-05-08 16:54:30
    Kotlin 取消了关键字static,也就无法直接声明静态成员,在kotlin中定义静态变量需要使用伴生类 companion 先看看下java 的定义 如果直接复制粘贴过去如下 但是这些却不是静态变量 我们如下写法即可 ...
  • 静态变量static和全局变量global

    千次阅读 2021-03-04 05:42:25
    静态变量static ,全局变量global静态变量在java也叫类变量从名字可以看出它是属于某个类的而不是类的实例。它的关键字是static存储在静态存储区,当程序执行,类的代码被加载到内存,类的静态变量就分配了内存空间,...
  • static静态变量的理解

    千次阅读 2018-07-22 17:26:37
    static静态变量的理解 静态变量 类型说明符是static静态变量属于静态存储方式,其存储空间为内存中的静态数据区(在静态存储区内分配存储单元),该区域中的数据在整个程序的运行期间一直占用这些存
  • 在变量的前面加上static 就构成了静态变量static 变量)。 static变量和普通变量的区别在于非静态全局变量的作用域是整个源程序,当一个源程序由多个源文件组成时,非静态的全局变量在各个源文件中都是有效的。 而...
  • 头文件中定义static静态变量的利弊

    千次阅读 2018-01-19 19:40:22
    频繁使用其实效率更高,如果定义静态变量不用,那就会浪费内存,因为全局数据区生命周期是从程序运行到结束。 局部变量:每次栈上都要为局部变量分配空间,因此局部变量太多会影响效率,但是其回收方便,
  • static静态变量 与 常量

    千次阅读 2020-08-09 19:16:58
    在学习static静态变量之前,我们还是有必要来了解 变量 的意义。程序要对数据进行读、写、运算等操作,当需要保存特定的值或结果的时候就需要用到变量,在用户看来,变量是用来描述一条信息的名称,在变量中可以储存...
  • static--静态变量与普通变量的区别

    万次阅读 多人点赞 2019-03-12 09:59:09
    静态变量与普通变量的区别 全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式, 静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽...
  • static修饰的成员变量和成员方法独立于该类的任何对象。 被类所有的实例所共享。...声明为static关键词修饰的变量叫做静态成员变量,也叫全局变量静态成员变量的访问方式: (1)直接通过类...
  • 静态变量 static定义

    千次阅读 2016-04-22 10:34:50
    具体来说,静态变量(全局变量及汇编语言里定义的符号亦同)可用const,constant或final(根据语言决定)等关键字标识,这时其值就会在编译时(英语:Compile time)设定,并且无法在运行时改变。 编译器通常将静态...
  • static定义变量

    千次阅读 2019-01-08 11:01:57
    static全局变量与普通全局变量的区别 static全局变量和普通全局变量的存储方式没有不同...而static全局变量只能在它定义的源文件中使用。由于静态全局变量的作用域局限于一个源文件内,只能为该源文件内的函数公用...
  • 这个时候定义一个静态变量那会不会造成内存泄漏呢?会的,由于静态变量生命周期同类的对象一致。因此不能。 2.在人性化的设计中,静态变量大都用来供外界访问或类中各个方法共享。你在一个方法中定义了一个静态变量...
  • 静态变量static的理解

    千次阅读 2020-04-25 21:11:10
    静态变量在函数间调用时保持他们的值不变。 它的语法结构为: static c_type data_name; 其中,c_type 为基础的数据类型,data_name是变量名。 生存期 生存期的概念是在程序执行过程中体现的。程序开始执行后,对所...
  • 关于C语言中定义static变量的解释

    千次阅读 2020-03-07 11:39:55
    在C语言中static类型的变量的意思其实和它的本意差不多,表示“静态”或者“全局”的意思,用来修饰变量和函数。经static修饰过后的变量或者函数的作用域或者存储域会发生变化,而由static修饰的变量在初始值方面也...
  • 先上实例public classTestStatic {public static String staticString = "this ... //静态变量public String instanceString = "this is a instance String";//实例变量//静态方法public static voidstaticMethod()...
  • Kotlin定义静态变量、静态方法

    万次阅读 2018-05-10 15:46:31
    Kotlin定义静态变量、静态方法 kotlin定义静态变量、方法可以采用伴生对象的方式。 经典例子,实例化Fragment。 java写法: public class TestFragment extends Fragment { private static final String ARG_...
  • java定义静态变量的作用 static关键字

    万次阅读 2016-10-25 11:33:09
    我们知道类中的静态变量在程序运行期间,其内存空间对所有该类的对象实例而言是共享的,为了节省系统内存开销、共享资源,应该将一些变量声明为静态变量。通过下面的例子,你就会发现有什么不同。 代码一: public...
  • 最近通过帮朋友解答c++的一道笔试题,学到了不少东西,在此记录下。...这就要从static变量初始化的阶段谈起了,首先我们先了解一下c++中关于静态变量的三条规则: 在C++中,全局static变量和class的stat
  • 静态局部变量静态全程变量static

    万次阅读 多人点赞 2019-01-01 13:28:04
    我们知道在函数内部定义变量,当程序执行到它的定义处时,编译器为它在栈上分配空间,函数在栈上分配的空间在此函数执行结束时会释放掉,这样就产生了一个问题: 如果想将函数中此变量的值保存至下一次调用时,如何...
  • static 修饰的是 静态变量,它的优点是 使用很方便,在不同的类和包中都可以使用,在虚拟机中单独占用内存。 不过使用 static 有一些不太好的地方:项目中 使用 static 的很多地方会莫明的出现空指针异常的错误...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 518,373
精华内容 207,349
关键字:

static定义静态变量