精华内容
下载资源
问答
  • 在SQL Server中局部变量前面字符为( )。_学小易找答案
    2021-01-21 07:21:46

    【单选题】下列对文中提 到 的 几部中国作品的说法中 ,不符合文意的一项是 ______

    【填空题】三角形的特点是 ( )条边,( )个角。

    【判断题】三角形也可以叫做三边形。

    【单选题】青少年鼻出血常见于

    【单选题】唢呐高亢有力的音色,更适合表现()的情绪?

    【单选题】下列对作者在文中提 到 的 关于中国婚礼中 “庙见” 的理解,不符合文意的一项是 _____

    【判断题】在T-SQL中,分隔标识符是用单引号定界的标识符。

    【判断题】At present, the manufacturing process of CPU is .

    【单选题】口臭患者应选用的漱口液是 (2.0分)

    【单选题】鼻腔凡士林纱条填塞,留置时间为

    【判断题】The control unit performs all the arithmetic and logical functions.

    【单选题】6 岁儿童患慢性额窦炎,最适宜的治疗方法为

    【单选题】下列对作者在文中提 到 的 中国女性典范中的 “四德” 的理解,不符合文意的一项是 ______ D

    【单选题】变应性鼻炎的典型症状哪项错误

    【单选题】在SQL Server中局部变量前面的字符为( )。

    【单选题】口腔PH值低时容易发生 (2.0分)

    【单选题】The core component of the microcomputer hardware system is .

    【单选题】三种基本的积极情绪不包括哪一个?()

    【单选题】下列对文中提 到 的 关于 “中国婚礼” 的理解,不符合文意的一项是 ______

    【单选题】下列对文中提 到 的 关于中国女性典范所具有的 “幽闲”一次的翻译 理解,不符合文意的一项是 ______

    【填空题】(《温病条辩.上焦篇》第54条)秋感燥气,右脉数大,伤手太阴气分者,_________。

    【简答题】生物浓缩、积累、放大有何区别和联系

    【单选题】慢性单纯性鼻炎的主要症状是

    【填空题】The main function of the arithmetic unit is to carry out arithmetical operations and operations.

    【单选题】鼻疖禁忌挤压的主要原因是

    【单选题】对于出血较剧,渗血面较广的鼻出血的止血方法哪项是正确的

    【填空题】(《温病条辩。上焦篇》第31条)温病燥热,欲解燥者,先滋其干,________,服之反燥甚。

    【单选题】下列对文中提 到 的 几部外国文学作品的说法中 ,不符合文意的一项是 _____

    【单选题】下列对文中提 到 的 关于 “中国女性典范”的 理解,不符合文意的一项是 _____

    【填空题】(《温病条.上焦篇》第56条)__________,或热或咳者,沙参麦冬汤主之。

    【判断题】CPU can access data directly from the hard disk.

    【单选题】下列对文中提 到 的 中国女性典范中的 “ 三从 ” 的理解,不符合文意的一项是 ______

    【简答题】《温病条辩。中焦篇》第30条 温病小便不利者,--------, 忌五苓、------。

    【单选题】为昏迷患者进行口腔护理时,不需准备的用物是 (2.0分)

    【单选题】口腔护理的目的,不妥的是 (2.0分)

    【单选题】下面标志符不合法的是( )。

    【单选题】行鼻窦负压置换疗法时负压不应超过

    【判断题】Registers in the control unit are used to keep track of the overall status of the program.

    【判断题】CPU is mainly used to store programs and data.

    【单选题】下列对文中提 到 的 关于 “中国婚姻”与“欧美婚姻”的 理解,不符合文意的一项是 ______

    【判断题】四边形也可以叫做四角形。

    【单选题】下列对文中提 到 的 几位学者的说法中 ,不符合文意的一项是 _____

    【判断题】With the development of computer, the physical size of the CPU has often become bigger and bigger.

    【填空题】三角形具有( )性,平行四边行具有( )的特性。

    【单选题】鼻出血的处理哪项错误

    【填空题】(《温病条辩。上焦篇》第57条)______,清窍不利有利者,翘荷汤主之。

    【填空题】(《温病条辨。上焦篇》第43条)头痛,恶寒,身重疼痛,________,脉弦细而濡,面色淡黄,胸闷不饥,_____。状若阴虚,病难速已,名日湿温。汗之则神昏耳聋,甚则目瞑不欲言。下之则洞泄,润之则病深不解。长夏深秋冬同法,______。

    【填空题】四边形的特点是( )条边,( )个角。

    【单选题】Word length is one of the main performance indicators of CPU, it means .

    【单选题】FX 系列 PLC 中 LDP, 表示什么指令 ?

    更多相关内容
  • python中全局变量和局部变量详解

    万次阅读 多人点赞 2018-11-13 12:18:46
    python中全局变量和局部变量的最大区别在于局部变量只能通过函数去访问,而全局变量可以直接访问。 !!! 我们先来看一个最简单的例子,事实上这并不是一个真正的全局变量,只是在类中的一个变量。 !!! 我们...

    写在最前面:

    python中全局变量和局部变量的最大区别在于局部变量只能通过函数去访问,而全局变量可以直接访问。

    !!!

    我们先来看一个最简单的例子,事实上这并不是一个真正的全局变量,只是在类中的一个变量。

    !!!

    我们先从类中的变量访问开始讲起

    那么我们要如何访问这个变量呢?

    class variable:
        a = '我是类变量'
    
        def showvarible(self):
            b = '我是函数变量'
            print(a)
            print(b)
    
    
    variable().showvarible()

    毫无疑问,编译器就已经报错了,这是因为类中的变量不可以在函数中直接访问,应该这样

    class variable:
        a = '我是类变量'
    
        def showvarible(self):
            b = '我是函数变量'
            print(variable.a)
            print(b)
    
    
    variable().showvarible()
    我是类变量
    我是函数变量
    

    其实我们还可以通过self去访问

    class variable:
    
        a = '我是类变量'
    
        def showvarible(self):
            b = '我是函数变量'
            print(self.a)
            print(b)
    
    
    variable().showvarible()

     结果是一样的

    我是类变量
    我是函数变量

     

    还可以怎么做呢,我们通过构造函数给定一个参数,类中可访问

    class variable:
    
        def __init__(self,a):
            self.a = '我是类变量'
    
        def showvarible(self):
            b = '我是函数变量'
            print(self.a)
            print(b)
            
    
    
    variable(1).showvarible()
    我是类变量
    我是函数变量

     这里需要注意的是,实例化的时候必须给参数,由于python是动态语言,不需要指定参数的类型,你可以放int,比如1,也可以给一个字符串。 

     

    然后我们真正看一下全局变量

    a = '我是真正的全局变量'
    
    
    def showvariable():
        b = '我一直都是局部变量'
        print(a)
        print(b)
    
    
    showvariable()
    我是真正的全局变量
    我一直都是局部变量
    

     

    当我们试图在函数外访问这个函数的局部变量时

    a = '我是真正的全局变量'
    
    
    def showvariable():
        b = '我一直都是局部变量'
        print(a)
    
    def showb():
        print(b)
    
    
    showvariable()

    报错

    我是真正的全局变量
    Traceback (most recent call last):
      File "F:/leetcode/xxx.py", line 13, in <module>
        showb()
      File "F:/leetcode/xxx.py", line 9, in showb
        print(b)
    NameError: name 'b' is not defined
    

    说明局部变量只能在局部使用。

    那么不巧的是,我的局部变量和全局变量定义了同一个名称,谁的优先级更高呢?

    a = '我是真正的全局变量'
    
    
    def showvariable():
        a = '我一直都是局部变量'
        print(a)
    
    
    print(a)
    showvariable()

    我猜是局部变量,嘿嘿

    我是真正的全局变量
    我一直都是局部变量

    果然,函数优先使用了局部变量

    而优先级还有一个体现,来看下面的例子

    a = 3
    
    
    def showvariable():
        a = a * 5
        print(a)
    
    
    showvariable()

    你可能会认为输出15,但是上面的一个例子告诉我们,在函数内会优先使用局部变量

    3
    Traceback (most recent call last):
      File "F:/leetcode/xxx.py", line 10, in <module>
        showvariable()
      File "F:/leetcode/xxx.py", line 5, in showvariable
        a = a * 3
    UnboundLocalError: local variable 'a' referenced before assignment
    

    这样是因为,我们在函数内定义了一个局部变量a,但是还没来得及赋值,就被*5,编译器不知道拿谁去*5,当然报错了。

     

    下面讲讲global,global第一次是只能定义不能赋值的

    def showvariable():
        global a
        a = '我是global'
        print(a)
    
    
    showvariable()
    我是global

    当然是可以在函数外访问的

    def showvariable():
        global a
        a = '我是global'
        print(a)
    
    def showglobal():
        print(a)
    
    showvariable()
    showglobal()
    我是global
    我是global

    但是,必须赋值后才有意义,如果像这样

    def showvariable():
        global a
        a = '我是global'
        print(a)
    
    def showglobal():
        print(a)
    
    print(a)
    showvariable()
    showglobal()

    在没有赋值的时候,就去打印

    Traceback (most recent call last):
      File "F:/leetcode/xxx.py", line 9, in <module>
        print(a)
    NameError: name 'a' is not defined
    

    因为此时global a还没有赋值,当然不能打印。

    展开全文
  • 静态局部变量和静态全程变量static。

    万次阅读 多人点赞 2019-01-01 13:28:04
    我们知道在函数内部定义的变量,当程序执行到它的定义处时,编译器为它在栈上分配空间,函数在栈上分配的空间在此函数执行结束时会释放掉,这样就产生了一个问题: 如果想将函数中此变量的值保存至下一次调用时,如何...

    1. 什么是static?

    static 是 C/C++ 中很常用的修饰符,它被用来控制变量的存储方式和可见性。

    1.1 static 的引入

    我们知道在函数内部定义的变量,当程序执行到它的定义处时,编译器为它在栈上分配空间,函数在栈上分配的空间在此函数执行结束时会释放掉,这样就产生了一个问题: 如果想将函数中此变量的值保存至下一次调用时,如何实现? 最容易想到的方法是定义为全局的变量,但定义一个全局变量有许多缺点,最明显的缺点是破坏了此变量的访问范围(使得在此函数中定义的变量,不仅仅只受此函数控制)。static 关键字则可以很好的解决这个问题。

    另外,在 C++ 中,需要一个数据对象为整个类而非某个对象服务,同时又力求不破坏类的封装性,即要求此成员隐藏在类的内部,对外不可见时,可将其定义为静态数据。

    static 存储类

    static 存储类指示编译器在程序的生命周期内保持局部变量的存在,而不需要在每次它进入和离开作用域时进行创建和销毁。因此,使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。

    static 修饰符也可以应用于全局变量。当 static 修饰全局变量时,会使变量的作用域限制在声明它的文件内。

    全局声明的一个 static 变量或方法可以被任何函数或方法调用,只要这些方法出现在跟 static 变量或方法同一个文件中。

    以下实例演示了 static 修饰全局变量和局部变量的应用:

    实例

    #include <stdio.h> /* 函数声明 */ 
    
    void func1(void); 
    static int count=10; /* 全局变量 - static 是默认的 */ 
    int main()
     {
     while (count--) 
    { 
    func1(); 
    } return 0; 
    } 
    void func1(void) 
    { /* 'thingy' 是 'func1' 的局部变量 - 只初始化一次 * 每次调用函数 'func1' 'thingy' 值不会被重置。 */
     static int thingy=5; 
    thingy++;
     printf(" thingy 为 %d , count 为 %d\n", thingy, count); 
    }

    实例中 count 作为全局变量可以在函数内使用,thingy 使用 static 修饰后,不会在每次调用时重置。

    可能您现在还无法理解这个实例,因为我已经使用了函数和全局变量,这两个概念目前为止还没进行讲解。即使您现在不能完全理解,也没有关系,后续的章节我们会详细讲解。当上面的代码被编译和执行时,它会产生下列结果:

     thingy 为 6 , count 为 9
     thingy 为 7 , count 为 8
     thingy 为 8 , count 为 7
     thingy 为 9 , count 为 6
     thingy 为 10 , count 为 5
     thingy 为 11 , count 为 4
     thingy 为 12 , count 为 3
     thingy 为 13 , count 为 2
     thingy 为 14 , count 为 1
     thingy 为 15 , count 为 0

    extern 存储类

    extern 存储类用于提供一个全局变量的引用,全局变量对所有的程序文件都是可见的。当您使用 extern 时,对于无法初始化的变量,会把变量名指向一个之前定义过的存储位置。

    当您有多个文件且定义了一个可以在其他文件中使用的全局变量或函数时,可以在其他文件中使用 extern 来得到已定义的变量或函数的引用。可以这么理解,extern 是用来在另一个文件中声明一个全局变量或函数。

    extern 修饰符通常用于当有两个或多个文件共享相同的全局变量或函数的时候,如下所示:

    第一个文件:main.c

    实例

    #include <stdio.h> int count ; extern void write_extern(); int main() { count = 5; write_extern(); }

     

     

     

    1.2 静态数据的存储

    全局(静态)存储区:分为 DATA 段和 BSS 段。DATA 段(全局初始化区)存放初始化的全局变量和静态变量;BSS 段(全局未初始化区)存放未初始化的全局变量和静态变量。程序运行结束时自动释放。其中BBS段在程序执行之前会被系统自动清0,所以未初始化的全局变量和静态变量在程序执行之前已经为0。存储在静态数据区的变量会在程序刚开始运行时就完成初始化,也是唯一的一次初始化。

    在 C++ 中 static 的内部实现机制:静态数据成员要在程序一开始运行时就必须存在。因为函数在程序运行中被调用,所以静态数据成员不能在任何函数内分配空间和初始化。

    这样,它的空间分配有三个可能的地方,一是作为类的外部接口的头文件,那里有类声明;二是类定义的内部实现,那里有类的成员函数定义;三是应用程序的 main() 函数前的全局数据声明和定义处。

    静态数据成员要实际地分配空间,故不能在类的声明中定义(只能声明数据成员)。类声明只声明一个类的"尺寸和规格",并不进行实际的内存分配,所以在类声明中写成定义是错误的。它也不能在头文件中类声明的外部定义,因为那会造成在多个使用该类的源文件中,对其重复定义。

    static 被引入以告知编译器,将变量存储在程序的静态存储区而非栈上空间,静态数据成员按定义出现的先后顺序依次初始化,注意静态成员嵌套时,要保证所嵌套的成员已经初始化了。消除时的顺序是初始化的反顺序。

    优势:可以节省内存,因为它是所有对象所公有的,因此,对多个对象来说,静态数据成员只存储一处,供所有对象共用。静态数据成员的值对每个对象都是一样,但它的值是可以更新的。只要对静态数据成员的值更新一次,保证所有对象存取更新后的相同的值,这样可以提高时间效率。


    2. 在 C/C++ 中static的作用

    2.1 总的来说

    • (1)在修饰变量的时候,static 修饰的静态局部变量只执行初始化一次,而且延长了局部变量的生命周期,直到程序运行结束以后才释放。
    • (2)static 修饰全局变量的时候,这个全局变量只能在本文件中访问,不能在其它文件中访问,即便是 extern 外部声明也不可以。
    • (3)static 修饰一个函数,则这个函数的只能在本文件中调用,不能被其他文件调用。static 修饰的变量存放在全局数据区的静态变量区,包括全局静态变量和局部静态变量,都在全局数据区分配内存。初始化的时候自动初始化为 0。
    • (4)不想被释放的时候,可以使用static修饰。比如修饰函数中存放在栈空间的数组。如果不想让这个数组在函数调用结束释放可以使用 static 修饰。
    • (5)考虑到数据安全性(当程序想要使用全局变量的时候应该先考虑使用 static)。

    2.2 静态变量与普通变量

    静态全局变量有以下特点:

    • (1)静态变量都在全局数据区分配内存,包括后面将要提到的静态局部变量;
    • (2)未经初始化的静态全局变量会被程序自动初始化为0(在函数体内声明的自动变量的值是随机的,除非它被显式初始化,而在函数体外被声明的自动变量也会被初始化为 0);
    • (3)静态全局变量在声明它的整个文件都是可见的,而在文件之外是不可见的。

    优点:静态全局变量不能被其它文件所用;其它文件中可以定义相同名字的变量,不会发生冲突。

    (1)全局变量和全局静态变量的区别

    • 1)全局变量是不显式用 static 修饰的全局变量,全局变量默认是有外部链接性的,作用域是整个工程,在一个文件内定义的全局变量,在另一个文件中,通过 extern 全局变量名的声明,就可以使用全局变量。
    • 2)全局静态变量是显式用 static 修饰的全局变量,作用域是声明此变量所在的文件,其他的文件即使用 extern 声明也不能使用。

    2.3 静态局部变量有以下特点:

    • (1)该变量在全局数据区分配内存;
    • (2)静态局部变量在程序执行到该对象的声明处时被首次初始化,即以后的函数调用不再进行初始化;
    • (3)静态局部变量一般在声明处初始化,如果没有显式初始化,会被程序自动初始化为 0;
    • (4)它始终驻留在全局数据区,直到程序运行结束。但其作用域为局部作用域,当定义它的函数或语句块结束时,其作用域随之结束。

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

    看下面的例子:

    实例

    //example: #include <stdio.h> #include <stdlib.h> int k1 = 1; int k2; static int k3 = 2; static int k4; int main() { static int m1 = 2, m2; int i = 1; char*p; char str[10] = "hello"; char*q = "hello"; p = (char *)malloc(100); free(p); printf("栈区-变量地址 i:%p\n", &i); printf("栈区-变量地址 p:%p\n", &p); printf("栈区-变量地址 str:%p\n", str); printf("栈区-变量地址 q:%p\n", &q); printf("堆区地址-动态申请:%p\n", p); printf("全局外部有初值 k1:%p\n", &k1); printf(" 外部无初值 k2:%p\n", &k2); printf("静态外部有初值 k3:%p\n", &k3); printf(" 外静无初值 k4:%p\n", &k4); printf(" 内静态有初值 m1:%p\n", &m1); printf(" 内静态无初值 m2:%p\n", &m2); printf(" 文字常量地址:%p, %s\n", q, q); printf(" 程序区地址:%p\n", &main); return 0; }

    输出结果如下:


    3. static 用法

    3.1 在 C++ 中

    static 关键字最基本的用法是:

    • 1、被 static 修饰的变量属于类变量,可以通过类名.变量名直接引用,而不需要 new 出一个类来
    • 2、被 static 修饰的方法属于类方法,可以通过类名.方法名直接引用,而不需要 new 出一个类来

    被 static 修饰的变量、被 static 修饰的方法统一属于类的静态资源,是类实例之间共享的,换言之,一处变、处处变。

    在 C++ 中,静态成员是属于整个类的而不是某个对象,静态成员变量只存储一份供所有对象共用。所以在所有对象中都可以共享它。使用静态成员变量实现多个对象之间的数据共享不会破坏隐藏的原则,保证了安全性还可以节省内存。

    静态成员的定义或声明要加个关键 static。静态成员可以通过双冒号来使用即 <类名>::<静态成员名>。

    3.2 静态类相关

    通过类名调用静态成员函数和非静态成员函数:

    class Point { public: void init() { } static void output() { } }; void main() { Point::init(); Point::output(); }

    报错:

    'Point::init' : illegal call of non-static member function

    结论 1:不能通过类名来调用类的非静态成员函数。

    通过类的对象调用静态成员函数和非静态成员函数。

    class Point { public: void init() { } static void output() { } }; void main() { Point pt; pt.init(); pt.output(); }

    编译通过。

    结论 2:类的对象可以使用静态成员函数和非静态成员函数。

    在类的静态成员函数中使用类的非静态成员。

    #include <stdio.h> class Point { public: void init() { } static void output() { printf("%d\n", m_x); } private: int m_x; }; void main() { Point pt; pt.output(); }

    编译出错:

    error C2597: illegal reference to data member 'Point::m_x' in a static member function

    因为静态成员函数属于整个类,在类实例化对象之前就已经分配空间了,而类的非静态成员必须在类实例化对象后才有内存空间,所以这个调用就出错了,就好比没有声明一个变量却提前使用它一样。

    结论3:静态成员函数中不能引用非静态成员。

    在类的非静态成员函数中使用类的静态成员。

    class Point { public: void init() { output(); } static void output() { } }; void main() { Point pt; Pt.init(); pt.output(); }

    编译通过。

    结论 4:类的非静态成员函数可以调用用静态成员函数,但反之不能。

    使用类的静态成员变量。

    #include <stdio.h> class Point { public: Point() { m_nPointCount++; } ~Point() { m_nPointCount--; } static void output() { printf("%d\n", m_nPointCount); } private: static int m_nPointCount; }; void main() { Point pt; pt.output(); }

    按 Ctrl+F7 编译无错误,按 F7 生成 EXE 程序时报链接错误。

    error LNK2001: unresolved external symbol "private: static int Point::m_nPointCount" (?m_nPointCount@Point@@0HA)

    这是因为类的静态成员变量在使用前必须先初始化。

    在 main() 函数前加上 int Point::m_nPointCount = 0; 再编译链接无错误,运行程序将输出 1。

    结论 5:类的静态成员变量必须先初始化再使用。

    思考总结:静态资源属于类,但是是独立于类存在的。从 J 类的加载机制的角度讲,静态资源是类初始化的时候加载的,而非静态资源是类实例化对象的时候加载的。 类的初始化早于类实例化对象,比如 Class.forName("xxx") 方法,就是初始化了一个类,但是并没有实例化对象,只是加载这个类的静态资源罢 了。所以对于静态资源来说,它是不可能知道一个类中有哪些非静态资源的;但是对于非静态资源来说就不一样了,由于它是实例化对象出来之后产生的,因此属于类的这些东西它都能认识。所以上面的几个问题答案就很明确了:

    • 1)静态方法能不能引用非静态资源?不能,实例化对象的时候才会产生的东西,对于初始化后就存在的静态资源来说,根本不认识它。
    • 2)静态方法里面能不能引用静态资源?可以,因为都是类初始化的时候加载的,大家相互都认识。
    • 3)非静态方法里面能不能引用静态资源?可以,非静态方法就是实例方法,那是实例化对象之后才产生的,那么属于类的内容它都认识。

    static 修饰类:这个用得相对比前面的用法少多了,static 一般情况下来说是不可以修饰类的, 如果 static 要修饰一个类,说明这个类是一个静态内部类(注意 static 只能修饰一个内部类),也就是匿名内部类。像线程池 ThreadPoolExecutor 中的四种拒绝机制 CallerRunsPolicy、AbortPolicy、DiscardPolicy、 DiscardOldestPolicy 就是静态内部类。静态内部类相关内容会在写内部类的时候专门讲到。)

    3.3 总结:

    • (1)静态成员函数中不能调用非静态成员。
    • (2)非静态成员函数中可以调用静态成员。因为静态成员属于类本身,在类的对象产生之前就已经存在了,所以在非静态成员函数中是可以调用静态成员的。
    • (3)静态成员变量使用前必须先初始化(如 int MyClass::m_nNumber = 0;),否则会在 linker 时出错。

    一般总结:在类中,static 可以用来修饰静态数据成员和静态成员方法。

    静态数据成员

    • (1)静态数据成员可以实现多个对象之间的数据共享,它是类的所有对象的共享成员,它在内存中只占一份空间,如果改变它的值,则各对象中这个数据成员的值都被改变。
    • (2)静态数据成员是在程序开始运行时被分配空间,到程序结束之后才释放,只要类中指定了静态数据成员,即使不定义对象,也会为静态数据成员分配空间。
    • (3)静态数据成员可以被初始化,但是只能在类体外进行初始化,若未对静态数据成员赋初值,则编译器会自动为其初始化为 0。
    • (4)静态数据成员既可以通过对象名引用,也可以通过类名引用。

    静态成员函数

    • (1)静态成员函数和静态数据成员一样,他们都属于类的静态成员,而不是对象成员。
    • (2)非静态成员函数有 this 指针,而静态成员函数没有 this 指针。
    • (3)静态成员函数主要用来方位静态数据成员而不能访问非静态成员。

    再给一个利用类的静态成员变量和函数的例子以加深理解,这个例子建立一个学生类,每个学生类的对象将组成一个双向链表,用一个静态成员变量记录这个双向链表的表头,一个静态成员函数输出这个双向链表。

    实例

    #include <stdio.h> #include <string.h> const int MAX_NAME_SIZE = 30; class Student { public: Student(char *pszName); ~Student(); public: static void PrintfAllStudents(); private: char m_name[MAX_NAME_SIZE]; Student *next; Student *prev; static Student *m_head; }; Student::Student(char *pszName) { strcpy(this->m_name, pszName); //建立双向链表,新数据从链表头部插入。 this->next = m_head; this->prev = NULL; if (m_head != NULL) m_head->prev = this; m_head = this; } Student::~Student ()//析构过程就是节点的脱离过程 { if (this == m_head) //该节点就是头节点。 { m_head = this->next; } else { this->prev->next = this->next; this->next->prev = this->prev; } } void Student::PrintfAllStudents() { for (Student *p = m_head; p != NULL; p = p->next) printf("%s\n", p->m_name); } Student* Student::m_head = NULL; void main() { Student studentA("AAA"); Student studentB("BBB"); Student studentC("CCC"); Student studentD("DDD"); Student student("MoreWindows"); Student::PrintfAllStudents(); }

    程序将输出:

     

    static变量称为静态变量。根据变量的类型可以分为静态局部变量和静态全程变量。
      
        1. 静态局部变量  
        它与局部变量的区别在于: 在函数退出时, 这个变量始终存在, 但不能被其它  
    函数使用, 当再次进入该函数时, 将保存上次的结果。其它与局部变量一样。  

        2. 静态全程变量  
       静态全程变量就是指只在定义它的源文件中可见而在其它源文件中不可见的变量。
    它与全程变量的区别是: 全程变量可以再说明为外部变量(extern), 被其它源文件使
    用, 而静态全程变量却不能再被说明为外部的, 即只能被所在的源文件使用。 

     

     

     

    static变量与全局变量初始化都一样,只会初始化一次,也就是你在函数内创建这个变量的时候要是给过一次初值,每次调用函数时不会重新给这个变量幅值,它会保持上一次的值,所以在函数执行完成跳出该函数的时候被释放掉。
    static函数的作用是限制该函数的使用范围,也就是只有本函数内的其他函数可以调用static函数,不能被跨文件调用。另外一点就是其他C文件可以使用同一个用static修饰的函数名

     

     

     

    u8 KEY_Scan(u8 mode)
    {  
    static u8 key_up=1;//按键按松开标志 (只进行一次初始化)
    if(mode)key_up=1;  //支持连按  
    if(key_up&&(KEY0==0||KEY1==0||WK_UP==1))
    {
    delay_ms(10);//去抖动 
    key_up=0;
    if(KEY0==0)return KEY0_PRES;
    else if(KEY1==0)return KEY1_PRES;
    else if(WK_UP==1)return WKUP_PRES; 
    }else if(KEY0==1&&KEY1==1&&WK_UP==0)key_up=1;     
    return 0;// 无按键按下
    }

     

     

    以下为GPS局部程序 应用的为静态变量、

     

     

     

     


    //GPRS数据保存位置
    static char GPRS_Data[MAXRECVBUFF]={0};
    static int  GPRS_Dlen = 0;
    static u8   GPRS_Dtu_ConLock = 0;
     
    u8 RestartGprs = 0; //重启GPRS标志
     
    #if GU906GSM_EN
    //短信信息在SIM卡中的位置
    static char SIMDataID[5]=""; 
    struct user_simdata sim;
    #endif
     
    /*********************************************************
      * @function  GPRS_ascii_to_hex
      * @role      
      * @input     
      * @output    None
      * @return    
      ********************************************************/
    static int GPRS_ascii_to_hex(u8 *asc_data, u8 *hex_data, int len)
    {
        int i;
        u8 tmp_dat;
        for(i = 0; i < len; i++)
        {
            if ((asc_data[i] >= '0') && (asc_data[i] <= '9')){
                tmp_dat = asc_data[i] - '0';
            }else if ((asc_data[i] >= 'A') && (asc_data[i] <= 'F')){ // A....F
                tmp_dat = asc_data[i] - 0x37;
            }
            else if((asc_data[i] >= 'a') && (asc_data[i] <= 'f')){ // a....f
                tmp_dat = asc_data[i] - 0x57;
            }else return -1;
            hex_data[i] = tmp_dat;  
        }
        return 0;
    }
     
    /*********************************************************
      * @function  mypow
      * @role      pow库函数的实现,计算num的n次幂,其中n为整数 
      * @input     num
      * @output    n
      * @return    计算结果
      *******************************************************
    static int mypow(int num,int n)
    {
        int powint=1;
        int i;
        for(i=1;i<=n;i++) powint*=num;
        return powint;
    }
    */
    /*********************************************************
      * @function  FreeStr
      * @role      删除字符串中的字串,支持16进制数据,无视结束符
      * @input     字符串、字符串总长度、开始删除的起始位置、要删除的长度
      * @output    None
      * @return    None
      ********************************************************/
    static void FreeStr(char *str, int strsiz, int head, int len)
    {
        int i = 0;
        while(len--)
        {
            for(i = head; i < strsiz;i++)
            {
                str[i] = str[i+1];
            }
        }
    }
     
    #if GU906GSM_EN
    /*********************************************************
      * @function  GU906_ParsingSIM
      * @role      解析SIM卡中的短信数据
      * @input     卡中的数据
      * @output    None
      * @return    成功返回:0,失败返回:-1
        @data      
        +CMGR: "REC READ","18750******",,"2015/03/14 20:02:15+32"
         124abcABC
        OK
      ********************************************************/
    static int GU906_ParsingSIM(char *pinput)
    {
        char *p = pinput;
        int i;
        #if DEBUG_EN
        printf("\n分离手机号\n");
        #endif
        if((p = strstr(p,"\",\"")) == 0)
            return -1;
        p += 3;
        memset(sim.phone,0,sizeof(sim.phone));
        for (i = 0; (*p != '\"') && (*p != '\0'); ++i,p++){
            sim.phone[i] = *p;
        }
        sim.phone[i] = '\0';
        #if DEBUG_EN
        printf("sms.phone[%s]\r\n",sim.phone);
        printf("\n分离设备类型\n");
        #endif
        
        p +=2;
        memset(sim.dev,0,sizeof(sim.dev));
        for (i = 0; (*p != ',') && (*p != '\0'); ++i,p++){
            sim.dev[i] = *p;
        }
        #if DEBUG_EN
        printf("sms.dev[%s]\r\n",sim.dev);
        printf("\n分离时间\n");
        #endif
        
        p += 2;
        memset(sim.date,0,sizeof(sim.date));
        for (i = 0; (*p != '\"') && (*p != '\0'); ++i,p++){
            sim.date[i] = *p;
        }
        #if DEBUG_EN
        printf("sms.date[%s]\r\n",sim.date);
        printf("\n分离数据\n");
        #endif
        
        p++;
        memset(sim.data,0,sizeof(sim.data));
        while((*p != '\0') && ((*p == '\n') || (*p == '\r')) ) p++;
        for (i = 0; (*p != '\0') && (*p != '\n') && (*p != '\r'); ++i,p++){
            sim.data[i] = *p;
        }
        sim.data[i] = '\0';
        #if DEBUG_EN
        printf("sms.data:[%s]\r\n",sim.data );
        #endif
        return 0;
    }
    #endif
     
    /*********************************************************
      * @function  GetRecvData
      * @role      提取字符串中跟命令无关的数据,有时在进行命令操作时,
                   会突然收到短信,什么的,这里要做的就是处理并过滤掉这些数据。
                   还有模块突然复位了,这里也做判断,并复位CPU。
      * @input     数据和数据长度
      * @output    None
      * @return    None
      ********************************************************/
    static void GetRecvData(char *pBuff, int *pLen)
    {
        int rlen = 0;
        char buff[5]="";
        int i = 0;
        char *p1 = NULL;
        char *p2 = NULL;    
     
        if((pBuff == NULL) || (*pLen == 0))
            return;
        if (((p1 = strstr(pBuff, "+IPD,")) != 0) && ((p2 = strchr(pBuff, ':')) != 0))
        {
            p1+=5;
            for (i = 0; ((p1-pBuff) < *pLen) && (i < 5) && (*p1 != ':'); ++i,++p1) {
                buff[i] = *p1;
            }
            buff[i] = '\0';
            rlen = atoi(buff);
            p2++;
            GPRS_Dlen = ((rlen >= (*pLen - (p2 - pBuff)))?(*pLen - (p2 - pBuff)):rlen);
            memcpy(GPRS_Data, p2,GPRS_Dlen);
            rlen = GPRS_Dlen;
            
            p1 = strstr(pBuff, "+IPD,");
            p2 = strchr(pBuff, ':');
            rlen += ((p2+1)-p1);
            FreeStr(pBuff, *pLen,p1-pBuff, rlen);
            if((*pLen -rlen) <=3)
                *pLen = 0;
            else
                *pLen -=rlen;
            #if DEBUG_EN
            printf("B[%d][%s]\r\n",*pLen, pBuff);
            #endif
        }
        #if GU906GSM_EN
        else if (strstr(pBuff, "+CMTI:") && ((p1 = strchr(pBuff, ',')) != 0)){   //+CMTI: "SM",2 有短信消息到来  
            rlen = 0;
            p1++;
            for(i = 0; *p1 != '\r' && *p1 != '\n' && *p1 != '\0' && rlen < sizeof(SIMDataID);i++, p1++){
                if(*p1 >= '0' && *p1 <= '9')
                    SIMDataID[rlen++] = *p1;
            }
            SIMDataID[rlen] = '\0'; 
        }
        else if ((p1 = strstr(pBuff, "+CMGR:")) != 0){ //读取到短消息
            GU906_ParsingSIM(p1);
        }
        #endif
        else if(strstr(pBuff,"[0000]") || strstr(pBuff,"Build Time")) 
        {
            #if (DEBUG_EN == 1)
            printf("restart...\r\n\r\n");
            #endif
            RestartGprs = 1;
        }
    }
     
    /*********************************************************
      * @function  GetFreeBuff
      * @role      处理掉缓存中多余的数据,同时也起到延时200ms的作用,
                   读取数据函数自带延时10ms,所以这里num=20,
                   GU906发送命令不能太快,不然GU906会因为处理不过来,而导致出错。
      * @input     None
      * @output    None
      * @return    None
      ********************************************************/
    static void GetFreeBuff(int num)
    {
        char buff[MAXRECVBUFF] = {0};
        int siz = 0;
        while(num--)
        {
            siz = usart4_Receive(buff,MAXRECVBUFF);
            if(siz)
            {
                GetRecvData(buff, &siz);    
            }
        }
    }
     
        
    /*********************************************************
      * @function  SendAT
      * @role      发送AT指令并接收
      * @input     gprs:要发送的参数
      * @output    out:返回的参数
      * @return    成功返回:_ATOK,失败返回:_ATERROR
      ********************************************************/
    static s8 SendAT(struct GprsData *gprs, char *out, u32 Delay)
    {
        int siz = 0;
        int i = 0;
        char *p = gprs->order;  
        u8 dat[2];
        u8 csq = 0;
        s8 ret = _ATERROR;
        char buff[MAXRECVBUFF] = {0};
        RestartGprs = 0;
     
    #if (DEBUG_EN == 1)
        printf("\r\n------------------------------\r\n");
        printf("len[%d]\r\n", gprs->olen);
        for(i = 0; i< gprs->olen; i++,++p)
            printf("%c", *p);
        printf("\r\n");
    #endif
        i = 0;
        p = NULL;
        GetFreeBuff(10);
        usart4_Send(gprs->order,gprs->olen);
        if((gprs->type == _GSMSEND) || (gprs->type == _ATATD)) 
        {
            ret = _ATOK;
            goto GU906_SENDATRET;
        }
     
        while(1)
        {
            for(i = 0;i<sizeof(buff);i++) 
                buff[i]=0;
            siz = 0; i = 0;
            while(siz == 0)
            {
                siz = usart4_Receive(buff,MAXRECVBUFF);
                if(siz){
                    #if (DEBUG_EN == 1)
                    printf("\r\nrecv:\r\n");
                    printf("[%s]\r\n",buff);
                    #endif
                    GetRecvData(buff, &siz);
                }
                if(i++ > Delay) 
                {
                    ret = _ATOTIME;
                    goto GU906_SENDATRET;
                }
            }
            
            if(RestartGprs){
                ret = _ATERROR;
                goto GU906_SENDATRET;
            }
            
            switch(gprs->type)
            {
                case _AT:
                case _ATE:   
                case _ATCNMI:
                case _ATCMGD:
                case _ATCMGF:
                case _ATCSMP:
                case _ATUCS2:
                case _ATATH :
                case _ATGSM :
                case _ATCSTT:
                case _ATCIICR:
                case _ATCIPCFG:
                case _ATCIPPACK:
                case _ATCIPSCONT:
                case _OPENDTU:
                case _CLOSEDTU:
                case _ATGB2312:
                    if(strstr(buff, "OK")){
                        ret = _ATOK;
                        goto GU906_SENDATRET;
                    }else if(strstr(buff, "ERROR") || strstr(buff,"NO CARRIER")) {
                        GetFreeBuff(100);
                        ret = _ATERROR;
                        goto GU906_SENDATRET;
                    }
                break;
                    
                case _ATCPMS:
                    if(strstr(buff, "OK") && strstr(buff, "+CPMS:")){
                         ret = _ATOK;
                         goto GU906_SENDATRET;
                    }else if(strstr(buff, "ERROR")){
                        ret = _ATERROR;
                        goto GU906_SENDATRET;
                    }
                    break;
                    
                case _ATESIM:
                    ret = _ATERROR;
                    if(strstr(buff, "OK"))
                    {
                        if((p = strstr(buff, "+ESIMS: ")) != 0)
                        {
                            p += 8;
                            if(1 == (*p -'0'))
                                ret = _ATOK;    
                        }
                        goto GU906_SENDATRET;
                    }
                    break;
                
                case _ATCMGS:
                    if(strstr(buff, ">")){
                        GetFreeBuff(1);
                        ret = _ATOK;
                        goto GU906_SENDATRET;
                    }
                    break;
     
                case _ATCSQ:
                    if(strstr(buff, "OK"))
                    {
                        if((p = strstr(buff, "+CSQ:")) != 0)
                        {
                            GPRS_ascii_to_hex((u8 *)(p+6), dat, 2);
                            csq = dat[0]*10 + dat[1];
                            #if DEBUG_EN
                            printf("信号:[%d]\r\n", csq);
                            #endif    
                            if (csq < 99 && csq >= GPRSCSQ){ //网络信号要大于GPRSCSQ(18)
                                ret = _ATOK;
                                goto GU906_SENDATRET;
                            } else {
                                ret = _ATERROR;
                                goto GU906_SENDATRET;
                            }    
                        }
                    }
                    else{
                        ret = _ATERROR;
                        goto GU906_SENDATRET;
                    }
                    break;
     
                case _ATCIPSTARTOK:
                    if(strstr(buff, "OK"))
                    {
                        if (strstr(buff, "+CIPSTART:")) {
                            ret = _ATOK;
                            goto GU906_SENDATRET;
                        }    
                        ret = _ATERROR;
                        goto GU906_SENDATRET;                    
                    }else if(strstr(buff, "ERROR")) {
                        ret = _ATERROR;
                        goto GU906_SENDATRET;
                    }
                    break;                
                
                case _ATCREG:
                    if(strstr(buff, "OK"))
                    {
                        if ((p = strstr(buff, "+CREG: ")) != 0)
                        {
                            p += 7;
                            if(('0' == *p) || ('5' == *p)) 
                            {
                                ret = _ATOK;
                                goto GU906_SENDATRET;
                            }
                        }    
                        ret = _ATERROR;
                        goto GU906_SENDATRET;                    
                    }else if(strstr(buff, "ERROR")) {
                        ret = _ATERROR;
                        goto GU906_SENDATRET;
                    }
                    break;
     
                case _ATCIPSEND:
                    if (strstr(buff, ">")) {
                        ret = _ATOK;
                        goto GU906_SENDATRET;
                    }
                    else if (strstr(buff, "ERROR")){
                        ret = _ATERROR;
                        goto GU906_SENDATRET;
                    }
                break;
     
                case _ATCIPMUX:
                    if(strstr(buff, "+CIPMUX: 0") && strstr(buff, "OK")) {
                        ret = _ATOK;
                        goto GU906_SENDATRET;
                    }else if (strstr(buff, "ERROR")){
                        ret = _ATERROR;
                        goto GU906_SENDATRET;
                    }
                    break;
     
                case _ATCIPMODE:
                    if(strstr(buff, "+CIPMODE: ") && strstr(buff, "OK")) {
                        ret = _ATOK;
                        goto GU906_SENDATRET;
                    }else if (strstr(buff, "ERROR")){
                        ret = _ATERROR;
                        goto GU906_SENDATRET;
                    }
                    break;
     
                case _GPRSSEND:
                    if(strstr(buff, "SEND OK")) {
                       ret = _ATOK;
                       goto GU906_SENDATRET;
                    }
                break;
     
                case _ATCMGR:
                    GetRecvData(buff, &siz);
                    ret = _ATOK;
                    goto GU906_SENDATRET;
                //break; 
     
                case _ATCIPCLOSE:
                    if (strstr(buff, "CLOSE OK") || strstr(buff, "+CME ERROR:")) {
                        ret = _ATOK;
                        goto GU906_SENDATRET;
                    }
                    else if(strstr(buff, "ERROR")){
                        ret = _ATERROR;
                        goto GU906_SENDATRET;   
                    }
                break;
     
                case _ATCIPSTART:
                    if(!GPRS_Dtu_ConLock)
                    {
                        if(strstr(buff, "CONNECT OK")){
                            ret = _ATOK;
                            goto GU906_SENDATRET;
                        }
                        else if(strstr(buff, "RECONNECTING") || strstr(buff, "ERROR") || strstr(buff, "CONNECT FAIL")){
                            GetFreeBuff(100);
                            ret = _ATERROR;
                            goto GU906_SENDATRET;
                        }                    
                    }
                    else if(strstr(buff, "OK")){
                        ret = _ATOK;
                        goto GU906_SENDATRET;
                    }
                    else if(strstr(buff, "ERROR")){
                        ret = _ATERROR;
                        goto GU906_SENDATRET;   
                    }
                    break;
                
                case _GSMSENDEND: 
                    GetFreeBuff(100);
                    ret = _ATOK;
                    goto GU906_SENDATRET; //忽略返回信息
                    /*
                    if(strstr(buff, "+CMGS:")) {
                        if(strstr(buff, "OK"))
                            return _ATOK;
                        lock = 1;
                    }
                    else if(lock && strstr(buff, "OK")) {
                        return _ATOK;
                    }else return _ATOK; //忽略返回信息
                    break;
                    */
                case _ATCIPSCONT_C:
                    if(strstr(buff,"OK"))
                    {
                        printf("Line:%d\r\n",__LINE__);
                        if(0 != (p = strstr(buff,"+CIPMODE: ")))
                        {
                            p += 10;
                            printf("Line:%d\r\n",__LINE__);
                            if(1 == (*p -'0'))
                            {
                                printf("Line:%d\r\n",__LINE__);
                                if(0 != (p = strstr(buff,"+CIPSTART: ")))
                                {
                                    printf("Line:%d\r\n",__LINE__);
                                    if(strstr(buff,"218.66.59.201") && strstr(buff,"8888"))
                                    {
                                        printf("DTU OK\r\n");
                                        GPRS_Dtu_ConLock = 1;
                                        ret = _ATOK;
                                        goto GU906_SENDATRET;
                                    }
                                }                        
                            }
                        }
                        GPRS_Dtu_ConLock = 0;
                        ret = _ATOK;
                        goto GU906_SENDATRET;
                    }else if(strstr(buff, "ERROR")){
                        ret = _ATERROR;
                        goto GU906_SENDATRET;   
                    }
                    break;
                    
                default: break; 
            }   
        }
        GU906_SENDATRET:
        return ret;
    }
     
    /*********************************************************
      * @function  GU906_ExecuteOrder
      * @role      执行命令
      * @input     None
      * @output    None
      * @return    成功返回:_ATOK,失败返回:_ATERROR,超时返回:_ATOTIME
      ********************************************************/
    static s8 GU906_ExecuteOrder(char *Order, u32 len, enum order type, u32 num)
    {
        u32 i = 0;
        u32 delay_time = 1000;
        s8 ret = _ATOTIME;
        struct GprsData gprs;
        
        if(type == _ATCIPSTART)
            delay_time = 4000;
        if(type == _GPRSSEND)
            delay_time = 10;
        
        gprs.order = Order;
        gprs.olen = len;
        gprs.type = type;
        while((ret = SendAT(&gprs, NULL, delay_time)) != _ATOK)
        {
            if(ret == _ATERROR) {
                if(++i >= num) return _ATERROR;
                delay_s(1);
            }else return _ATOTIME;
        }
        return _ATOK;
    }
     
    /*********************************************************
      * @function  GU906_init
      * @role      GSM初始化
      * @input     None
      * @output    None
      * @return    成功返回:_ATOK,失败返回:_ATERROR,超时返回:_ATOTIME
      ********************************************************/
    s8 GU906_init(void)
    {
        s8 ret = _ATOTIME;
     
        // 开回显:ATE1 关回显:ATE0
        if(_ATOK != (ret = GU906_ExecuteOrder(ATE(0), strlen(ATE(0)), _ATE, 2)))
            return ret;
        
        // 查询卡是否存在
        if(_ATOK != (ret = GU906_ExecuteOrder(ATESIM, strlen(ATESIM), _ATESIM, 10))) 
            return ret;
     
    #if GU906GSM_EN
        // 设置短信模式为text模式
        if(_ATOK != (ret = GU906_ExecuteOrder(ATCMGF, strlen(ATCMGF), _ATCMGF, 2))) 
            return ret;
     
        // 设置短信存储单元为SIM卡
        if(_ATOK != (ret = GU906_ExecuteOrder(ATCPMS, strlen(ATCPMS), _ATCPMS, 2))) 
            return ret;
     
        // 设置这组参数来了新信息存储起来
        if(_ATOK != (ret = GU906_ExecuteOrder(ATCNMI, strlen(ATCNMI), _ATCNMI, 2))) 
            return ret;
    #endif
        
        //删除SIM卡中的所有短信
        if(_ATOK != (ret = GU906_ExecuteOrder(ATCMGD, strlen(ATCMGD), _ATCMGD, 2))) 
            return ret;
     
        //查询信号强度 信号强度大于等于18才行
        while(_ATOK != (ret = GU906_ExecuteOrder(ATCSQ, strlen(ATCSQ), _ATCSQ, 60)))
        {
            if(ret == _ATOTIME) return ret;
        }
        return _ATOK;  
    }
     
    /*********************************************************
      * @function  GU906_Module_State
      * @role      判断GU906的状态
      * @input     None
      * @output    None
      * @return    成功返回:_ATOK,失败返回:_ATERROR,超时返回:_ATOTIME
      ********************************************************/
    s8 GU906_Module_State(void)
    {
        return GU906_ExecuteOrder(AT, strlen(AT), _AT, 0);
    }
     
    /*********************************************************
      * @function  GU906_TCP_Socket
      * @role      进行TCP连接
      * @input     IP地址与端口
      * @output    None
      * @return    成功返回:_ATOK,失败返回:_ATERROR,超时返回:_ATOTIME
      ********************************************************/
    s8 GU906_TCP_Socket(struct Gprs_Config *GprsCon)
    {
        char cipstart[100] = {0};
        s8 ret = _ATOTIME;
        
        if(GprsCon->server_ip == NULL || !GprsCon->server_port) return ret;
        if(!strlen((char *)GprsCon->server_ip)) return ret;
        
        //确保模块以及注册到GSM网络
        if(_ATOK != (ret = GU906_ExecuteOrder(ATCREG, strlen(ATCREG), _ATCREG, 2))) 
            return ret;
     
        //让模块激活 GPRS 网络,在需要反复建立 TCP 链接的场合可提高速度
        if(_ATOK != (ret = GU906_ExecuteOrder(ATCIICR, strlen(ATCIICR), _ATCIICR, 2))) 
            return ret;
        
        //查询当前是否有网络连接
        while(_ATOK == GU906_ExecuteOrder(ATCIPSTARTOK, strlen(ATCIPSTARTOK), _ATCIPSTARTOK, 0)) 
        {
            //关闭网络连接
            if(_ATOK != (ret = GU906_ExecuteOrder(ATCIPCLOSE, strlen(ATCIPCLOSE), _ATCIPCLOSE, 2))) 
                return ret;
            
            //保存设置
            if(_ATOK != (ret = GU906_ExecuteOrder(ATCIPSCONT(0), strlen(ATCIPSCONT(0)), _ATCIPSCONT, 2))) 
                return ret;
        }
     
        //单链接模式
        if(_ATOK != (ret = GU906_ExecuteOrder(ATCIPMUX, strlen(ATCIPMUX), _ATCIPMUX, 2))) 
            return ret;
     
        //非数据透传输模式
        if(_ATOK != (ret = GU906_ExecuteOrder(ATCIPMODE(0), strlen(ATCIPMODE(0)), _ATCIPMODE, 2))) 
            return ret;
     
        //自动启动连接命令
        if(_ATOK != (ret = GU906_ExecuteOrder(ATCIPCFG(0), strlen(ATCIPCFG(0)), _ATCIPCFG, 2))) 
            return ret;
     
        //心跳包设置
        if(_ATOK != (ret = GU906_ExecuteOrder(ATCIPPACK(0), strlen(ATCIPPACK(0)), _ATCIPPACK, 2))) 
            return ret;
        
        //连接到服务器
        //cipstart=(char *)mymalloc(100); 
        //if(cipstart==NULL) return -1; 
        sprintf(cipstart, ATCIPSTART,"TCP", GprsCon->server_ip, GprsCon->server_port);
        ret = GU906_ExecuteOrder(cipstart, strlen(cipstart), _ATCIPSTART, 3);
        
        //myfree(cipstart);
        return ret;
    }
     
    /*********************************************************
      * @function  GU906_DTU_Socket
      * @role      设置透传模式
      * @input     IP地址与端口
      * @output    None
      * @return    成功返回:_ATOK,失败返回:_ATERROR,超时返回:_ATOTIME
      ********************************************************/
    s8 GU906_DTU_Socket(struct Gprs_Config *GprsCon)
    {
        char atorder[100] = "";
        s8 ret = _ATOTIME;
        
        if(GprsCon->server_ip == NULL || !GprsCon->server_port) return ret;
        if(!strlen((char *)GprsCon->server_ip)) return ret;
        
        //atorder=(char *)mymalloc(100); 
        //if(atorder==NULL) return -1; 
        
        //查询数据透设置情况
        if(_ATOK != (ret = GU906_ExecuteOrder(ATCIPSCONT_C, strlen(ATCIPSCONT_C), _ATCIPSCONT_C, 2))) 
            goto GU906_DTU_SOCKETEND;
     
        if(!GPRS_Dtu_ConLock)
        {
            //设置账号
            if(_ATOK != (ret = GU906_ExecuteOrder(ATCSTT, strlen(ATCSTT), _ATCSTT, 2))) 
                goto GU906_DTU_SOCKETEND;
            
            //透传参数设置
            if(_ATOK != (ret = GU906_ExecuteOrder(ATCIPCFG(1), strlen(ATCIPCFG(1)), _ATCIPCFG, 2))) 
                goto GU906_DTU_SOCKETEND;
            
            //设置心跳
            if(_ATOK != (ret = GU906_ExecuteOrder(ATCIPPACK(0), strlen(ATCIPPACK(0)), _ATCIPPACK, 2))) 
                goto GU906_DTU_SOCKETEND;
            
            //设置设备注册包
            if(_ATOK != (ret = GU906_ExecuteOrder(ATCIPPACK(1), strlen(ATCIPPACK(1)), _ATCIPPACK, 2))) 
                goto GU906_DTU_SOCKETEND;
            
            //单链接模式
            if(_ATOK != (ret = GU906_ExecuteOrder(ATCIPMUX, strlen(ATCIPMUX), _ATCIPMUX, 2))) 
                goto GU906_DTU_SOCKETEND;
     
            //数据透传输模式
            if(_ATOK != (ret = GU906_ExecuteOrder(ATCIPMODE(1), strlen(ATCIPMODE(1)), _ATCIPMODE, 2))) 
                goto GU906_DTU_SOCKETEND;
     
            //保存设置
            sprintf(atorder, ATCIPSCONT(1),"TCP", GprsCon->server_ip, GprsCon->server_port);
            if(_ATOK != (ret = GU906_ExecuteOrder(atorder, strlen(atorder), _ATCIPSCONT, 2))) 
                goto GU906_DTU_SOCKETEND;
            
            GPRS_Dtu_ConLock = 1;
        }
     
        //建立数据透连接
        sprintf(atorder, ATCIPSTART, "TCP", GprsCon->server_ip, GprsCon->server_port);
        if(_ATOK != (ret = GU906_ExecuteOrder(atorder, strlen(atorder), _ATCIPSTART, 2))) 
            goto GU906_DTU_SOCKETEND;
     
        GU906_DTU_SOCKETEND:
        //myfree(atorder);
        return ret;
    }
     
    /*********************************************************
      * @function  GU906_DtuOrAT
      * @role      透传模式与AT模式转换
      * @input     None
      * @output    None
      * @return    成功返回:_ATOK,失败返回:_ATERROR,超时返回:_ATOTIME
      ********************************************************/
    s8 GU906_DtuOrAT(u8 type)
    {
        s8 ret = _ATERROR;
        if(type)
        {
            while(!GPRS_Dtu_ConLock)
            {
                //打开透传
                delay_s(2);
                if(_ATOK != (ret = GU906_ExecuteOrder(OPENDTU, strlen(OPENDTU), _OPENDTU, 0))) 
                    goto GU906_DTUOFFONEND;
                GPRS_Dtu_ConLock = 1;
            }
        }
        else
        {
            while(GPRS_Dtu_ConLock)
            {
                //关闭透传
                delay_s(2);
                if(_ATOK != (ret = GU906_ExecuteOrder(CLOSEDTU, strlen(CLOSEDTU), _CLOSEDTU, 0)))
                {
                    delay_s(1);
                    if(_ATOK != (GU906_Module_State()))
                        goto GU906_DTUOFFONEND;    
                }
                GPRS_Dtu_ConLock = 0;
            }    
        }
        
        GU906_DTUOFFONEND:
        return ret;
    }
    /*********************************************************
      * @function  GU906_GPRS_write
      * @role      gprs发送数据
      * @input     要发送的数据与数据长度
      * @output    None
      * @return    成功返回:_ATOK,失败返回:_ATERROR,超时返回:_ATOTIME
      ********************************************************/
    s8 GU906_GPRS_write(char* pdat, int len)
    {
        char atorder[20] = "";
        s8 ret = -1;
        if(strlen(pdat) == 0) return 0;
        
        //atorder = (char *)mymalloc(20); 
        //if(atorder == NULL) return -1; 
        
        if(!GPRS_Dtu_ConLock)//非数据透模式
        {
            //设置数据长度
            sprintf(atorder, ATCIPSEND(1), len);
            if(_ATOK != (ret = GU906_ExecuteOrder(atorder, strlen(atorder), _ATCIPSEND, 0))) 
                goto GU906_GPRS_WRITERET;
            
            //发送数据
            if(_ATOK != (ret = GU906_ExecuteOrder(pdat, len, _GPRSSEND, 0))) 
                goto GU906_GPRS_WRITERET;
        }
        else
        {
            //发送数据
            usart4_Send(pdat, len);
            ret = _ATOK;
        }
        GU906_GPRS_WRITERET:
        //myfree(atorder);
        return ret;
    }
     
    /*********************************************************
      * @function  GU906_GPRS_read
      * @role      查询是否接收到数据
      * @input     输出缓存大小
      * @output    接收到的数据
      * @return    接收到的数据长度
      ********************************************************/
    u32 GU906_GPRS_read(char *pout, int len)
    {
        int i = 0;
        
        if(!GPRS_Dtu_ConLock)
        {
            GPRSREAD:
            if(GPRS_Dlen){
                for(i = 0;(i < GPRS_Dlen) && (i < (len -1)); i++){
                    pout[i] = GPRS_Data[i];
                }
                memset(GPRS_Data, 0, sizeof(GPRS_Data));
                GPRS_Dlen = 0;
                return i;
            }else{
                GetFreeBuff(1);
                if(GPRS_Dlen)
                    goto GPRSREAD;
            }    
        }
        else
        {
            return usart4_Receive(pout,len);
        }
        return 0;
    }
     
    /*********************************************************
      * @function  GU906_make_phone
      * @role      向指定的手机拨号
      * @input     手机号
      * @output    None
      * @return    成功返回:_ATOK,失败返回:_ATERROR,超时返回:_ATOTIME
      ********************************************************/
    s8 GU906_make_phone(char *phone)
    {
        char mphone[20]="";
        sprintf(mphone, ATATD, phone);  
        return GU906_ExecuteOrder(mphone, strlen(mphone), _ATATD, 0);
    }
     
    /*********************************************************
      * @function  GU906_Answer_Phone
      * @role      等待电话被接听
      * @input     手机号
      * @output    None
      * @return    成功返回:_ATOK,失败返回:_ATERROR,超时返回:_ATOTIME
      ********************************************************/
    s8 GU906_Answer_Phone(u32 Delay)
    {
        int siz = 0;
        u32 i = 0;
        char buff[MAXRECVBUFF] = "";
        
        i = 0;
        while(1)
        {
            siz = 0;
            siz = usart4_Receive(buff,MAXRECVBUFF);
            if(siz){
                GetRecvData(buff, &siz);
                if(strstr(buff, "+COLP:") && strstr(buff, "OK")){
                    return _ATOK;
                }else if(strstr(buff, "NO CARRIER") || strstr(buff, "+CREG: 1") || strstr(buff, "ERROR")){
                    return _ATERROR;
                }
            }
            if(i++ > Delay) 
            {
                return _ATOTIME;
            }
        }
    }        
    /*********************************************************
      * @function  GU906_end_phone
      * @role      挂机
      * @input     None
      * @output    None
      * @return    成功返回:_ATOK,失败返回:_ATERROR,超时返回:_ATOTIME
      ********************************************************/
    s8 GU906_end_phone(void)
    {
        return GU906_ExecuteOrder(ATATH, strlen(ATATH), _ATATH, 0);
    }
     
    #if GU906GSM_EN
    /*********************************************************
      * @function  GU906_Chinese_text
      * @role      向指定的手机发送中文短信
      * @input     phone 手机号指针,pmsg 短消息指针
      * @output    None
      * @return    成功返回:_ATOK,失败返回:_ATERROR,超时返回:_ATOTIME
      ********************************************************/
    s8 GU906_Chinese_text(char *phone,char* pmsg)
    {
        s8 ret = _ATOTIME;
        char atphone[50] = "";
        char end[]={0x1A,0x00};
        
        if(strlen(phone) != 11)  return _ATERROR;
        //atphone = (char *)mymalloc(50); 
        //if(atphone == NULL) return -1; 
        
        //设置短消息为txet模式
        if(_ATOK != (ret = GU906_ExecuteOrder(ATCMGF, strlen(ATCMGF), _ATCMGF, 2))) 
            goto GU906_CHINESE_TEXTEND;
        
        //设置GB2312编码
        if(_ATOK != (ret = GU906_ExecuteOrder(ATGB2312, strlen(ATGB2312), _ATGB2312, 2))) 
            goto GU906_CHINESE_TEXTEND;
        
        //设置这组参数来了新信息存储起来 
        if(_ATOK != (ret = GU906_ExecuteOrder(ATCNMI, strlen(ATCNMI), _ATCNMI, 2))) 
            goto GU906_CHINESE_TEXTEND;
        
        //设置用户手机号
        sprintf(atphone,ATCMGS,phone);
        if(_ATOK != (ret = GU906_ExecuteOrder(atphone, strlen(atphone), _ATCMGS, 2))) 
            goto GU906_CHINESE_TEXTEND;
        
        //发送数据
        if(_ATOK == (ret = GU906_ExecuteOrder(pmsg, strlen(pmsg), _GSMSEND, 0))) 
        {
            ret = GU906_ExecuteOrder(end, 1, _GSMSENDEND, 0);
        }
        GU906_CHINESE_TEXTEND:
        //myfree(atphone);
        return ret;
    }
     
    /*********************************************************
      * @function  GU906_Read_SIM
      * @role      读取短信信息
      * @input     短信在SIM卡中的位置
      * @output    None
      * @return    成功返回:_ATOK,失败返回:_ATERROR,超时返回:_ATOTIME 
      ********************************************************/
    static s8 GU906_Read_SIM(char *pnum)
    {
        s8 ret = _ATOTIME;
        char cmgr[20]="";
        //读取短信的编码格式为GB2312
        if(_ATOK != (ret = GU906_ExecuteOrder(ATGB2312, strlen(ATGB2312), _ATGB2312, 2))) 
            return ret;
        
        //读取短消息
        sprintf(cmgr,ATCMGR,pnum);
        return GU906_ExecuteOrder(cmgr, strlen(cmgr), _ATCMGR, 2);
    }
     
    /*********************************************************
      * @function  GU906_DeleteSms
      * @role      删除SIM卡中的所有短信
      * @input     None
      * @output    None
      * @return    成功返回:_ATOK,失败返回:_ATERROR,超时返回:_ATOTIME 
      ********************************************************/
    static int GU906_DeleteSms(void)
    {
        return GU906_ExecuteOrder(ATCMGD, strlen(ATCMGD), _ATCMGD, 2);
    }
     
    /*********************************************************
      * @function  GU906_Read_UserSMS
      * @role      查询并读取短信数据
      * @input     None
      * @output    None
      * @return    0,接收到新数据,-1,未接收到新数据
      ********************************************************/
    s8 GU906_Read_UserSMS(void)
    {
        SMSREAD:
        if(strlen(SIMDataID)){
            #if DEBUG_EN
            printf("SIMDataID[%s]\r\n",SIMDataID);
            #endif
            GU906_Read_SIM(SIMDataID);
            GU906_DeleteSms();
            memset(SIMDataID,0,sizeof(SIMDataID));
            return 0;
        }else{
            GetFreeBuff(1);
            if(strlen(SIMDataID))
                goto SMSREAD;
        }
        return -1;
    }
    #endif

    gu906.文件如下
    #ifndef _GU906_H_
    #define _GU906_H_
    #include "sys.h"
     
    #define GU906GSM_EN   1    //是否开启短信功能 
    #define GPRSCSQ       18   //信号强度,在使用GPRS功能时,最低要求信号强度不得低于18
     
    #define _ATOK          0  //执行成功
    #define _ATERROR      -1  //执行错误
    #define _ATOTIME      -2  //执行超时
    #define _LINKNOT      -3  //掉线了
     
    struct Gprs_Config{
        u8 *server_ip;     //服务器IP
        u32 server_port;   //服务器端口
    };
     
    #if GU906GSM_EN
    //根据实际内存情况而定
    struct user_simdata{
        char phone[15];  //用户手机号
        char dev[50];    //用户使用的设备
        char date[50];   //接收时间
        char data[200];  //接收的数据
    };
    extern struct user_simdata sim;
    s8 GU906_Read_UserSMS(void);
    s8 GU906_Chinese_text(char *phone,char* pmsg);
    #endif
     
    s8  GU906_init(void);
    s8  GU906_Module_State(void);
    s8  GU906_TCP_Socket(struct Gprs_Config *GprsCon);
    s8  GU906_DTU_Socket(struct Gprs_Config *GprsCon);
    s8  GU906_GPRS_write(char* pdat, int len);
    u32 GU906_GPRS_read(char *pout, int len);
     
    s8  GU906_make_phone(char *phone);
    s8  GU906_Answer_Phone(u32 Delay);
    s8  GU906_end_phone(void);
    s8  GU906_DtuOrAT(u8 type);
     
     
    #endif
    main.c

    #include <string.h>
    #include <stdlib.h>
    #include "stdio.h"
    #include "delay.h"
    #include "GU906.h"
    #include "config.h"
    #include "usart1.h"
    #include "usart4.h"
     
    int main(void)
    {    
        u32 ret = 0;
        char buff[200]="";
        struct Gprs_Config GprsCon;
        delay_init();
        usart4_Configuration(115200);    //GU900默认通信波特率是115200
        usart1_Configuration(115200);    //调试输出端口波特率设置
        delay_s(5);                      //刚上电 要等待10秒,等待GU906模块初始化完成
        
        printf("\r\nBegin...\r\n");
        GprsCon.server_ip = (u8 *)"210.66.59.211"; //GPRS通信时的服务器IP
        GprsCon.server_port = atoi("8888");        //GPRS通信时的服务器端口
        
        //GSM初始化
        while(1)
        {
            if(_ATOK == GU906_init()){
                printf("GU906 init ok.\r\n\r\n");
                break;
            }
            printf("init error.\r\n");
            delay_s(1);
        }
        
        /*****************************************************************************/
        //GU906 GPRS TCP 非透传模式通信测试
        while(1)
        {
            if(_ATOK == GU906_TCP_Socket(&GprsCon))
            {
                printf("socket ok\r\n\r\n");
                delay_s(3);    
                while(1)
                {
                    ret = GU906_GPRS_read(buff, 200);
                    if(ret)
                    {
                        printf("GPRS:[%d][%s]\r\n", ret,buff);
                        if(_ATOK != GU906_GPRS_write((char *)"OK", 2))
                        {
                            printf("Send Error.\r\n");
                        }                    
                    }
                }
            }
            printf("GU906_TCP_Socket ERROR.\r\n");
            while(1);
        }
        /*******************************************************************************/
        
        /*****************************************************************************/
        //GU906 GPRS TCP 透传模式通信测试
        while(1)
        {
            if(_ATOK == GU906_DTU_Socket(&GprsCon))
            {
                printf("socket ok\r\n\r\n");
                delay_s(3);    
                while(1)
                {
                    ret = GU906_GPRS_read(buff, 200);
                    if(ret)
                    {
                        printf("GPRS:[%d][%s]\r\n", ret,buff);
                        if(_ATOK != GU906_GPRS_write((char *)buff, ret))
                        {
                            printf("Send Error.\r\n");
                        }                    
                        
                        if(strstr(buff,"CLOSE"))
                        {
                            GU906_DtuOrAT(0);
                        }
                        if(strstr(buff,"OPEN"))
                        {
                            GU906_DtuOrAT(1);
                        }
                    }
                }
            }
            printf("GU906_TCP_Socket ERROR.\r\n");
            while(1);
        }
        /*******************************************************************************/
        
        /*****************************************************************************/
        //发送短信测试
        while(_ATOK != GU906_Chinese_text("18750******", "123abd 测试"))
        {
            delay_s(5);
        }
     
        //接收短信测试
        while(1)
        {
            if(0 == GU906_Read_UserSMS())
            {
                printf("------------------------------\r\n");
                printf("号码:%s\r\n",sim.phone);
                printf("设备:%s\r\n",sim.dev);
                printf("时间:%s\r\n",sim.date);
                printf("信息:%s\r\n",sim.data);
            }
            delay_ms(50);
        }
        /******************************************************************************/
        
        /*****************************************************************************/
        //打电话测试
        if (_ATOK == GU906_make_phone("18750******"))
        {
            //等待接听
            while(_ATOTIME == GU906_Answer_Phone(1000))
            {
                printf("make ok\r\n");
                GU906_end_phone();            
            }
            printf("make ok\r\n");
        }
        else 
        {
            printf("make error\r\n");
            //SoftReset();
        }
     

    展开全文
  • C语言中局部变量和全局变量变量的存储类别(static,extern,auto,register) 1----局部变量和全局变量 在讨论函数的形参变量时曾经提到,形参变量只在被调用期间才分配内存单元,调用结束立即释放。这一点表明形参变量...

    C语言中局部变量和全局变量变量的存储类别(static,extern,auto,register)

    1----局部变量和全局变量
    在讨论函数的形参变量时曾经提到,形参变量只在被调用期间才分配内存单元,调用结束立即释放。这一点表明形参变量只有在函数内才是有效的,离开该函数就不能再使用了。这种变量有效性的范围称变量的作用域。不仅对于形参变量,C语言中所有的量都有自己的作用域。变量说明的方式不同,其作用域也不同。C语言中的变量,按作用域范围可分为两种,即局部变量和全局变量。

    1.1 局部变量
    局部变量也称为内部变量。局部变量是在函数内作定义说明的。其作用域仅限于函数内,离开该函数后再使用这种变量是非法的。
    关于局部变量的作用域还要说明以下几点:

    1. 主函数中定义的变量也只能在主函数中使用,不能在其它函数中使用。同时,主函数中也不能使用其它函数中定义的变量。因为主函数也是一个函数,它与其它函数是平行关系。这一点是与其它语言不同的,应予以注意。
    2. 形参变量是属于被调函数的局部变量,实参变量是属于主调函数的局部变量。
    3. 允许在不同的函数中使用相同的变量名,它们代表不同的对象,分配不同的单元,互不干扰,也不会发生混淆。如在前例中,形参和实参的变量名都为n,是完全允许的。
    4. 在复合语句中也可定义变量,其作用域只在复合语句范围内。

    1.2 全局变量
    全局变量也称为外部变量,它是在函数外部定义的变量。它不属于哪一个函数,它属于一个源程序文件。其作用域是整个源程序。在函数中使用全局变量,一般应作全局变量说明。只有在函数内经过说明的全局变量才能使用。全局变量的说明符为extern。但在一个函数之前定义的全局变量,在该函数内使用可不再加以说明。

    2. 变量的存储类别
    2.1 动态存储方式与静态动态存储方式
    前面已经介绍了,从变量的作用域(即从空间)角度来分,可以分为全局变量和局部变量。
    从另一个角度,从变量值存在的作时间(即生存期)角度来分,可以分为静态存储方式和动态存储方式。

    • 静态存储方式:是指在程序运行期间分配固定的存储空间的方式。
    • 动态存储方式:是在程序运行期间根据需要进行动态的分配存储空间的方式。

    用户存储空间可以分为三个部分:

    1. 程序区;
    2. 静态存储区;
    3. 动态存储区;

    全局变量全部存放在静态存储区,在程序开始执行时给全局变量分配存储区,程序行完毕就释放。在程序执行过程中它们占据固定的存储单元,而不动态地进行分配和释放;

    动态存储区存放以下数据:

    1. 函数形式参数;
    2. 自动变量(未加static声明的局部变量);
    3. 函数调用实的现场保护和返回地址;

    对以上这些数据,在函数开始调用时分配动态存储空间,函数结束时释放这些空间。
    在c语言中,每个变量和函数有两个属性:数据类型和数据的存储类别。

    2.2 auto变量
    函数中的局部变量,如不专门声明为static存储类别,都是动态地分配存储空间的,数据存储在动态存储区中。函数中的形参和在函数中定义的变量(包括在复合语句中定义的变量),都属此类,在调用该函数时系统会给它们分配存储空间,在函数调用结束时就自动释放这些存储空间。这类局部变量称为自动变量。自动变量用关键字auto作存储类别的声明。

    a是形参,b,c是自动变量,对c赋初值3。执行完f函数后,自动释放a,b,c所占的存储单元。
    关键字auto可以省略,auto不写则隐含定为“自动存储类别”,属于动态存储方式。

    2.3 用static声明局部变量
    有时希望函数中的局部变量的值在函数调用结束后不消失而保留原值,这时就应该指定局部变量为“静态局部变量”,用关键字static进行声明。

    对静态局部变量的说明:
    1)静态局部变量属于静态存储类别,在静态存储区内分配存储单元。在程序整个运行期间都不释放。而自动变量(即动态局部变量)属于动态存储类别,占动态存储空间,函数调用结束后即释放。
    2)静态局部变量在编译时赋初值,即只赋初值一次;而对自动变量赋初值是在函数调用时进行,每调用一次函数重新给一次初值,相当于执行一次赋值语句。
    3)如果在定义局部变量时不赋初值的话,则对静态局部变量来说,编译时自动赋初值0(对数值型变量)或空字符(对字符变量)。而对自动变量来说,如果不赋初值则它的值是一个不确定的值。

    2.4 register变量
    为了提高效率,C语言允许将局部变量得值放在CPU中的寄存器中,这种变量叫“寄存器变量”,用关键字register作声明。

    说明:

    1. 只有局部自动变量和形式参数可以作为寄存器变量;
    2. 一个计算机系统中的寄存器数目有限,不能定义任意多个寄存器变量;
    3. 局部静态变量不能定义为寄存器变量。

    2.5 用extern声明外部变量
    外部变量(即全局变量)是在函数的外部定义的,它的作用域为从变量定义处开始,到本程序文件的末尾。如果外部变量不在文件的开头定义,其有效的作用范围只限于定义处到文件终了。如果在定义点之前的函数想引用该外部变量,则应该在引用之前用关键字extern对该变量作“外部变量声明”。表示该变量是一个已经定义的外部变量。有了此声明,就可以从“声明”处起,合法地使用该外部变量。

    说明:在本程序文件的最后1行定义了外部变量A,B,但由于外部变量定义的位置在函数main之后,因此本来在main函数中不能引用外部变量A,B。现在我们在main函数中用extern对A和B进行“外部变量声明”,就可以从“声明”处起,合法地使用该外部变量A和B。

    展开全文
  • JavaScript变量 JavaScript使用var关键字声明变量。声明变量的5种常规用法如下: var a; //声明单个变量。var关键字与变量名之间以空格分隔 var b, c; //声明多个变量变量之间以逗号分隔 var d = 1; //声明...
  • c语言中形参与实参: 形参 form parameter ...//在函数中,形参就可以当作是一个局部变量。 if ( a>b ) return a; else return b; } 函数调用 int main() { int a=3,b=5 ; printf( "max=%d\n" , max(a,b) )
  • 全局变量的生命周期一直到程序的结束,全局变量是静态存储方式。 例: #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; /* a 就是一个全局变量*/ int a = 2; int main(int argc, ch...
  • 上一次给大家讲了C++数据类型还有C++注释,在以后的代码中,随着代码的增多,注释是必不可少的,它会提示我们代码功能,变量含义等等。所以我们要熟练掌握注释,我们也拓展了数据类型,数据类型是C++比较基础也比较...
  • 什么时候初始化 根据 C++ 标准,全局变量的初始化要在 main 函数执行前完成,常识无疑,但是这个说法...答案是既有编译时,也可能会有运行时(seriously), 从语言的层面来说,全局变量的初始化可以划分为以下两
  • 1.用户定义的变量用户定义的变量有字母数字及下划线组成,并且变量名的第一个字符不能为数字.与其它UNIX名字一样,变量名是大小写敏感的.对于变量,用户可按如下方式赋值:name = value在引用变量时,需在前面加$符号,...
  • C语言中局部变量与全局变量在内存中的存放位置
  • *******************************概念***************************************************************************************************************************首先得明白全局变量、静态全局变量、局部变量...
  • return 局部变量

    千次阅读 2015-08-24 13:15:18
    一般的来说,函数是可以返回局部变量的。 局部变量的作用域只在函数内部,在函数返回后,局部变量的内存已经释放了。因此,如果函数返回的是局部变量的值,不涉及地址,程序不会出错。但是如果返回的是局部变量的...
  • 成员变量和局部变量同名 在同一个作用域内不允许定义同名的多个变量。   在一个方法内,可以定义和成员变量同名的局部变量或参数,此时成员变量被屏蔽。此时如果想要访问成员变量,可以通过 this 关键字来...
  • 局部变量:在函数内定义的变量,作用域限于函数内。 说明:(1)主函数定义的变量不能再其他函数中使用,主函数也不能使用其他函数定义的变量。 (2)形参变量属于被调函数的局部变量,实参变量属于主调函数的局部...
  • C语言中局部变量和全局变量变量的存储类别(static,extern,auto,register) 1----局部变量和全局变量 在讨论函数的形参变量时曾经提到,形参变量只在被调用期间才分配内存单元,调用结束立即释放。这一点表明形参变量...
  • 当我们同时编译多个文件时,所有未加static前缀的全局变量和函数都具有全局可见性。为理解这句话,我举例来说明。我们要同时编译两个源文件,一个是a.c,另一个是main.c。 下面是a.c的内容 chara='A';//...
  • C语言中局部变量和全局变量 变量的存储类别(static,extern,auto,register)   局部变量和全局变量 在讨论函数的形参变量时曾经提到,形参变量只在被调用期间才分配内存单元,调用结束立即释放。这一点表明形参...
  • static作用(修饰函数、局部变量、全局变量)

    万次阅读 多人点赞 2018-12-09 20:52:50
    C语言:static作用(修饰函数、局部变量、全局变量) 一、 static全局变量与普通的全局变量有什么区别 ? 全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。  全局变量本身就是静态存储方式, ...
  • 局部静态变量Static详解

    万次阅读 多人点赞 2017-03-10 18:01:40
    局部变量前加上“static”关键字,就成了静态局部变量。静态局部变量存放在内存的全局数据区。函数结束时,静态局部变量不会消失,每次该函数调用 时,也不会为其重新分配空间。它始终驻留在全局数据区,直到程序...
  • C语言学习中的知识点,字符串指针和字符数组的区别,静态全局变量、静态局部变量、全局变量和局部变量的区别, 有错误的地方请大家指正! 以下程序用VC++6.0调试 先说说字符串指针和字符数组的区别 1. 相同点: /*...
  • 1、栈区(stack)— 由编译器自动分配释放,存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。 2、堆区(heap) — 一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收 。注意它与...
  • JS 基础之全局变量,局部变量

    千次阅读 2018-08-23 09:56:29
    本章将概要介绍一些编写高质量JavaScript的最佳实践、模式和习惯,比如避免全局变量、使用单var声明、预缓存循环中的length、遵守编码约定等等。本章还包括一些编程习惯,这些习惯跟具体的代码关系不大,而是更多...
  • 可以使用字符来定义和创建 JavaScript 对象,定义 JavaScript 对象可以跨越多行,空格跟换行不是必须的。 可以说 "JavaScript 对象是变量的容器"。但是,我们通常认为 "JavaScript 对象是键值对的容器"。 键值对...
  • 全局变量和局部变量详解

    千次阅读 2014-09-03 22:52:48
    1.局部变量 (1)局部变量也称为内部变量,他是在函数体内作定义说明的,其作用域仅限于函数内部,离开该函数后再使用这种变量是非法的。 如:func () { int x; 局部变量x的作用域 在函数体内  //...... ...
  •  一、局部变量局部变量也称为内部变量。局部变量是在函数内作定义说明的。其作用域仅限于函数内, 离开该函数后再使用这种变量是非法的。例如:int f1(int a) /*函数f1*/ { int b,c;……}int f2(int x)...
  • JAVA 面向对象 成员变量和局部变量

    万次阅读 多人点赞 2016-07-20 18:08:42
    局部变量 成员变量和局部变量的运行机制存在很大差异,下面我们看看差异在哪. 成员变量 成员变量指的是在类里定义的变量. 局部变量指的是在方法里定义的变量. 下面我给出Java程序中的变量划分图: 成员变量被...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 140,573
精华内容 56,229
关键字:

局部变量前面的字符