精华内容
下载资源
问答
  • 2019-03-29 19:12:12

    概述:

    全局变量和和由static修饰的静态变量都被储存在全局数据区。全局数据区的内存在程序运行时会被全部置'0'.这不同于局部变量,局部变量在栈上分配内存,但此块内存一般不为零,且编译器不会在局部变量被声明的地方为其置'0',除非申明时对其初始化值为0.

     

    全局变量:

    申明在main函数外的变量被编译器视为全局变量。即其在整个文件的任何地方都可以使用它。

    对于其他源文件来说,全局变量对其有可见性。即可以在其他源文件中通过包含此源/头文件然后通过extern关键字引用此全局变量。

    静态变量:

    静态变量在被申明在文件任何地方都会被视作静态变量(感觉是废话,嘻嘻),只要它被static关键字所修饰(好像还是废话)。而若想创建一个全局变量,其必须在main函数外和其他函数外被申明,否则它就不是全局变量了。

    对于其他源文件来说,本文件的静态变量是不可见的,无法外部被引用。

    但申明在本文件的哪个地方对本文件其他地方能否访问静态变量是有影响的。如果静态变量像全局变量一样被申明在所有函数之外,那么在本文件任何地方都能访问到此静态变量(当然要保证申明的地方在访问的地方之前)。如果静态变量被申明在某个函数中,那么在此函数外,此静态变量是不可访问的。这有点像局部变量,不过它是静态的。什么意思呢?举个例子,一个被申明在test()函数内部的局部变量a,在test()每次被调用时,都会在栈上被重新分配内存,test函数执行完毕时,a所代表的内存区域被释放。而如果a被申明为静态的。在test()第一次被调用时,编译器会在全局数据区为a分配内存,在test函数执行完毕后,a所代表的内存区域并不会被释放,它的值还是原来的值。在以后test()的每次调用都不会再理会a变量的申明语句(如" static int a; "),即使申明语句带有初始化性质(如" static int a=10 ")。

    参考了:

    https://blog.csdn.net/candyliuxj/article/details/7853938

    更多相关内容
  • 本文主要介绍了C++中的局部变量、全局变量、局部静态变量、全局静态变量的区别。具有很好的参考价值,下面跟着小编一起来看下吧
  • 1.全局变量 全局变量无疑要在main函数开始前执行完成,但可细分为在编译时在运行时初始化,即static initializationdynamic initialization。 static initialization 静态初始化按照我的理解,是针对那些较为...


    1.全局变量


        全局变量无疑要在main函数开始前执行完成,但可细分为在编译时和在运行时初始化,即static initialization和dynamic initialization。


     static initialization
               静态初始化按照我的理解,是针对那些较为简单的,c++内部定义的数据结构,如int,double,bool及其数组结构的初始化。又可分为zero和const两种方式。


               对于zero初始化,编译时编译器将其分配在.bss段,不占用rom空间;而const初始化,也就是我们指定了全局变量的初始值,编译器会将其分配在.data段,占用room空间。


     dynamic initialization
               这种初始化针对的是需要调用构造函数才能完成的初始化。这种初始化会在main函数执行前由运行时库调用对应的代码进行初始化。


        静态初始化先于动态初始化,这一点很好理解。静态初始化在编译时初始化,直接写进.bss和.data段,程序执行时直接加载,而动态初始化只能在运行时由运行时库调用相应构造函数进行初始化。


    2.类的静态成员


        C++规定,const的静态成员可以直接在类内初始化,而非const的静态成员需要在类外声明以初始化。对于后一种情况,我们一般选择在类的实现文件中初始化。


        至此,具体的初始化方式和上面所说的又是一致的,可在编译期间初始化,也可以在运行时初始化。


    3.关于静态成员函数和静态成员变量的使用


        两者都可以通过类名+"::"的方式进行使用,此外,对于类的对象,指针或引用,也可以直接调用。但类的静态成员函数由于不含有this指针,只能引用其类的静态成员变量。


        不过有一种技巧,可以给类的静态成员函数传递该类的指针、引用等作为形参,强行使用该类的对象。























    本文转自:

    https://www.cnblogs.com/fushi/p/7631359.html








    展开全文
  • 但是对于全局变量和静态变量来说,其生命周期较长,其析构函数将会在什么时机进行调用呢?让我们来探究一下。 我们先看下面的一段程序: #include <iostream> #include <cstdlib> #include <string&...

    在C++中,对于局部变量,当局部变量的生命周期结束时,会自动调用析构函数。

    但是对于全局变量和静态变量来说,其生命周期较长,其析构函数将会在什么时机进行调用呢?让我们来探究一下。

    我们先看下面的一段程序:

    #include <iostream>
    #include <cstdlib>
    #include <string>
    
    class Static {
    public:
        Static()
        {
            std::cout << "Static constructor\n";
        }
        ~Static()
        {
            std::cout << "Static destructor\n";
        }
    };
    
    class Global {
    public:
        Global()
        {
            std::cout << "Global constructor\n";
        }
        ~Global()
        {
            std::cout << "Global destructor\n";
        }
    };
    
    class Local {
    public:
        Local(std::string var_name)
        {
            __var_name = var_name;
            std::cout << "Local:\"" << __var_name << "\" constructor\n";
        }
        ~Local()
        {
            std::cout << "Local:\"" << __var_name << "\" destructor\n";
        }
    private:
        std::string __var_name;
    };
    
    static Static static_var;
    Global global_var;
    
    void func(Local local)
    {
        Local local_in_func("local_in_func");
        return;
    }
    
    int main()
    {
        std::cout << "first line in main\n";
        Local local_var_in_main("local_var_in_main");
        func(local_var_in_main);
        {
            Local local_in_bracket("local_in_bracket");
        }
        std::cout << "last line in main\n";
    }
    

    执行结果:

    Static constructor
    Global constructor
    first line in main
    Local:"local_var_in_main" constructor
    Local:"local_in_func" constructor
    Local:"local_in_func" destructor
    Local:"local_var_in_main" destructor
    Local:"local_in_bracket" constructor
    Local:"local_in_bracket" destructor
    last line in main
    Local:"local_var_in_main" destructor
    Global destructor
    Static destructor
    

    这里可以清楚的看到各种类型变量的构造函数和析构函数的执行时机,基本上是符合预期的,这里有一个有意思的是local_var_in_main的析构函数被执行了两次,但是其构造函数仅被执行了一次,如果我们的场景是构造函数申请一块内存,析构函数释放这块内存,目前这种方式是否会有问题?该如何解决?

    我们知道,我们可以通过atexit来注册退出函数,我们可以在atexit中注册一些清理函数,在程序退出时能够将一些资源释放掉。那么,退出函数和全局变量的析构函数谁先执行呢?

    我们通过以下一段代码进行验证:

    #include <iostream>
    #include <cstdlib>
    #include <string>
    
    void exitfunc()
    {
        std::cout << "exitfunc\n";
    }
    
    class Static {
    public:
        Static()
        {
            std::cout << "Static constructor\n";
        }
        ~Static()
        {
            std::cout << "Static destructor\n";
        }
    };
    
    class Global {
    public:
        Global()
        {
            std::cout << "Global constructor\n";
        }
        ~Global()
        {
            std::cout << "Global destructor\n";
        }
    };
    
    class Local {
    public:
        Local(std::string var_name)
        {
            __var_name = var_name;
            std::cout << "Local:\"" << __var_name << "\" constructor\n";
        }
        ~Local()
        {
            std::cout << "Local:\"" << __var_name << "\" destructor\n";
        }
    private:
        std::string __var_name;
    };
    
    static Static static_var;
    Global global_var;
    
    void func(Local local)
    {
        Local local_in_func("local_in_func");
        return;
    }
    
    int main()
    {
        std::cout << "first line in main\n";
        atexit(exitfunc);
        Local local_var_in_main("local_var_in_main");
        func(local_var_in_main);
        {
            Local local_in_bracket("local_in_bracket");
        }
        std::cout << "last line in main\n";
    }
    

    执行结果:

    Static constructor
    Global constructor
    first line in main
    Local:"local_var_in_main" constructor
    Local:"local_in_func" constructor
    Local:"local_in_func" destructor
    Local:"local_var_in_main" destructor
    Local:"local_in_bracket" constructor
    Local:"local_in_bracket" destructor
    last line in main
    Local:"local_var_in_main" destructor
    exitfunc
    Global destructor
    Static destructor
    

    可以看到退出函数的执行顺序是先于全局变量和静态变量的析构函数的。

    那么如果我们在全局变量和静态变量的构造函数中注册exit函数的话,退出函数和析构函数的执行时机将会是怎样的呢?

    通过下面一段代码验证:

    #include <iostream>
    #include <cstdlib>
    #include <string>
    
    void exitfunc_global()
    {
        std::cout << "exitfunc in global\n";
    }
    
    void exitfunc_static()
    {
        std::cout << "exitfunc in static\n";
    }
    
    class Static {
    public:
        Static()
        {
            atexit(exitfunc_static);
            std::cout << "Static constructor\n";
        }
        ~Static()
        {
            std::cout << "Static destructor\n";
        }
    };
    
    class Global {
    public:
        Global()
        {
            atexit(exitfunc_global);
            std::cout << "Global constructor\n";
        }
        ~Global()
        {
            std::cout << "Global destructor\n";
        }
    };
    
    class Local {
    public:
        Local(std::string var_name)
        {
            __var_name = var_name;
            std::cout << "Local:\"" << __var_name << "\" constructor\n";
        }
        ~Local()
        {
            std::cout << "Local:\"" << __var_name << "\" destructor\n";
        }
    private:
        std::string __var_name;
    };
    
    static Static static_var;
    Global global_var;
    
    void func(Local local)
    {
        Local local_in_func("local_in_func");
        return;
    }
    
    int main()
    {
        std::cout << "first line in main\n";
        Local local_var_in_main("local_var_in_main");
        func(local_var_in_main);
        {
            Local local_in_bracket("local_in_bracket");
        }
        std::cout << "last line in main\n";
    }
    

    执行结果:

    Static constructor
    Global constructor
    first line in main
    Local:"local_var_in_main" constructor
    Local:"local_in_func" constructor
    Local:"local_in_func" destructor
    Local:"local_var_in_main" destructor
    Local:"local_in_bracket" constructor
    Local:"local_in_bracket" destructor
    last line in main
    Local:"local_var_in_main" destructor
    Global destructor
    exitfunc in global
    Static destructor
    exitfunc in static
    

    这说明一个问题,析构函数的注册和atexit的注册应该是同一种机制,这些退出函数应该是被注册在一条链表中,先注册的先执行,后注册的后执行。全局变量和静态变量的析构函数大概是什么时候注册的?这我想应该比较明显了吧。

    如果现在,我的需求是我们所注册的退出函数的执行时机必须晚于所有析构函数。有人可能会说我们在开发过程中不太会遇到这种场景,不,这是很有可能的。

    谷歌编码规范明确指出,避免声明全局或静态的类,就是为了规避不确定的析构函数以及其他退出函数的调用顺序。

    如何做到呢?我们可以通过gcc的attribute destructor来实现,且可以指定优先级。
    更多精彩文章请关注知乎:系统编程-白质。 csdn一般是看心情发。

    展开全文
  • C++全局变量与全局静态变量: <em><strong><span style="color:#ff0000">C++ 全局变量和全局静态变量的根本区别还是作用域的区别</span></strong></em> 1.全局变量是不显示...

     

    C++全局变量与全局静态变量:

    <em><strong><span style="color:#ff0000">C++ 全局变量和全局静态变量的根本区别还是作用域的区别</span></strong></em>
    1.全局变量是不显示用static修饰的全局变量,但全局变量默认是静态的,作用域是整个工程,在一个文件内定义的全局变量,在另一个文件中,通过extern 全局变量名的声明,
     就可以使用全局变量;
    2.全局静态变量是显示用static修饰的全局变量,作用域是所在的文件,其他的文件即使用extern声明也不能使用。
    3.全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式, 静态全局变量当然也是静态存储方式。 这两者在存储方式上并无
    不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序, 当一个源程序由多个源文件组成时,非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限
    制了其作用域, 即只在定义该变量的源文件内有效, 在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内,只能为该源文件内的函数公
    用, 因此可以避免在其它源文件中引起错误。所以把全局变量改变为静态变量后是改变了它的作用域, 限制了它的使用范围。
    
     
    1. 全局变量的作用域是整个项目,它只需要在一个源文件中定义就可以作用于所有的源文件,其它不包括全局变量定义的文件需要用extern关键字再次声明这个全局变量。 2. 全局变量、静态全局变量、静态局部变量都是在静态存储区(全局数据区)中分配空间的,而局部变量是在栈上分配空间的。 3. 全局变量、静态变量的生命期和程序生命期是一样的,在程序结束之后操作系统会回收空间。 4. 全局变量和静态变量都是保存在静态存储区中,生命期和程序一样,但是不同的是全局变量的作用域是整个项目,而静态全局变量是当前程序文件,静态局部变量则是当前函数体内。 全局变量和静态全局变量、静态局部变量默认值都是0,也就是在没有初始化变量值的时候默认为0。 5. 静态变量包含静态局部变量和静态全局变量。 静态局部变量具有局部作用域只对定义自己的函数可见,只被初始化一次,自从初始化一次之后直到程序运行期间一直都在。 静态全局变量具有全局作用域作用于定义它的程序文件但是不能作用于项目里的其它文件,这一点和全局变量不同。静态全局变量可以被多次初始化。 6. 把局部变量改变为静态变量之后是改变了它的存储方式和生命期。 把全局变量改变为静态变量之后是改变了它的作用域,限制了使用范围 7. 看以下几个例子 例子:测试静态局部变量  int Fun(void)操作系统会回收空间。 4. 全局变量和静态变量都是保存在静态存储区中,生命期和程序一样,但是不同的是全局变量的作用域是整个项目,而静态全局变量是当前程序文件,静态局部变量则是当前函数体内。 全局变量和静态全局变量、静态局部变量默认值都是0,也就是在没有初始化变量值的时候默认为0。 5. 静态变量包含静态局部变量和静态全局变量。 静态局部变量具有局部作用域只对定义自己的函数可见,只被初始化一次,自从初始化一次之后直到程序运行期间一直都在。 静态全局变量具有全局作用域作用于定义它的程序文件但是不能作用于项目里的其它文件,这一点和全局变量不同。静态全局变量可以被多次初始化。 6. 把局部变量改变为静态变量之后是改变了它的存储方式和生命期。 把全局变量改变为静态变量之后是改变了它的作用域,限制了使用范围 7. 看以下几个例子 例子:测试静态局部变量  int Fun(void)
      { 
        	//声明一个静态局部变量
    	static int num = 0;
    	++num;
    	return num;
       }
           for(int i = 0; i < 10; i++)	//声明一个静态局部变量
    	static int num = 0;
    	++num;
    	return num;
       }
           for(int i = 0; i < 10; i++)
      {
           cout<<Fun()<<" ";
      }
    /*
    输出结果是
    1 2 3 4 5 6 7 8 9 10
    */
    /*解释如下
    1. 静态局部变量只会被初始化一次,因此第一次调用Fun函数的时候num被初始化为0
    2. 然后每次调用的时候++num,第一次调用++num为1;第二次++num为2......
    3. 静态局部变量的生命期是整个程序因此值可以保存下来*/
     //声明一个静态全部变量
    static int value;
    
    //测试静态全局变量
    void G(void)解释如下
    1. 静态局部变量只会被初始化一次,因此第一次调用Fun函数的时候num被初始化为0
    2. 然后每次调用的时候++num,第一次调用++num为1;第二次++num为2......
    3. 静态局部变量的生命期是整个程序因此值可以保存下来*/
     //声明一个静态全部变量
    static int value;
    
    //测试静态全局变量
    void G(void)
     {
        value = 0;
        ++value;
     }
    
    for(int i = 0; i < 10; i++){
        G();
        cout<<value<<" ";
    }
    /*
    输出1 1 1 1 1 1 1 1 1 1
    解释
    1. 静态全局变量可以被初始化多次,因为每次调用G函数都会对静态全局变量初始化为0
    2. 每次value的值都初始化为0,++value为1,因此输出的值为1
    */
    //测试静态局部变量
    int Get(int x)
    {
        static int count = x;
    	return count+x;
    }
    printf("%d %d\n", Get(4), Get(5));
    /*
    输出9 10
    解释:
    1.printf是一个函数,根据函数参数入栈的顺序是从右到左,则先调用Get(5)再调用Get(4)
    2.调用Get(5)的时候,count第一次被初始化为5,则返回10;第二次调用Get(4)的时候count不再被初始化值为5返回9
    */
    
    
    <img id="currentImg" data-cke-saved-src="https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1511022855516&di=7e070e7ea0987556ba0675d6145088fb&imgtype=0&src=http%3A%2F%2Fimg.sucai.redocn.com%2Fattachments%2Fimages%2F201012%2F20101206%2F20101205_172d8cc1d8e717623d7cj8Ftg6eLZ2Aw.jpg" src="https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1511022855516&di=7e070e7ea0987556ba0675d6145088fb&imgtype=0&src=http%3A%2F%2Fimg.sucai.redocn.com%2Fattachments%2Fimages%2F201012%2F20101206%2F20101205_172d8cc1d8e717623d7cj8Ftg6eLZ2Aw.jpg" width="490" height="340" alt="" class="currentImg" />
    
    

    对变量和常量的认识:

    我认为,常量在编程中用的最多的的是数字,理由这是非常简单的,因为数字就是数字,它是不能改变的,例如:1就是1,2就是2,等等等等······
    变量在编程中相对来说是字母,例如:int a=12;b=13;a=b;经过这一赋值的操作,结果变为a=13,b=13。以我的观点来看这一过程为a=12的初始化被下面的a=b覆盖了。
    具体在程序中为:
    #include<iostream>
    using namespace std;
    int main()
    {
    	int a,b;
    	a=12;
    	b=13;
    	a=b;
    	cout<<"a= "<<a<<"\t"<<"b= "<<b<<endl;
    }
    	int a,b;
    	a=12;
    	b=13;
    	a=b;
    	cout<<"a= "<<a<<"\t"<<"b= "<<b<<endl;
    }
    
    /* 输出的结果为:a=13 b=13.
    
    
    
    
    
    
    展开全文
  • C++全局变量
  • C++全局变量和静态变量的使用

    千次阅读 2017-03-16 13:43:08
    参考:... (1)编译单元(模块) ... 第一步,将每个.cpp(.c)相应的.h文件编译成obj文件; 第二步,将工程中所有的obj文件进行LINK,生成最终.exe文件。  那么,错误可能在两个地方产
  • 1.两者作用域不同,全局变量的作用域是整个工程项目,静态全局变量作用域只在当前文件 2.全局变量在其他文件引用时,需使用extern声明 3.全局变量和静态全局变量都存储在静态存储区
  • c++全局变量和静态局部变量初始化的时间 1.全局变量初始化在主函数之前 2.静态局部变量初始化在第一次调用这个静态局部变量之前 #include <iostream> using namespace std; class A { public: A(int a):m_a...
  • 注意:本文所说的全局变量指的是 variables with static storage,措词来自 c++ 的语言标准文档。  什么时候初始化  根据 C++ 标准,全局变量的初始化要在 main 函数执行前完成,常识无疑,但是这个说法有点含糊...
  • 全局变量的使用方法 参考链接:https://www.cnblogs.com/Dageking/p/3185230.htmlhttps://blog.csdn.net/hi_baymax/article/details/82425457 强烈建议使用xxx.h和xxx.cpp的形式创建全局变量和全局函数。.h和....
  • 比较全局变量和静态全局变量 未经初始化的静态全局变量会被程序自动初始化为0; 静态全局变量在声明它的整个文件都是可见的,而在文件之外是不可见的; 静态变量都在全局数据区分配内存。 所以不能在两个文件生成...
  • 静态数据成员实际上是类域中的全局变量。所以,静态数据成员的定义(初始化)不应该被放在头文件中。 其定义方式与全局变量相同。举例如下: xxx.h文件 class base{ private: static const int _i;//声明,标准c++...
  • C++全局变量静态变量的构造与析构顺序 本人是C++的初学者,将自己学习过程中的一些收获记录在CSDN上,一方面能为大家提供帮助,另一方面能够方便自己日后查看。 关于在C++全局变量静态变量的构造与析构顺序,...
  • 我们知道在C++中的变量根据定义的位置的不同生存周期,具有不同的作用域。具体分为6种:
  • C和C++全局变量,局部变量,静态变量和常量

    万次阅读 多人点赞 2016-08-14 22:54:15
    C/C++中常量,静态变量,全局变量和局部变量的区别和作用。把局部变量改变为静态局部变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态全局变量是改变了它的作用域, 限制了它的使用范围。因此...
  • 今天上午写C++代码,被神马全局变量和静态全局变量困住了,出现了各种“重定义”和“链接”相关的error。到底在哪里声明,在哪里定义,哪里使用extern?傻傻分不清~ 本来我想自己总结一下的,后来看到网上的总结太...
  • 2、C++全局静态变量的析构销毁顺序是未定义的,特别是在多线程环境,多dll环境下,特别复杂,但是在某个编译器下,析构顺序是一定,按着构造的反顺序析构,其他都是随机,不确定的。 3、堆、栈、静态存储区 1...
  • C++ 静态局部变量 全局变量 Static local variable and Global variable Static local variable 对于 static local variable ,在 control 首次经过其声明时才会被初始化(除非其初始化是零初始化或常量初始化,这...
  • 参考: ... 跨模块(文件)的全局变量的初始化顺序无法保证!!!!这将导致存在前后依赖的变量问题十分麻烦。 全局变量在多线程中,特别容易出错!
  • 静态变量全局变量的初始化静态和全局变量的初始化默认初始化规则 静态和全局变量的初始化 为初始化的全局变量和静态变量 编译器会同等处理, 放入BSS段(这是全零的内存段),所以会被默认初始化为0 默认初始化...
  • 通常的想法是定义一个全局变量来实现。但是这样一来,变量已经不再属于函数本身了,不再仅受函数的控制,给程序的维护带来不便。静态局部变量正好可以解决这个问题。静态局部变量保存在全局数据区,而不是保存在栈中...
  • 一个由C/C++编译的程序占用的内存分为以下几个部分 栈区(stack) 由编译器自动分配释放 ,存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈,如果还不清楚,那么就把它想成数组,它的内存分配...
  • 静态成员变量和静态成员函数 class ClassA { int a; int b; static int c; //静态成员变量 static void xxx_fun() //静态成员函数 { ... } } 普通成员变量每个对象都有各自的一份,静态成员变量所有对象...
  • 按存储区域分:全局变量、静态全局变量和静态局部变量都存放在内存的全局数据区,局部变量存放在内存的栈区 按作用域分: 1、全局变量在整个工程文件内都...4、全局变量和静态变量如果没有手工初始化,则由编译...
  • 例如外部变量虽属于静态存储方式,但不一定是静态变量,必须由 static加以定义后才能成为静态外部变量,或称静态全局变量。 2. 静态局部变量 静态局部变量属于静态存储方式,它具有以下特点: (1)静态局部变量...
  • 局部变量、全局变量和静态变量之间的区别 (1)局部变量 定义: 在一个函数内部定义的变量是局部变量,它只在本函数范围内有效。 1.主函数main定义的变量也只在主函数有效; 2.不同函数中可以使用名字相同的变量,...
  • C++ 全局变量、局部变量、静态全局变量静态局部变量的区别 C++ 变量根据定义的位置的不同的生命周期,具有不同的作用域,作用域可分为 6 种:全局作用域,局部作用域,语句作用域,类作用域,命名空间作用域...
  • 3、全局区(静态区)(static)—,全局变量和静态变量的存储是放在一块的,初始化的全局变量和静态变量在一块区域(.data),未初始化的全局变量和未初始化的静态变量在相邻的另一块区域(.bss)。 – 程序结束后由系统...
  • 全局变量存储在静态存储区,其作用域是全局作用域,生命周期是整个程序的生命周期。 具体而言,在一个文件中定义一个全局变量,在程序的其它文件中可以通过extern关键字再次声明说明该变量已经定义。 2. 静态...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 138,559
精华内容 55,423
关键字:

c++全局变量和静态变量

c++ 订阅