精华内容
下载资源
问答
  • 全局变量的危害

    2018-07-03 21:20:34
    嵌入式特别是单片机os-less的程序,最易范的错误是全局变量满天飞。这个现象在早期汇编转型过来的程序员以及初学者中常见,这帮家伙几乎把全局变量当作函数形参来用。在.h文档里面定义许多杂乱的结构体,extern一堆...
      嵌入式特别是单片机os-less的程序,最易范的错误是全局变量满天飞。这个现象在早期汇编转型过来的程序员以及初学者中常见,这帮家伙几乎把全局变量当作函数形参来用。在.h文档里面定义许多杂乱的结构体,extern一堆令人头皮发麻的全局变量,然后再这个模块里边赋值123,那个模块里边判断123分支决定做什么。每当看到这种程序,我总要戚眉变脸而后拍桌怒喝。没错,就是怒喝。我不否认全局变量的重要性,但我认为要十分谨慎地使用它,滥用全局变量会引申带来其它更为严重的结构性系统问题。

    诸位看官,且听我细细道来。

    1. 它会造成不必要的常量频繁使用,特别当这个常量没有用宏定义“正名”时,代码阅读起来将万分吃力。

    2. 它会导致软件分层的不合理,全局变量相当于一条快捷通道,它容易使程序员模糊了“设备层”和“应用层”之间的边界。写出来的底层程序容易自作多情地关注起上层的应用。这在软件系统的构建初期的确效率很高,功能调试进度一日千里,但到了后期往往bug一堆,处处“补丁”,雷区遍布。说是度日如年举步维艰也不为过。

    3. 由于软件的分层不合理,到了后期维护,哪怕仅是增加修改删除小功能,往往要从上到下掘地三尺地修改,涉及大多数模块,而原有的代码注释却忘了更新修改,这个时候,交给后来维护者的系统会越来越像一个“泥潭”,注释的唯一作用只是使泥潭上方再加一些迷烟瘴气。

    4. 全局变量大量使用,少不了有些变量流连忘返于中断与主回圈程序之间。这个时候如果处理不当,系统的bug就是随机出现的,无规律的,这时候初步显示出病入膏肓的特征来了,没有大牛来力挽狂澜,注定慢性死亡。

    无需多言,您已经成功得到一个畸形的系统,它处于一个神秘的稳定状态!你看着这台机器,机器也看着你,相对无言,心中发毛。你不确定它什么时候会崩溃,也不晓得下一次投诉什么时候道理。

    然后,我告诉大家现实层面的后果是什么。

    1.“老人”气昂昂,因为系统离不开他,所有“雷区”只有他了然于心。当出现紧急的bug时,只有他能够搞定。你不但不能辞退他,还要给他加薪。
    2. 新人见光死,但凡招聘来维护这个系统的,除了改出更多的bug外,基本上一个月内就走人,到了外面还宣扬这个公司的软件质量有够差够烂。
    3.随着产品的后续升级,几个月没有接触这个系统的原创者会发现,很多雷区他本人也忘记了,于是每次的产品升级维护周期越来越长,因为修改一个功能会冒出很多bug,而按下一个bug,会弹出其他更多的bug。在这期间,又会产生更多的全局变量。终于有一天他告诉老板,不行啦不行啦,资源不够了,ram或者flash空间太小了,升级升级。
    4. 客户投诉不断,售后也快崩溃了,业务员也不敢推荐此产品了,市场份额越来越小,公司形象越来越糟糕。

    要问我的对策吗,只有两个原则:
    1. 能不用全局变量尽量不用,我想除了系统状态和控制参数、通信处理和一些需要效率的模块,其他的基本可以靠合理的软件分层和编程技巧来解决。
    2. 如果不可避免需要用到,那能藏多深就藏多深。
    1)如果只有某.c文件用,就static到该文件中,顺便把结构体定义也收进来;
    2)如果只有一个函数用,那就static到函数里面去;
    3)如果非要开放出去让人读取,那就用函数return出去,这样就是只读属性了;
    4)如果非要遭人蹂躏赋值,好吧,我开放函数接口让你传参赋值;5)实在非要extern**我,我还可以严格控制包含我.h档的对象,而不是放到公共的includes.h中被人围观,丢人现眼。
    如此,你可明白我对全局变量的感悟有多深刻。悲催的我,已经把当年那些“老人”交给我维护的那些案子加班全部重新翻写了。你能明白吗,不要让人背后唾弃你哦。

    续篇
      对于一些网友提到的,如果大量使用局部变量也会容易造成栈溢出的问题,还提到程序模型的概念。言之有理。所以特地来补充一下意见:
    1.全局变量是不可避免要用到的,每一个设备底层几乎都需要它来记录当前状态,控制时序,起承转合但是尽量不要用来传递参数,这个很忌讳的。
    2.尽量把变量的作用范围控制在使用它的模块里面,如果其他模块要访问,就开个读或写函数接口出来,严格控制访问范围。这一点,C++的private属性就是这么干的。这对将来程序的调试也很有好处。C语言之所以有++版本,很大原因就是为了控制它的灵活性,要说面向对象的思想,C语言早已有之,亦可实现。
    3.当一个模块里面的全局变量超过3个(含)时,就用结构体包起来吧。要归0便一起归0,省得丢三落四的。
    4.在函数里面开个静态的全局变量,全局数组,是不占用栈空间的只是有些编译器对于大块的全局数组,会放到和一般变量不同的地址区。若是在keil C51,因为是静态编译,栈爆掉了会报警,所以大可以尽情驰骋,注意交通规则就是了。
    5.单片机的os-less系统中,只有栈没有堆的用法,那些默认对堆分配空间的“startup.s”,可以大胆的把堆空间干掉。
    6.程序模型?如何分析抽象出来呢,从哪个角度进行模型构建呢?很愿意聆听网友的意见。本人一直以来都是从两个角度分析系统,事件--状态机迁移图 和 数据流图,前者分析控制流向,完善UI,后者可知晓系统数据的缘起缘灭。这些理论,院校的《软件工程》教材都有,大家不妨借鉴下。只不过那些理论,终究是起源于大型系统软件管理的,牛刀杀鸡,还是要裁剪一下的。
    展开全文
  • class SomeObj(): def __init__(self, param): self.param = param def query(self): self.param += 1 return self.param global_obj = SomeObj(0) @app.route('/') def home(): flash(global_obj.query()) render_...

    In my app the state of a common object is changed by making requests, and the response depends on the state.

    class SomeObj():

    def __init__(self, param):

    self.param = param

    def query(self):

    self.param += 1

    return self.param

    global_obj = SomeObj(0)

    @app.route('/')

    def home():

    flash(global_obj.query())

    render_template('index.html')

    If I run this on my development server, I expect to get 1, 2, 3 and so on. If requests are made from 100 different clients simultaneously, can something go wrong? The expected result would be that the 100 different clients each see a unique number from 1 to 100. Or will something like this happen:

    Client 1 queries. self.param is incremented by 1.

    Before the return statement can be executed, the thread switches over to client 2. self.param is incremented again.

    The thread switches back to client 1, and the client is returned the number 2, say.

    Now the thread moves to client 2 and returns him/her the number 3.

    Since there were only two clients, the expected results were 1 and 2, not 2 and 3. A number was skipped.

    Will this actually happen as I scale up my application? What alternatives to a global variable should I look at?

    解决方案

    You can't use global variables to hold this sort of data. Not only is it not thread safe, it's not process safe, and WSGI servers in production spawn multiple processes. Not only would your counts be wrong if you were using threads to handle requests, they would also vary depending on which process handled the request.

    Use a data source outside of Flask to hold global data. A database, memcached, or redis are all appropriate separate storage areas, depending on your needs. If you need to load and access Python data, consider multiprocessing.Manager. You could also use the session for simple data that is per-user.

    The development server may run in single thread and process. You won't see the behavior you describe since each request will be handled synchronously. Enable threads or processes and you will see it. app.run(threaded=True) or app.run(processes=10). (In 1.0 the server is threaded by default.)

    Some WSGI servers may support gevent or another async worker. Global variables are still not thread safe because there's still no protection against most race conditions. You can still have a scenario where one worker gets a value, yields, another modifies it, yields, then the first worker also modifies it.

    If you need to store some global data during a request, you may use Flask's g object. Another common case is some top-level object that manages database connections. The distinction for this type of "global" is that it's unique to each request, not used between requests, and there's something managing the set up and teardown of the resource.

    展开全文
  • 假设str为在任何函数外申明的变量,分别指出以下str在何时初始化,存于何处,并画出其内存结构图: 1) char str[] = "hello"; 2) char str[] = {'h', 'e', 'l', 'l', 'o'}; 3) char *str = "hello";  ...

    上次在网上偶遇一题,大致如下:

    假设str为在任何函数外申明的变量,分别指出以下str在何时初始化,存于何处,并画出其内存结构图:

    1) char str[] = "hello";

    2) char str[] = {'h', 'e', 'l', 'l', 'o'};

    3) char *str = "hello";  

    4) const char str[] = "hello";

    明白以下几点即可:

    1)编译器把带const的全局变量编译成常量并放在常量区;

    2)全局变量和全局常量分别放在内存的不同区域;

    3)编译器会在字符串后面添'\0',而字符数组后面不会;

    4)对于已初始化的全局变量,编译器在进入main函数前对其进行初始化;

    5)常量字符串的定义方法即在函数外进行类似以下的申明:char *str = "hello";  

    另外还有一点,编译器是没法初始化变量的,只能初始化常量。变量从flash到ram的加载要靠内存分配文件来完成。

    顺便转载一下这方面的文章:

    程序的内存分配(堆和栈区别)
     

     

    一、预备知识 程序的内存分配

    一个由c/C++编译的程序占用的内存分为以下几个部分
    1、栈区(stack)     由编译器自动分配释放 ,存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。
    2、堆区(heap)      一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事,分配方式倒是类似于链表,呵呵。
    3、全局区(静态区)(static),全局变量和静态变量的存储是放在一块的,初始化的全局变量和静态变量在一块区域, 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放 
    4、文字常量区    ?常量字符串就是放在这里的。 程序结束后由系统释放
    5、程序代码区?存放函数体的二进制代码。
    二、例子程序 
    这是一个前辈写的,非常详细 
    //main.cpp 
    int a = 0; 全局初始化区 
    char *p1; 全局未初始化区 
    main() 

    int b; 栈 
    char s[] = "abc"; 栈 
    char *p2; 栈 
    char *p3 = "123456"; 123456\0在常量区,p3在栈上。 
    static int c =0; 全局(静态)初始化区 
    p1 = (char *)malloc(10); 
    p2 = (char *)malloc(20); 
    分配得来得10和20字节的区域就在堆区。 
    strcpy(p1, "123456"); 123456\0放在常量区,编译器可能会将它与p3所指向的"123456"优化成一个地方。 
    }


    二、堆和栈的理论知识

    2.1申请方式 
    stack: 
    由系统自动分配。 例如,声明在函数中一个局部变量 int b; 系统自动在栈中为b开辟空间 
    heap: 
    需要程序员自己申请,并指明大小,在c中malloc函数 
    如p1 = (char *)malloc(10); 
    在C++中用new运算符 
    如p2 = (char *)malloc(10); 
    但是注意p1、p2本身是在栈中的。


    2.2 
    申请后系统的响应 
    栈:只要栈的剩余空间大于所申请空间,系统将为程序提供内存,否则将报异常提示栈溢出。 
    堆:首先应该知道操作系统有一个记录空闲内存地址的链表,当系统收到程序的申请时, 
    会遍历该链表,寻找第一个空间大于所申请空间的堆结点,然后将该结点从空闲结点链表中删除,并将该结点的空间分配给程序,另外,对于大多数系统,会在这块内存空间中的首地址处记录本次分配的大小,这样,代码中的delete语句才能正确的释放本内存空间。另外,由于找到的堆结点的大小不一定正好等于申请的大小,系统会自动的将多余的那部分重新放入空闲链表中。

    2.3申请大小的限制 
    栈:在Windows下,栈是向低地址扩展的数据结构,是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的,在WINDOWS下,栈的大小是2M(也有的说是1M,总之是一个编译时就确定的常数),如果申请的空间超过栈的剩余空间时,将提示overflow。因此,能从栈获得的空间较小。 
    堆:堆是向高地址扩展的数据结构,是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的,自然是不连续的,而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见,堆获得的空间比较灵活,也比较大。


    2.4申请效率的比较: 
    栈由系统自动分配,速度较快。但程序员是无法控制的。 
    堆是由new分配的内存,一般速度比较慢,而且容易产生内存碎片,不过用起来最方便. 
    另外,在WINDOWS下,最好的方式是用VirtualAlloc分配内存,他不是在堆,也不是在栈是直接在进程的地址空间中保留一快内存,虽然用起来最不方便。但是速度快,也最灵活。

    2.5堆和栈中的存储内容 
    栈: 在函数调用时,第一个进栈的是主函数中后的下一条指令(函数调用语句的下一条可执行语句)的地址,然后是函数的各个参数,在大多数的C编译器中,参数是由右往左入栈的,然后是函数中的局部变量。注意静态变量是不入栈的。 
    当本次函数调用结束后,局部变量先出栈,然后是参数,最后栈顶指针指向最开始存的地址,也就是主函数中的下一条指令,程序由该点继续运行。 
    堆:一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。

    2.6存取效率的比较

    char s1[] = "aaaaaaaaaaaaaaa"; 
    char *s2 = "bbbbbbbbbbbbbbbbb"; 
    aaaaaaaaaaa是在运行时刻赋值的; 
    而bbbbbbbbbbb是在编译时就确定的; 
    但是,在以后的存取中,在栈上的数组比指针所指向的字符串(例如堆)快。 
    比如: 
    #include 
    void main() 

    char a = 1; 
    char c[] = "1234567890"; 
    char *p ="1234567890"; 
    a = c[1]; 
    a = p[1]; 
    return; 

    对应的汇编代码 
    10: a = c[1]; 
    00401067 8A 4D F1 mov cl,byte ptr [ebp-0Fh] 
    0040106A 88 4D FC mov byte ptr [ebp-4],cl 
    11: a = p[1]; 
    0040106D 8B 55 EC mov edx,dword ptr [ebp-14h] 
    00401070 8A 42 01 mov al,byte ptr [edx+1] 
    00401073 88 45 FC mov byte ptr [ebp-4],al 
    第一种在读取时直接就把字符串中的元素读到寄存器cl中,而第二种则要先把指针值读到edx中,在根据edx读取字符,显然慢了。


    2.7小结: 
    堆和栈的区别可以用如下的比喻来看出: 
    使用栈就象我们去饭馆里吃饭,只管点菜(发出申请)、付钱、和吃(使用),吃饱了就走,不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作,他的好处是快捷,但是自由度小。 
    使用堆就象是自己动手做喜欢吃的菜肴,比较麻烦,但是比较符合自己的口味,而且自由度大

    一般认为在c中分为这几个存储区

    1栈 - 有编译器自动分配释放 
    2堆 - 一般由程序员分配释放,若程序员不释放,程序结束时可能由OS回收 
    3全局区(静态区),全局变量和静态变量的存储是放在一块的,初始化的全局变量和静态变量在一块区域,未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。- 程序结束释放 
    4另外还有一个专门放常量的地方。 - 程序结束释放
    在函数体中定义的变量通常是在栈上,用malloc, calloc, realloc等分配内存的函数分配得到的就是在堆上。在所有函数体外定义的是全局量,加了static修饰符后不管在哪里都存放在全局区(静态区),在所有函数体外定义的static变量表示在该文件中有效,不能extern到别的文件用,在函数体内定义的static表示只在该函数体内有效。另外,函数中的"adgfdf"这样的字符串存放在常量区。比如:

    代码:

    int a = 0; //全局初始化区 
    char *p1; //全局未初始化区 
    main() 
    {

    int b; //栈
    char s[] = "abc"; //栈 
    char *p2; //栈 
    char *p3 = "123456"; //123456\0在常量区,p3在栈上。 
    static int c = 0; //全局(静态)初始化区 
    p1 = (char *)malloc(10); 
    p2 = (char *)malloc(20); //分配得来得10和20字节的区域就在堆区。 
    strcpy(p1, "123456"); //123456\0放在常量区,编译器可能会将它与p3所指向的"123456"优化成一块。 
    }


    还有就是函数调用时会在栈上有一系列的保留现场及传递参数的操作。栈的空间大小有限定,vc的缺省是2M。栈不够用的情况一般是程序中分配了大量数组和递归函数层次太深。有一点必须知道,当一个函数调用完返回后它会释放该函数中所有的栈空间。栈是由编译器自动管理的,不用你操心。
    堆是动态分配内存的,并且你可以分配使用很大的内存。但是用不好会产生内存泄漏。并且频繁地malloc和free会产生内存碎片(有点类似磁盘碎片),因为c分配动态内存时是寻找匹配的内存的。而用栈则不会产生碎片。

    在栈上存取数据比通过指针在堆上存取数据快些。一般大家说的堆栈和栈是一样的,就是栈(stack),而说堆时才是堆heap。栈是先入后出的,一般是由高地址向低地址生长。

    有人可能会说,全局内存就是全局变量嘛,有必要专门一章来介绍吗?这么简单的东西,还能玩出花来?我从来没有深究它,不一样写程序吗?关于全局内存这个主题虽然玩不出花来,但确实有些重要,了解这些知识,对于优化程序的时间和空间很有帮助。因为有好几次这样经历,我才决定花一章篇幅来介绍它。
    正如大家所知道的,全局变量是放在全局内存中的,但反过来却未必成立。用static修饰的局部变量就是放在放全局内存的,它的作用域是局部的,但生命期是全局的。在有的嵌入式平台中,堆实际上就是一个全局变量,它占用相当大的一块内存,在运行时,把这块内存进行二次分配。
    这里我们并不强调全局变量和全局内存的差别。在本文中,全局强调的是它的生命期,而不是它的作用域,所以有时可能把两者的概念互换。
    一般来说,在一起定义的两个全局变量,在内存的中位置是相邻的。这是一个简单的常识,但有时挺有用,如果一个全局变量被破坏了,不防先查查其前后相关变量的访问代码,看看是否存在越界访问的可能。
    在ELF格式的可执行文件中,全局内存包括三种:bss、data和rodata。其它可执行文件格式与之类似。了解了这三种数据的特点,我们才能充分发挥它们的长处,达到速度与空间的最优化。
    1.         bss
    已经记不清bss代表Block Storage Start还是Block Started by Symbol。像这我这种没有用过那些史前计算机的人,终究无法明白这样怪异的名字,也就记不住了。不过没有关系,重要的是,我们要清楚bss全局变量有什么样特点,以及如何利用它。
    通俗的说,bss是指那些没有初始化的和初始化为0的全局变量。它有什么特点呢,让我们来看看一个小程序的表现。

     

    int bss_array [1024 * 1024] = {0};
    int main ( int argc char argv [])
    {
         return  0;
    }

     

    [ root @localhost bss] # gcc  - g  bss.c -o bss.exe
    [ root @localhost bss] # ll
    total 12
    -rw-r--r-- 1  root root    84  Jun  22 14:32 bss.c
    -rwxr-xr- x   root root 5683 Jun  22 14:32 bss.exe
    变量bss_array的大小为4M,而可执行文件的大小只有5K。由此可见,bss类型的全局变量只占运行时的内存空间,而不占文件空间。
    另外,大多数操作系统,在加载程序时,会把所有的bss全局变量全部清零,无需要你手工去清零。但为保证程序的可移植性,手工把这些变量初始化为0也是一个好习惯。
    2.         data
    与bss相比,data就容易明白多了,它的名字就暗示着里面存放着数据。当然,如果数据全是零,为了优化考虑,编译器把它当作bss处理。通俗的说,data指那些初始化过(非零)的非const的全局变量。它有什么特点呢,我们还是来看看一个小程序的表现。

     

    int data_array [1024 * 1024] = {1};
    int main ( int argc char argv [])
    {
         return  0;
    }

     

    [ root @localhost  data ] # gcc  - g data .c -o  data .exe
    [ root @localhost  data ] # ll
    total 4112
    -rw-r--r-- 1  root root       85  Jun  22 14:35  data .c
    -rwxr-xr- x   root root 4200025 Jun  22 14:35  data .exe
    仅仅是把初始化的值改为非零了,文件就变为 4M 多。 由此可见,data类型的全局变量是即占文件空间,又占用运行时内存空间的。
    3.         rodata
    rodata的意义同样明显,ro代表read only,即只读数据(const)。关于rodata类型的数据,要注意以下几点:
    l           常量不一定就放在rodata里,有的立即数直接编码在指令里,存放在代码段(.text)中。
    l           对于字符串常量,编译器会自动去掉重复的字符串,保证一个字符串在一个可执行文件(EXE/SO)中只存在一份拷贝。
    l           rodata是在多个进程间是共享的,这可以提高空间利用率。
    l           在有的嵌入式系统中,rodata放在ROM(如norflash)里,运行时直接读取ROM内存,无需要加载到RAM内存中。
    l           在嵌入式linux系统中,通过一种叫作XIP(就地执行)的技术,也可以直接读取,而无需要加载到RAM内存中。
    由此可见,把在运行过程中不会改变的数据设为rodata类型的,是有很多好处的:在多个进程间共享,可以大大提高空间利用率,甚至不占用RAM空间。同时由于rodata在只读的内存页面(page)中,是受保护的,任何试图对它的修改都会被及时发现,这可以帮助提高程序的稳定性。
    4.         变量与关键字
    static关键字用途太多,以致于让新手模糊。不过,总结起来就有两种作用,改变生命期限制作用域。如:
    l           修饰inline函数:限制作用域
    l           修饰普通函数:限制作用域
    l           修饰局部变量:改变生命期
    l           修饰全局变量:限制作用域
    const 关键字倒是比较明了,用const修饰的变量放在rodata里,字符串默认就是常量。对const,注意以下几点就行了。
    l           指针常量:指向的数据是常量。如 const char* p = “abc”; p指向的内容是常量 ,但p本身不是常量,你可以让p再指向”123”。
    l           常量指针:指针本身是常量。如:char* const p = “abc”; p本身就是常量,你不能让p再指向”123”。
    l           指针常量 + 常量指针:指针和指针指向的数据都是常量。const char* const p =”abc”; 两者都是常量,不能再修改。
    violatile关键字通常用来修饰多线程共享的全局变量和IO内存。告诉编译器,不要把此类变量优化到寄存器中,每次都要老老实实的从内存中读取,因为它们随时都可能变化。这个关键字可能比较生僻,但千万不要忘了它,否则一个错误让你调试好几天也得不到一点线索。
    展开全文
  • 很详细原文地址:关于全局变量的若干细节(转)作者:永远的月饼 上次在网上偶遇一题,大致如下: 假设str为在任何函数外申明的变量,分别指出以下str在何时初始化,存于何处,并画出其内存结构图: 1) char str[]...
    很详细

    上次在网上偶遇一题,大致如下:

    假设str为在任何函数外申明的变量,分别指出以下str在何时初始化,存于何处,并画出其内存结构图:

    1) char str[] = "hello";

    2) char str[] = {'h', 'e', 'l', 'l', 'o'};

    3) char *str = "hello";  

    4) const char str[] = "hello";

    明白以下几点即可:

    1)编译器把带const的全局变量编译成常量并放在常量区;

    2)全局变量和全局常量分别放在内存的不同区域;

    3)编译器会在字符串后面添'',而字符数组后面不会;

    4)对于已初始化的全局变量,编译器在进入main函数前对其进行初始化;

    5)常量字符串的定义方法即在函数外进行类似以下的申明:char *str = "hello";  

    另外还有一点,编译器是没法初始化变量的,只能初始化常量。变量从flash到ram的加载要靠内存分配文件来完成。

    顺便转载一下这方面的文章:

    程序的内存分配(堆和栈区别)
     

     

    一、预备知识 程序的内存分配

    一个由c/C++编译的程序占用的内存分为以下几个部分
    1、栈区(stack)     由编译器自动分配释放 ,存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。
    2、堆区(heap)      一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事,分配方式倒是类似于链表,呵呵。
    3、全局区(静态区)(static),全局变量和静态变量的存储是放在一块的,初始化的全局变量和静态变量在一块区域, 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放 
    4、文字常量区    ?常量字符串就是放在这里的。 程序结束后由系统释放
    5、程序代码区?存放函数体的二进制代码。
    二、例子程序 
    这是一个前辈写的,非常详细 
    //main.cpp 
    int a = 0; 全局初始化区 
    char *p1; 全局未初始化区 
    main() 

    int b; 栈 
    char s[] = "abc"; 栈 
    char *p2; 栈 
    char *p3 = "123456"; 123456在常量区,p3在栈上。 
    static int c =0; 全局(静态)初始化区 
    p1 = (char *)malloc(10); 
    p2 = (char *)malloc(20); 
    分配得来得10和20字节的区域就在堆区。 
    strcpy(p1, "123456"); 123456放在常量区,编译器可能会将它与p3所指向的"123456"优化成一个地方。 
    }


    二、堆和栈的理论知识

    2.1申请方式 
    stack: 
    由系统自动分配。 例如,声明在函数中一个局部变量 int b; 系统自动在栈中为b开辟空间 
    heap: 
    需要程序员自己申请,并指明大小,在c中malloc函数 
    如p1 = (char *)malloc(10); 
    在C++中用new运算符 
    如p2 = (char *)malloc(10); 
    但是注意p1、p2本身是在栈中的。


    2.2 
    申请后系统的响应 
    栈:只要栈的剩余空间大于所申请空间,系统将为程序提供内存,否则将报异常提示栈溢出。 
    堆:首先应该知道操作系统有一个记录空闲内存地址的链表,当系统收到程序的申请时, 
    会遍历该链表,寻找第一个空间大于所申请空间的堆结点,然后将该结点从空闲结点链表中删除,并将该结点的空间分配给程序,另外,对于大多数系统,会在这块内存空间中的首地址处记录本次分配的大小,这样,代码中的delete语句才能正确的释放本内存空间。另外,由于找到的堆结点的大小不一定正好等于申请的大小,系统会自动的将多余的那部分重新放入空闲链表中。

    2.3申请大小的限制 
    栈:在Windows下,栈是向低地址扩展的数据结构,是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的,在WINDOWS下,栈的大小是2M(也有的说是1M,总之是一个编译时就确定的常数),如果申请的空间超过栈的剩余空间时,将提示overflow。因此,能从栈获得的空间较小。 
    堆:堆是向高地址扩展的数据结构,是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的,自然是不连续的,而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见,堆获得的空间比较灵活,也比较大。


    2.4申请效率的比较: 
    栈由系统自动分配,速度较快。但程序员是无法控制的。 
    堆是由new分配的内存,一般速度比较慢,而且容易产生内存碎片,不过用起来最方便. 
    另外,在WINDOWS下,最好的方式是用VirtualAlloc分配内存,他不是在堆,也不是在栈是直接在进程的地址空间中保留一快内存,虽然用起来最不方便。但是速度快,也最灵活。

    2.5堆和栈中的存储内容 
    栈: 在函数调用时,第一个进栈的是主函数中后的下一条指令(函数调用语句的下一条可执行语句)的地址,然后是函数的各个参数,在大多数的C编译器中,参数是由右往左入栈的,然后是函数中的局部变量。注意静态变量是不入栈的。 
    当本次函数调用结束后,局部变量先出栈,然后是参数,最后栈顶指针指向最开始存的地址,也就是主函数中的下一条指令,程序由该点继续运行。 
    堆:一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。

    2.6存取效率的比较

    char s1[] = "aaaaaaaaaaaaaaa"; 
    char *s2 = "bbbbbbbbbbbbbbbbb"; 
    aaaaaaaaaaa是在运行时刻赋值的; 
    而bbbbbbbbbbb是在编译时就确定的; 
    但是,在以后的存取中,在栈上的数组比指针所指向的字符串(例如堆)快。 
    比如: 
    #include 
    void main() 

    char a = 1; 
    char c[] = "1234567890"; 
    char *p ="1234567890"; 
    a = c[1]; 
    a = p[1]; 
    return; 

    对应的汇编代码 
    10: a = c[1]; 
    00401067 8A 4D F1 mov cl,byte ptr [ebp-0Fh] 
    0040106A 88 4D FC mov byte ptr [ebp-4],cl 
    11: a = p[1]; 
    0040106D 8B 55 EC mov edx,dword ptr [ebp-14h] 
    00401070 8A 42 01 mov al,byte ptr [edx+1] 
    00401073 88 45 FC mov byte ptr [ebp-4],al 
    第一种在读取时直接就把字符串中的元素读到寄存器cl中,而第二种则要先把指针值读到edx中,在根据edx读取字符,显然慢了。


    2.7小结: 
    堆和栈的区别可以用如下的比喻来看出: 
    使用栈就象我们去饭馆里吃饭,只管点菜(发出申请)、付钱、和吃(使用),吃饱了就走,不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作,他的好处是快捷,但是自由度小。 
    使用堆就象是自己动手做喜欢吃的菜肴,比较麻烦,但是比较符合自己的口味,而且自由度大

    一般认为在c中分为这几个存储区

    1栈 - 有编译器自动分配释放 
    2堆 - 一般由程序员分配释放,若程序员不释放,程序结束时可能由OS回收 
    3全局区(静态区),全局变量和静态变量的存储是放在一块的,初始化的全局变量和静态变量在一块区域,未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。- 程序结束释放 
    4另外还有一个专门放常量的地方。 - 程序结束释放
    在函数体中定义的变量通常是在栈上,用malloc, calloc, realloc等分配内存的函数分配得到的就是在堆上。在所有函数体外定义的是全局量,加了static修饰符后不管在哪里都存放在全局区(静态区),在所有函数体外定义的static变量表示在该文件中有效,不能extern到别的文件用,在函数体内定义的static表示只在该函数体内有效。另外,函数中的"adgfdf"这样的字符串存放在常量区。比如:

    代码:

    int a = 0; //全局初始化区 
    char *p1; //全局未初始化区 
    main() 
    {

    int b; //栈
    char s[] = "abc"; //栈 
    char *p2; //栈 
    char *p3 = "123456"; //123456在常量区,p3在栈上。 
    static int c = 0; //全局(静态)初始化区 
    p1 = (char *)malloc(10); 
    p2 = (char *)malloc(20); //分配得来得10和20字节的区域就在堆区。 
    strcpy(p1, "123456"); //123456放在常量区,编译器可能会将它与p3所指向的"123456"优化成一块。 
    }


    还有就是函数调用时会在栈上有一系列的保留现场及传递参数的操作。栈的空间大小有限定,vc的缺省是2M。栈不够用的情况一般是程序中分配了大量数组和递归函数层次太深。有一点必须知道,当一个函数调用完返回后它会释放该函数中所有的栈空间。栈是由编译器自动管理的,不用你操心。
    堆是动态分配内存的,并且你可以分配使用很大的内存。但是用不好会产生内存泄漏。并且频繁地malloc和free会产生内存碎片(有点类似磁盘碎片),因为c分配动态内存时是寻找匹配的内存的。而用栈则不会产生碎片。

    在栈上存取数据比通过指针在堆上存取数据快些。一般大家说的堆栈和栈是一样的,就是栈(stack),而说堆时才是堆heap。栈是先入后出的,一般是由高地址向低地址生长。

    有人可能会说,全局内存就是全局变量嘛,有必要专门一章来介绍吗?这么简单的东西,还能玩出花来?我从来没有深究它,不一样写程序吗?关于全局内存这个主题虽然玩不出花来,但确实有些重要,了解这些知识,对于优化程序的时间和空间很有帮助。因为有好几次这样经历,我才决定花一章篇幅来介绍它。
    正如大家所知道的,全局变量是放在全局内存中的,但反过来却未必成立。用static修饰的局部变量就是放在放全局内存的,它的作用域是局部的,但生命期是全局的。在有的嵌入式平台中,堆实际上就是一个全局变量,它占用相当大的一块内存,在运行时,把这块内存进行二次分配。
    这里我们并不强调全局变量和全局内存的差别。在本文中,全局强调的是它的生命期,而不是它的作用域,所以有时可能把两者的概念互换。
    一般来说,在一起定义的两个全局变量,在内存的中位置是相邻的。这是一个简单的常识,但有时挺有用,如果一个全局变量被破坏了,不防先查查其前后相关变量的访问代码,看看是否存在越界访问的可能。
    在ELF格式的可执行文件中,全局内存包括三种:bss、data和rodata。其它可执行文件格式与之类似。了解了这三种数据的特点,我们才能充分发挥它们的长处,达到速度与空间的最优化。
    1.          bss
    已经记不清bss代表Block Storage Start还是Block Started by Symbol。像这我这种没有用过那些史前计算机的人,终究无法明白这样怪异的名字,也就记不住了。不过没有关系,重要的是,我们要清楚bss全局变量有什么样特点,以及如何利用它。
    通俗的说,bss是指那些没有初始化的和初始化为0的全局变量。它有什么特点呢,让我们来看看一个小程序的表现。

     

    int bss_array [1024 * 1024] = {0};
    int main ( int argc char argv [])
    {
         return  0;
    }

     

    [ root @localhost bss] # gcc  - g  bss.c -o bss.exe
    [ root @localhost bss] # ll
    total 12
    -rw-r--r-- 1  root root    84  Jun  22 14:32 bss.c
    -rwxr-xr- x   root root 5683 Jun  22 14:32 bss.exe
    变量bss_array的大小为4M,而可执行文件的大小只有5K。由此可见,bss类型的全局变量只占运行时的内存空间,而不占文件空间。
    另外,大多数操作系统,在加载程序时,会把所有的bss全局变量全部清零,无需要你手工去清零。但为保证程序的可移植性,手工把这些变量初始化为0也是一个好习惯。
    2.          data
    与bss相比,data就容易明白多了,它的名字就暗示着里面存放着数据。当然,如果数据全是零,为了优化考虑,编译器把它当作bss处理。通俗的说,data指那些初始化过(非零)的非const的全局变量。它有什么特点呢,我们还是来看看一个小程序的表现。

     

    int data_array [1024 * 1024] = {1};
    int main ( int argc char argv [])
    {
         return  0;
    }

     

    [ root @localhost  data ] # gcc  - g data .c -o  data .exe
    [ root @localhost  data ] # ll
    total 4112
    -rw-r--r-- 1  root root       85  Jun  22 14:35  data .c
    -rwxr-xr- x   root root 4200025 Jun  22 14:35  data .exe
    仅仅是把初始化的值改为非零了,文件就变为 4M 多。 由此可见,data类型的全局变量是即占文件空间,又占用运行时内存空间的。
    3.          rodata
    rodata的意义同样明显,ro代表read only,即只读数据(const)。关于rodata类型的数据,要注意以下几点:
    l           常量不一定就放在rodata里,有的立即数直接编码在指令里,存放在代码段(.text)中。
    l           对于字符串常量,编译器会自动去掉重复的字符串,保证一个字符串在一个可执行文件(EXE/SO)中只存在一份拷贝。
    l           rodata是在多个进程间是共享的,这可以提高空间利用率。
    l           在有的嵌入式系统中,rodata放在ROM(如norflash)里,运行时直接读取ROM内存,无需要加载到RAM内存中。
    l           在嵌入式linux系统中,通过一种叫作XIP(就地执行)的技术,也可以直接读取,而无需要加载到RAM内存中。
    由此可见,把在运行过程中不会改变的数据设为rodata类型的,是有很多好处的:在多个进程间共享,可以大大提高空间利用率,甚至不占用RAM空间。同时由于rodata在只读的内存页面(page)中,是受保护的,任何试图对它的修改都会被及时发现,这可以帮助提高程序的稳定性。
    4.          变量与关键字
    static关键字用途太多,以致于让新手模糊。不过,总结起来就有两种作用,改变生命期限制作用域。如:
    l           修饰inline函数:限制作用域
    l           修饰普通函数:限制作用域
    l           修饰局部变量:改变生命期
    l           修饰全局变量:限制作用域
    const 关键字倒是比较明了,用const修饰的变量放在rodata里,字符串默认就是常量。对const,注意以下几点就行了。
    l           指针常量:指向的数据是常量。如 const char* p = “abc”; p指向的内容是常量 ,但p本身不是常量,你可以让p再指向”123”。
    l           常量指针:指针本身是常量。如:char* const p = “abc”; p本身就是常量,你不能让p再指向”123”。
    l           指针常量 + 常量指针:指针和指针指向的数据都是常量。const char* const p =”abc”; 两者都是常量,不能再修改。
    violatile关键字通常用来修饰多线程共享的全局变量和IO内存。告诉编译器,不要把此类变量优化到寄存器中,每次都要老老实实的从内存中读取,因为它们随时都可能变化。这个关键字可能比较生僻,但千万不要忘了它,否则一个错误让你调试好几天也得不到一点线索。
    展开全文
  • 参考:https://blog.csdn.net/liyang121316/article/details/12782403 保存在RAM中: *.icf配置文件中加入: place at address mem:0x08090000 { readwritesection .test };...u32 g_to_be_boot; ...
  • Flask, request, session, g, redirect, url_for, abort, render_template, flash from sqlalchemy.ext import declarative from sqlalchemy.orm import * 在最后,想告诉python新手一件很重要的事,...
  • static变量全局、局部变量的区别

    千次阅读 2010-12-27 11:16:00
    static变量与全局、局部变量的区别全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量全局变量本身就是静态存储方式,静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的...
  • 我相信大家都有过这样的经历,在面试过程中,考官通常会给你一道题目,然后问你某个变量存储在什么地方,在内存中是如何存储的等等一系列问题。不仅仅是在面试中,学校里面的考试也会碰到同样的问题。  如果你还不...
  • MSP430G2553 flash操作例子

    千次阅读 2016-10-21 15:29:59
    Flash_Init(unsigned char Div,unsigned char Seg ):依据SMCLK频率计算设定Flash的时 钟的分频系数,靠Seg段号码确定计划操作的段起始地址。 (2)整段擦除。Flash_Erase():段擦除函数。 (3)读字节。Flash_...
  • The flash media driver (FMD) is a device driver that performs the actual input and output of data to a flash memory device. An FMD contains all of the device-specific code necessary for read, write, ...
  • 编译器会保证只存在一个 (3) rodata是在多个进程间共享的 (4) 有的嵌入式系统,rodata放在ROM(或者NOR FLASH)中,运行时直接读取无需加载 至RAM( 哈佛 和冯诺依曼,从STM32的const全局变量说起有所记录) 想要将数据...
  • 模板特有变量

    2020-11-18 00:41:19
    g:局部的全局变量 url_for():反解析,通过函数名字,解析到视图函数的路径 get_flashed_messages():用来消耗flash方法中存储的信息 场景:登录出错,可以显示 注意点: 使用flash存储消息的时候需要设置SERCERT...
  • 【discuz x3】$_G变量的内容

    万次阅读 2014-05-04 13:28:09
    Array ( [uid] => 1 [username] => admin [adminid] => 1 [groupid] => 1 [sid] => PXW6my [formhash] => bc6f0b24 [connectguest] => 0 [timestamp] => 1399181615 [starttime
  • 全局内存

    2015-11-24 19:30:57
    有人可能会说,全局内存就是全局变量嘛,有必要专门一章来介绍吗?这么简单的东西,还能玩出花来?我从来没有深究它,不一样写程序吗?关于全局内存这个主题虽然玩不出花来,但确实有些重要,了解这些知识,对于优化...
  • 的 你的变量究竟存储在什么地方 && 全局内存 我相信大家都有过这样的经历,在面试 过程中,考官通常会给你一道题目,然后问你某个变量存储在什么地方,在内存中是如何存储的等等一系列问题。不仅仅是在...
  • STM32F412擦除内部FLASH时间过长

    万次阅读 2017-01-05 22:02:51
    通过与客户邮件和电话沟通,了解到客户主要是想使用内部FLASH暂时保存IAP升级时的程序数据,在IAP升级的过程中,需要首先擦除内部FLASH中一块足够大的空间,然后再写入升级数据。客户的工程中有使用到IWDG,喂狗间隔...
  • http://blog.163.com/zhqh43@126/blog/static/404330272007102012451957/ 我相信大家都有过这样的经历,在面试过程中,考官通常会给你一道题目,然后问你某个变量存储在什么地方,在内存中是如何存储的等等一系列...
  • Eboot 中给nandflash分区实现

    千次阅读 2010-11-01 22:23:00
    什么是MBR 硬盘的0柱面、0磁头、1扇区称为主引导扇区,NANDFLASH由BLOCK和Sector组成,所以NANDFLASH的第0 BLOCK,第1 Sector为主引导扇区,FDISK程序写到该扇区的内容称为主引导记录(MBR)。...
  •  U-Boot版本:U-boot 2008.10 目标板:Mini2440 Nandflash型号: K9F1G08U0B 256M    修改include/configs/mini2440.h。 1)添加命令支持: #define CONFIG_CMD_ELF #define CONFIG_CMD_
  • keil for arm中: staticconstuint8_ts_acBmpLogo030[len]__attribute__((at(0X800F000)))={0x80,0xC0,0xC0,0xC0,0xC0,0x80,xxxxxxx} ...将一个全局变量放到0x20000000处; 将一个const常量放置到0x0000100...
  • 我相信大家都有过这样的经历,在面试过程中,考官通常会给你一道题目,然后问你某个变量存储在什么地方,在内存中是如何存储的等等一系列问题。不仅仅是在面试中,学校里面的考试也会碰到同样的问题。 如果你还不...
  • apollo 3 plus flash操作

    2020-01-10 10:14:48
    全局测试变量定义 static uint32_t ui32Source[512]; flash读写起始地址定义 #define AM_HAL_FLASH_INSTANCE_SIZE ( 512 * 1024 ) #define AM_HAL_FLASH_PAGE_SIZE ( 8 * 1024 ) //! Arbitrary pa...
  • connect-flash 用法详解

    千次阅读 2017-08-02 09:30:38
    说到 connect-flash ,估计也有很多朋友像我一样被它虐了好一阵子,很多朋友可能都会遇到过这个问题:Express4.x 中的 connect-flash 为什么不起作用?或者 connect-flash 怎么用?诸如此类的问题,在这里我就给大家...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,716
精华内容 3,086
关键字:

flask全局变量g