精华内容
下载资源
问答
  • 静态局部变量的特点: 1.不会随着函数的调用退出而发生变化,不过,尽管该变量还...虽然用全局变量也可以达到上述目的,但全局变量有时会造成意外的副作用,因此仍以采用局部静态变量为宜。复制代码 代码如下:functio
  • 全局变量、文件域的静态变量和类的静态成员变量在main执行之前的静态初始化过程中分配内存并初始化局部静态变量(一般为函数内的静态变量)在第一次使用时分配内存并初始化。这里的变量包含内置数据类型自定义...

    全局变量、文件域的静态变量和类的静态成员变量在main执行之前的静态初始化过程中分配内存并初始化;局部静态变量(一般为函数内的静态变量)在第一次使用时分配内存并初始化。这里的变量包含内置数据类型和自定义类型的对象。

    class B{
    public:
    	B()
    	{
    		cout << "B constructor called" << endl;
    	}
    	~B()
    	{
    		cout << "B desconstructor called" << endl;
    	}
    };
    class A{
    public:
    	A()
    	{
    		cout << "A constructor called" << endl;
    	}
    	~A()
    	{
    		cout << "A desconstructor called" << endl;
    	}
    private:
    	static B b;
    };
    
    class C{
    public:
    	C()
    	{
    		cout << "C constructor called" << endl;
    	}
    	~C()
    	{
    		cout << "C desconstructor called" << endl;
    	}
    };
    class D{
    public:
    	D()
    	{
    		cout << "D constructor called" << endl;
    	}
    	~D()
    	{
    		cout << "D desconstructor called" << endl;
    	}
    };
    class E{
    public:
    	E()
    	{
    		cout << "E constructor called" << endl;
    	}
    	~E()
    	{
    		cout << "E desconstructor called" << endl;
    	}
    };
    int f()
    {
    	system("pause");
    	return 0;
    }
    C c;
    static E e;
    B A::b = B();//静态成员变量在类外初始化
    int main()
    {
    	_onexit(f);
    	A *pa = new A;
    	B b;
    	static D d;
    	delete pa;
    	return 0;
    }
    输出:

    C constructor called//全局变量初始化在main执行之前
    E constructor called//全局静态变量初始化在main之前

    B constructor called//类中的静态成员变量在类外初始化在main之前

    A constructor called//main中执行A的默认构造函数,但是没有调用B的默认构造函数,(若A中的成员变量b不是static型的,那么在调用A的构造函数                                                                                                             时,系统会调用B的默认构造函数,这里涉及到构造函数成员初始化列表的作用)

    B constructor called//构造b

    D constructor called//局部静态变量在第一次使用时初始化

    A desconstructor called//显示调用A的析构

    B desconstructor called//局部变量在栈上,早析构

    D desconstructor called//局部静态变量出了main后析构

    B desconstructor called//类的静态成员变量析构

    E desconstructor called//全局静态变量析构

    C desconstructor called//全局变量析构,这后边三个析构顺序,应该和它们的构造顺序相反!!!!

    下边内容转载:

    有些成员变量的数据类型比较特别,它们的初始化方式也和普通数据类型的成员变量有所不同。这些特殊的类型的成员变量包括:

    a.引用

    b.常量

    c.静态

    d.静态常量(整型)

    e.静态常量(非整型)

    常量和引用,必须通过参数列表进行初始化。这里不包括常量静态成员变量,因为无法通过构造函数初始化静态类数据。但是非常量静态类数据,可以通过构造函数体赋值。

    例如:

    class Test {
    public:
    	int a;
    	static int b;
    public:
    	Test(int _a, int _b) : a(_a){
    		b = _b;
    	}
    };
    int Test::b;
    int main() {
    	Test t1(0, 0), t2(1, 1);
    	t1.b = 10;
    	t2.b = 20;
    	printf("%u %u %u %u", t1.a, t1.b, t2.a, t2.b);
    	system("pause");
    	return 0;
    }
    但如果是常量静态类数据就不行了,因为不能对常量赋值。

    静态成员变量的初始化也颇有点特别,是在类外初始化且不能再带有static关键字,记住是类外初始化,但可以在构造函数中赋值 ,其本质见文末。

    参考下面的代码以及其中注释:

        #include   
        using namespace std;  
          
        class BClass  
        {  
        public:  
         BClass() : i(1), ci(2), ri(i){} // 对于常量型成员变量和引用型成员变量,必须通过参数化列表的方式进行初始化  
                                                        //普通成员变量也可以放在函数体里,但是本质其实已不是初始化,而是一种普通的运算操作-->赋值运算,效率也低  
        private:  
         int i;                                  // 普通成员变量  
         const int ci;                           // 常量成员变量  
         int &ri;                                // 引用成员变量  
         static int si;                          // 静态成员变量  
         //static int si2 = 100;                 // error: 只有静态常量成员变量,才可以这样初始化  
         static const int csi;                   // 静态常量成员变量  
         static const int csi2 = 100;            // 静态常量成员变量的初始化(Integral type)    (1)  
         static const double csd;                // 静态常量成员变量(non-Integral type)  
         //static const double csd2 = 99.9;      // error: 只有静态常量整型数据成员才可以在类中初始化  
        };  
          
        //注意下面三行:不能再带有static  
        int BClass::si = 0; // 静态成员变量的初始化(Integral type)  
        const int BClass::csi = 1; // 静态常量成员变量的初始化(Integral type)  
        const double BClass::csd = 99.9; // 静态常量成员变量的初始化(non-Integral type
    静态成员属于类作用域,但不属于类对象,和普通的static变量一样,程序一运行就分配内存并初始化,生命周期和程序一致。
    所以,在类的构造函数里初始化static变量显然是不合理的。
    静态成员其实和全局变量地位是一样的,只不过编译器把它的使用限制在类作用域内(不是类对象,它不属于类对象成员),要在类的定义外(不是类作用域外)初始化。

    下面再说说成员变量是引用的情况:

    因为引用是别名的意思,所以定义应用肯定是外部有定义,然后在构造函数初始化列表中被初始化的。

    如果两个类要对第三个类的数据进行共享处理,可以考虑把第三个类作为这两个类的引用类型的成员变量。

    展开全文
  • 首先我们都知道静态变量是随着类的加载而加载的,所以当类加载进内存的时候,静态变量就已经伴随着类的加载而初始化进内存了,并且静态变量只在类加载时加载一次,存放在方法区中的静态区中。 再者就是全局变量也...

    首先我们都知道静态变量是随着类的加载而加载的,所以当类加载进内存的时候,静态变量就已经伴随着类的加载而初始化进内存了,并且静态变量只在类加载时加载一次,存放在方法区中的静态区中。

    再者就是全局变量也就是成员变量,全局变量(成员变量)是在创建对象的时候初始化的,所以只要创建对象就会初始化全局变量(成员变量),并存放在堆内存中。

    展开全文
  • 局部静态变量:静态区 全局变量: 静态区的常量区 全局静态变量:静态区 在进行C/C++编程时,需要程序员对内存的了解比较精准。经常需要操作的内存可分为以下几个类别:   1、栈区(stack)— 由编译器自动分配...

    局部变量:    栈区
    局部静态变量:静态区
    全局变量:    静态区的常量区
    全局静态变量:静态区

    在进行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"优化成一个地方。 
    }



    展开全文
  • 还有对全局变量是不是也是编译赋初值?没有初值是不是自动给它赋值(网上好像有这么讲的),那什么时候在内存开辟空间呢(这个图上的生存期从main函数就开始)? 这些可能涉及计算机组成原理,我没学过,希望哪位...
  • 根据定义变量位置的不同,可以将变量分为成员变量和局部变量。 成员变量是 定义在一个类的变量:类中方法外 局部变量是定义在一个方法内的变量:方法中 成员变量分为: 静态属性:随类的存在而存在,是在类加载的...

    根据定义变量位置的不同,可以将变量分为成员变量和局部变量。
    成员变量是 定义在一个类的变量:类中方法外
    局部变量是定义在一个方法内的变量:方法中

    成员变量分为:
    静态属性:随类的存在而存在,是在类加载的初始化
    非静态属性:随实例的属性存在而存在。

    局部变量:
    局部变量不能加static,包括protected, private, public这些也不能加。局部变量保存在栈中。
    局部编程必须在声明时初始化。

    成员变量和局部变量区别:
    成员变量可以不显式初始化,它们可以由系统设定默认值;局部变量没有默认值,所以必须设定初始赋值。
    成员变量存在于堆内存,局部变量存在于栈内存。

    静态变量:类中方法外,用static修饰
    生命周期:JVM第一次读到这个类并加载类时开始,类销毁不存在。
    类加载过程:

    1. 加载父类(如果父类已经加载过,则不在加载)。
    2. 初始化静态属性 。
    3. 按顺序的初始化静态代码块 初始化的前提就是分配空间 。

    静态变量存在于方法区即静态区(方法区包含整个程序中唯一存在的元素)

    全局变量(在java中可以理解为用static final修饰):在java中全局变量也称成员变量,是创建对象的时候分配内存的。全局常量存于全局数据区。
    创建对象过程为:

    1. 分配空间。
    2. 创建父类对象。
    3. 初始化成员变量。
    4. 调用构造方法创建一个对象。

    方法(包括静态方法)中不能有静态变量,方法中存在的是局部变量,而不是静态变量。静态变量是定义在类中,方法体外面的。

    展开全文
  • 全局变量局部变量、全局静态变量局部静态变量的区别。要从分配内存的位置作用域入手来解释。 全局变量,分配的内存在静态存储区内存上面,其作用域是全局作用域,也就是整个程序的生命周期内都可以使用,...
  • 全局变量、全局静态变量局部变量、局部静态变量区别
  • 局部变量: 创建在栈区(向下生长),生命周期存在于当前作用域中。 创建时