-
局部静态变量static详解
2018-05-22 08:03:20原帖地址： https://blog.csdn.net/zkangaroo/article/details/61202533在局部变量前加上“static”关键字，就成了静态局部变量。静态局部变量存放在内存的全局数据区。函数结束时，静态局部变量不会消失，每次该...展开全文原帖地址： https://blog.csdn.net/zkangaroo/article/details/61202533
1.在局部变量前加上“static”关键字，就成了静态局部变量。
2.静态局部变量存放在内存的全局数据区。函数结束时，静态局部变量不会消失，每次该函数调用时，也不会为其重新分配空间。它始终驻留在全局数据区，直到程序运行结束。
3.静态局部变量的初始化与全局变量类似．如果不为其显式初始化，则C++自动为其 初始化为0。
4.静态局部变量与全局变量共享全局数据区，但静态局部变量只在定义它的函数中可见。
5.静态局部变量与局部变量在存储位置上不同，使得其存在的时限也不同，导致对这两者操作的运行结果也不同。
例如，下面的程序定义了全局变量、静态局部变量和局部变量：
#include <iostream.h>
int n = 1; //全局变量
void func()
{
static int a = 2; // 静态局部变量
int b = 5; // 局部变量
a += 2;
n += 12;
b += 5;
cout << "a:" << a
<< " b:" << b
<< " n:" << n << endl;
}
void main()
{
static int a; // 静态局部变量
int b = -10; // 局部变量
cout << "a:" << a
<< " b:" << b
<< " n:" << n << endl;
b += 4;
func();
cout << "a:" << a
<< " b:" << b
<< " n:" << n << endl;
n += 10;
func();
}
运行结果为：
a:0 b:-10 n:l
a:4 b:10 n:13
a:0 b:-6 n:13
a:6 b:10 n:35
程序中主函数main()两次调用了func()函数，从运行结果可以看出，程序控制每次进入func()函数时，局部变量b都被初始化。 而静态局部 变量a仅在第一次调用时被初始化，第二次进入该函数时，不再进行初始化，这时它的值是第一次调用后的结果值4。 main()函数中的变量a和b与func()函数中的变量a和b空间位置是不一样的，所以相应的值也不一样。
静态局部变量的用途有许多：可以使用它确定某函数是否被调用过。使用它保留多次调用的值。
对静态局部变量的说明：
(1) 静态局部变量在静态存储区内分配存储单元。在程序整个运行期间都不释放。而自动变量（即动态局部变量）属于动态存储类别，存储在动态存储区空间(而不是静态存储区空间)，函数调用结束后即释放.
(2) 为静态局部变量赋初值是在编译时进行值的，即只赋初值一次，在程序运行时它已有初值。以后每次调用函数时不再重新赋初值而只是保留上次函数调用结束时的 值。而为自动变量赋初值，不是在编译时进行的，而是在函数调用时进行，每调用一次函数重新给一次初值，相当于执行一次赋值语句。
(3) 如果在定义局部变量时不赋初值的话，对静态局部变量来说，编译时自动赋初值0(对数值型变量)或空字符(对字符型变量)。而对自动变量来说，如果不赋初 值，则它的值是一个不确定的值。这是由于每次函数调用结束后存储单元已释放，下次调用时又重新另分配存储单元，而所分配的单元中的值是不确定的。
(4) 虽然静态局部变量在函数调用结束后仍然存在，但其他函数是不能引用它的，也就是说，在其他函数中它是“不可见”的。
-
局部静态变量Static详解
2019-10-30 21:30:30在局部变量前加上“static”关键字，就成了静态局部变量。静态局部变量存放在内存的全局数据区。函数结束时，静态局部变量不会消失，每次该函数调用 时，也不会为其重新分配空间。它始终驻留在全局数据区，直到程序...展开全文在局部变量前加上“static”关键字，就成了静态局部变量。静态局部变量存放在内存的全局数据区。函数结束时，静态局部变量不会消失，每次该函数调用 时，也不会为其重新分配空间。它始终驻留在全局数据区，直到程序运行结束。静态局部变量的初始化与全局变量类似．如果不为其显式初始化，则C++自动为其 初始化为0。
静态局部变量与全局变量共享全局数据区，但静态局部变量只在定义它的函数中可见。静态局部变量与局部变量在存储位置上不同，使得其存在的时限也不同，导致对这两者操作 的运行结果也不同。
例如，下面的程序定义了全局变量、静态局部变量和局部变量：
#include <iostream.h>
void func();
int n = 1; //全局变量
void main()
{
static int a; // 静态局部变量
int b = -10; // 局部变量
cout << "a:" << a
<< " b:" << b
<< " n:" << n << endl;
b += 4;
func();
cout << "a:" << a
<< " b:" << b
<< " n:" << n << endl;
n += 10;
func();
}
void func()
{
static int a = 2; // 静态局部变量
int b = 5; // 局部变量
a += 2;
n += 12;
b += 5;
cout << "a:" << a
<< " b:" << b
<< " n:" << n << endl;
}运行结果为：
a:0 b:-10 n:l
a:4 b:10 n:13
a:0 b:-6 n:13
a:6 b:10 n:35
程序中主函数main()两次调用了func()函数，从运行结果可以看出，程序控制每次进入func()函数时，局部变量b都被初始化。而静态局部 变量a仅在第一次调用时被初始化，第二次进入该函数时，不再进行初始化，这时它的值是第一次调用后的结果值4。 main()函数中的变量a和b与func()函数中的变量a和b空间位置是不一样的，所以相应的值也不一样。关于变量作用域和可见性的进一步讨论见第6 章。
静态局部变量的用途有许多：可以使用它确定某函数是否被调用过。使用它保留多次调用的值。对静态局部变量的说明：
(1) 静态局部变量在静态存储区内分配存储单元。在程序整个运行期间都不释放。而自动变量（即动态局部变量）属于动态存储类别，存储在动态存储区空间(而不是静态存储区空间)，函数调用结束后即释放。
(2) 为静态局部变量赋初值是在编译时进行值的，即只赋初值一次，在程序运行时它已有初值。以后每次调用函数时不再重新赋初值而只是保留上次函数调用结束时的 值。而为自动变量赋初值，不是在编译时进行的，而是在函数调用时进行，每调用一次函数重新给一次初值，相当于执行一次赋值语句。(3) 如果在定义局部变量时不赋初值的话，对静态局部变量来说，编译时自动赋初值0(对数值型变量)或空字符(对字符型变量)。而对自动变量来说，如果不赋初 值，则它的值是一个不确定的值。这是由于每次函数调用结束后存储单元已释放，下次调用时又重新另分配存储单元，而所分配的单元中的值是不确定的。
(4) 虽然静态局部变量在函数调用结束后仍然存在，但其他函数是不能引用它的，也就是说，在其他函数中它是“不可见”的。
————————————————
版权声明：本文为CSDN博主「ShininGold」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/zkangaroo/article/details/61202533
-
C++基础——局部静态变量Static
2020-02-25 19:48:59在局部变量前加上“static”关键字，就成了静态局部变量。 静态局部变量存放在内存的全局数据区。 函数结束时，静态局部变量不会消失，每次该函数调用 时，也不会为其重新分配空间。它始终驻留在全局数据区，直到...展开全文- 在局部变量前加上“static”关键字，就成了静态局部变量。
- 静态局部变量存放在内存的全局数据区。
- 函数结束时，静态局部变量不会消失，每次该函数调用 时，也不会为其重新分配空间。它始终驻留在全局数据区，直到程序运行结束。静态局部变量的初始化与全局变量类似．
- 如果不为其显式初始化，则C++自动为其 初始化为0。
- 静态局部变量与全局变量共享全局数据区，但静态局部变量只在定义它的函数中可见。静态局部变量与局部变量在存储位置上不同，使得其存在的时限也不同，导致对这两者操作 的运行结果也不同。
下面的程序定义了全局变量、静态局部变量和局部变量：
#include <iostream> using namespace std; int n = 1; //全局变量 void func() { static int a = 2; // 静态局部变量 int b = 5; // 局部变量 a += 2; n += 12; b += 5; cout << "a:" << a << " b:" << b << " n:" << n << endl; } void main() { static int a; // 静态局部变量 int b = -10; // 局部变量 cout << "a:" << a << " b:" << b << " n:" << n << endl; b += 4; func(); cout << "a:" << a << " b:" << b << " n:" << n << endl; n += 10; func(); system("pause"); }
程序中主函数main()两次调用了func()函数，从运行结果可以看出，程序控制每次进入func()函数时，局部变量b都被初始化。而静态局部 变量a仅在第一次调用时被初始化，第二次进入该函数时，不再进行初始化，这时它的值是第一次调用后的结果值4。 main()函数中的变量a和b与func()函数中的变量a和b空间位置是不一样的，所以相应的值也不一样。
静态局部变量的说明：
(1) 静态局部变量在静态存储区内分配存储单元。在程序整个运行期间都不释放。而自动变量（即动态局部变量）属于动态存储类别，存储在动态存储区空间(而不是静态存储区空间)，函数调用结束后即释放。
(2) 为静态局部变量赋初值是在编译时进行值的，即只赋初值一次，在程序运行时它已有初值。以后每次调用函数时不再重新赋初值而只是保留上次函数调用结束时的 值。而为自动变量赋初值，不是在编译时进行的，而是在函数调用时进行，每调用一次函数重新给一次初值，相当于执行一次赋值语句。
(3) 如果在定义局部变量时不赋初值的话，对静态局部变量来说，编译时自动赋初值0(对数值型变量)或空字符(对字符型变量)。而对自动变量来说，如果不赋初 值，则它的值是一个不确定的值。这是由于每次函数调用结束后存储单元已释放，下次调用时又重新另分配存储单元，而所分配的单元中的值是不确定的。
(4) 虽然静态局部变量在函数调用结束后仍然存在，但其他函数是不能引用它的，也就是说，在其他函数中它是“不可见”的。
-
单片机之静态局部变量static
2020-08-03 03:48:39如果定义成局部变量，则必须定义成静态局部变量，静态局部变量是在编译时赋初值的，只赋初值一次，以后每次调用函数时不再重新赋初值而只是保留上次函数调用结束时的值。 -
C#中static静态变量的用法实例
2020-12-31 03:18:46本文实例讲述了C#中static静态变量的用法。分享给大家供大家参考。具体如下： 使用 static 修饰符声明属于类型本身而不是属于特定对象的静态成员static修饰符可用于类、字段、方法、属性、运算符、事件和构造函数，... -
PHP static局部静态变量和全局静态变量总结
2020-12-19 03:46:33即使局部静态变量定义时没有赋初值，系统会自动赋初值0（对数值型变量）或空字符（对字符变量）；静态变量的初始值为0。4.当多次调用一个函数且要求在调用之间保留某些变量的值时，可考虑采用静态局部变量。虽然用... -
静态局部变量和静态全程变量static。
2019-01-01 13:28:04static 是 C/C++ 中很常用的修饰符，它被用来控制变量的存储方式和可见性。 1.1 static 的引入 我们知道在函数内部定义的变量，当程序执行到它的定义处时，编译器为它在栈上分配空间，函数在栈上分配的空间在此...展开全文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 为 0extern 存储类
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;
}
#endifgu906.文件如下
#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();
}
-
局部变量存储区域静态变量存储区域static变量存储区域【转载】
2018-09-09 09:08:18常见的存储区域可分为： ...里面的变量通常是局部变量、函数参数等。 2、堆 由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。如果程序员没有释放掉，... -
PHP中的静态变量及static静态变量使用详解
2020-12-18 11:37:25一般的函数内变量在函数结束后会释放，比如局部变量，但是静态变量却不会。就是说，下次再调用这个函数的时候，该变量的值会保留下来。 只要在变量前加上关键字static，该变量就成为静态变量了。 <?php ... -
static静态局部变量的使用技巧
2020-07-14 15:50:36本文主要讲了static静态局部变量的使用技巧，希望对你的学习有所帮助。 -
Java语言 static （静态变量、实例变量、局部变量、静态方法）
2018-04-16 21:56:31（一）静态变量：线程非安全 1、静态变量：使用static关键字定义的变量。static可以修饰变量和方法，也有static静态代码块。被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的... -
静态变量static
2018-09-05 21:09:07静态变量： ...所有的全局变量都是静态变量，而局部变量只有定义时加上类型修饰符static，才为局部静态变量。 静态变量并不是说其就不能改变值，不能改变值的量叫常量。 其拥有的值是可变的 ，而且... -
C++全局变量、局部变量、全局静态变量、局部静态变量
2018-09-05 16:18:311、static关键字作用 1.1 隐藏 eg: //a.c文件中 char a = 'A'; void msg() { printf("Hello\n"); } //main.c文件中 extern char a; printf("%c",a); 输出结... -
static静态变量的理解
2018-07-22 17:26:37static静态变量的理解 静态变量 类型说明符是static。静态变量属于静态存储方式，其存储空间为内存中的静态数据区（在静态存储区内分配存储单元），该区域中的数据在整个程序的运行期间一直占用这些存 -
普通局部变量与static局部变量的区别
2019-05-08 17:57:53普通局部变量与static局部变量的区别 内存分配和释放 1、普通局部变量只有执行到变量定义的语句的时候才分配空间。 2、static局部变量在编译阶段（函数还没有执行），变量的空间已经分配。 3、普通局部变量离开作用... -
C语言中的 static变量（全局和局部）、static函数总结
2019-09-12 00:19:26同步博文：static 变量:静态局部变量:静态全局变量:static 函数…..:内部函数（又称静态函数）:外部函数:[案例]外部函数应用。开心分享： 本博文的简述or解决问题？ 详情： 见简介 同步博文： 本篇的csdn/... -
Java 变量类型：静态变量（static修饰）、成员变量、局部变量
2020-07-07 19:12:27１．静态变量（类变量、全局变量，无论一个类创建了多少个对象，类只拥有类变量的一份拷贝） 静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量 ２．成员变量（实例变量，一般情况下应该把... -
【C#】全局变量、全局静态变量、局部变量、局部静态变量的区别
2018-10-18 10:06:32C#中变量分为：全局变量、静态全局变量、局部变量和静态局部变量。 1、按存储区域分 （1）全局变量、静态全局变量和静态局部变量都存放在内存的静态存储区域； （2）局部变量存放在内存的栈区。 2... -
static--静态变量与普通变量的区别
2019-03-12 09:59:09静态变量与普通变量的区别 全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽... -
python如何设置静态变量
2020-12-17 01:13:01换个角度来看这个问题，函数中的静态变量其实可以看做是函数的一个内部变量，而不是调用期间生成的局部变量。所以这里介绍一种使用装饰器的方法给函数添加这样的内部变量。 def static_vars(**kwargs): def ... -
单例模式：静态局部变量方式
2020-08-30 22:50:39一种简单的单例模式，使用静态局部变量。 为什么是静态局部变量可以保证线程安全性？ 原因是Magic Static特性。如果变量在初始化时，并发线程同时进入到static声明语句，并发线程会阻塞等待初始化结束。这样可以... -
什么是全局变量，局部变量，静态全局变量，静态局部变量
2019-05-10 07:30:00//全局变量static int num2 = 111; //静态全局变量int add(int a,int b){ static int tempSum = 0; //静态局部变量 tempSum = tempSum + a + b; return tempSum;}int main(void){ printf... -
C语言 静态变量static的用法
2017-03-15 09:55:16第一个作用: 修饰变量，变量又分为局部和全局变量，但他们都存在内存的静态区 静态全局变量，作用于仅限于变量被定义的文件。其他文件即使用extern声明也没法使用，准确说就是作用域是从定义处开始，到文件结束... -
Python实现局部静态变量
2017-01-07 16:02:03Python实现局部静态变量[TOC] python没有局部静态变量，但可以通过以下几种方式实现类似于C语言的函数内局部静态变量。1、定义函数属性在python中一切皆对象，函数也是一个对象，因此可以给函数定义属性：def func... -
static静态局部变量的妙用
2020-07-25 18:54:22本文为大家介绍一种static静态局部变量的妙用方法。 -
静态变量static的作用
2016-11-08 14:49:17静态变量作用范围在一个文件内，程序开始时分配空间，结束时释放空间，默认初始化为0，使用时可以改变其值。 静态变量或静态函数只有本文件内的代码才能访问它，它的名字在其它文件中不可见。用法1：函数内部声明... -
g++中的局部静态变量的初始化机制及线程安全
2011-08-03 18:20:46g++中的局部静态变量的初始化机制及线程安全 -
局部变量，全局变量（外部变量），静态局部变量，静态全局变量
2018-03-20 16:59:43今天被问到了一个问题：如何让请求的类延迟释放如果要延迟释放或者在程序整个生命周期都存在可以考虑两种方式，一是定义一个静态变量，二是用单例。用单例本质上用的是静态变量。单例的写法如下：+ (instancetype)...
