精华内容
下载资源
问答
  • 全局变量、文件域的静态变量的静态成员变量在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变量显然是不合理的。
    静态成员其实和全局变量地位是一样的,只不过编译器把它的使用限制在类作用域内(不是类对象,它不属于类对象成员),要在类的定义外(不是类作用域外)初始化。

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

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

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

    展开全文
  • 易语言静态变量初始化源码,静态变量初始化,静态变量初始化例子
  • 易语言源码易语言静态变量初始化源码.rar 易语言源码易语言静态变量初始化源码.rar 易语言源码易语言静态变量初始化源码.rar 易语言源码易语言静态变量初始化源码.rar 易语言源码易语言静态变量初始化源码.rar ...
  • Spring框架给静态变量初始化

    千次阅读 2018-11-27 19:33:57
    工作中遇到一个问题给工具类静态变量初始化,就记录了一下。 这里需要注意一下不可以直接使用@Value注解的方式给静态变量初始化赋值; 1.第一种是用spring配置文件 下面是java,其中注释的注解是试验注解方式,...

    工作中遇到一个问题给工具类静态变量初始化,就记录了一下。

    这里需要注意一下不可以直接使用@Value注解的方式给静态变量初始化赋值;

    1.第一种是用spring配置文件

    下面是java类,其中注释的注解是试验注解方式,结果是得不到值;一定要有静态变量的set方法,否则会报错;本来这个demo是测试@PostConstruct注解的;

    package test;
    
    import javax.annotation.PostConstruct;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    //@Component("testPostConstruct")
    public class TestPostConstruct {
    
    	
    //    @Value("${name}")
    	private String name;
    	
    //    @Value("${age}")
    	private static String age;
    	
        public TestPostConstruct() {
            System.out.println("此时b还未被注入:name = " + name);
        }
     
        @PostConstruct
        private void init() {
            System.out.println("@PostConstruct将在依赖注入完成后被自动调用: name = " +name);
        }
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public static String getAge() {
    		System.out.println("age:"+TestPostConstruct.age);
    
    		return age;
    	}
    
    	public static void setAge(String age) {
    		TestPostConstruct.age = age;
    	}
    
    	@Override
    	public String toString() {
    		return "TestPostConstruct [name=" + name +"static:age:"+age+ "]";
    	}
        
        
    }
    

    Spring配置文件中配置工具类的bean;

     	<bean id="testPostConstruct" class="test.TestPostConstruct">
     		<property name="name">//成员变量
     			<value>${name}</value>
     		</property>
     		<property name="age">//静态变量
     			<value>${age}</value>
     		</property>
     	</bean>
     	
     	
    	<bean id="propertyConfigurer" //读取配置文件
    	      class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    	      <property name="location">
    	          <value>test.properties</value>
    	      </property>
    	</bean>

    配置文件test.properties

    name=oliver
    age=17

    测试demo,用Junit测试

    public class TestCase {
    	
    	ApplicationContext ctx;
    	@Before
    	public void init(){
    		ctx = 
    		new ClassPathXmlApplicationContext("spring-web.xml");
    	}
    	
    	@Test
    	public void testPostConstruct(){
    		System.out.println(TestPostConstruct.getAge());
    	}
    }

    测试结果

    此时b还未被注入:name = null
    @PostConstruct将在依赖注入完成后被自动调用: name = oliver
    age:17
    17
    

    2.把注解@Value用在set方法上,注意这里的set方法没有static修饰符

    package test;
    
    import javax.annotation.PostConstruct;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    @Component("testPostConstruct")
    public class TestPostConstruct {
    
    
        @Value("${name}")
    	private String name;
    	
       
    	private static String age;
    	
        public TestPostConstruct() {
            System.out.println("TestPostConstruct.age = " +age);
            System.out.println("此时b还未被注入:name = " + name);
        }
     
        
        @PostConstruct
        private void init() {
            System.out.println("TestPostConstruct.age = " +age);
            System.out.println("@PostConstruct将在依赖注入完成后被自动调用: name = " +name);
        }
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public static String getAge() {
    		System.out.println("age:"+TestPostConstruct.age);
    
    		return age;
    	}
    	 @Value("${age}")
    	public void setAge(String age) {
    		TestPostConstruct.age = age;
    	}
    
    	@Override
    	public String toString() {
    		return "TestPostConstruct [ name=" + name +"static:age:"+age+ "]";
    	}
    
    	
        
    }
    

    测试类同第一种一样

    测试结果如下

    TestPostConstruct.age = null
    此时b还未被注入:name = null
    TestPostConstruct.age = 17
    @PostConstruct将在依赖注入完成后被自动调用: name = oliver
    age:17
    17

    正常框架是可以实现的,可惜的是公司框架不知道做了什么操作两种方式都无法实现,好气。。。

    如有遇到相似的问题,有更好的方式解决,希望给予交流

    展开全文
  • 关于C++中的静态变量,或者说中结构体中的静态变量的初始化问题,解释如下: ...2.或结构的静态变量初始化必须在外部,这个外部是哪里呢? 上面这是test.h,这里定义了静态变量x,那么我...

    关于C++中类中类的静态变量,或者说类中结构体中的静态变量的初始化问题,解释如下:

    1.首先,定义在结构体或者类中的变量,在头文件中定义时仅仅是一个声明,并未分配空间,只有在静态变量被初始化之后才分配空间,因此千万不要再头文件中初始化静态变量,容易被其他文件引用,造成空间浪费

    2.类或结构的静态变量初始化必须在外部,这个外部是哪里呢?

     上面这是test.h,这里定义了静态变量x,那么我们在哪里初始化呢?

    这是test.app文件,显然我们在Test构造函数外面初始化了X,那么这里的y又是怎么回事呢?

    回到test.h

    看到没,类中类,结果其中的静态变量也是需要在最外面的类定义之外进行初始化,最后编译是通过的。

    展开全文
  • 在工具中,通常会初始化一些单例变量,这些变量由于只会初始一次,并不适合放在构造函数中,因此通常选择在静态代码块中执行,那么在一个中,就会涉及到静态变量和静态代码块的初始化执行顺序问题。 public ...

    在工具类中,通常会初始化一些单例变量,这些变量由于只会初始一次,并不适合放在构造函数中,因此通常选择在静态代码块中执行,那么在一个类中,就会涉及到静态变量和静态代码块的初始化执行顺序问题。

    public class Test
    {
    	private static Test t = new Test();
    
    	private static String a = "1";
    
    	static 
    	{
    		System.out.println(Test.a);
    		Test.a = "2";
    		System.out.println(Test.a);
    		System.out.println(Test.b);
    		Test.b = "4";
    		System.out.println(Test.b);
    	}
    
    	private static String b = "3";
    
    	private Test()
    	{
    		System.out.println("Constructor");
    		System.out.println(Test.a);
    		System.out.println(Test.b);
    	}
    
    	public static void start()
    	{
    
    	}
    
    	public static void main(String[] args)
    	{
    		Test.start();
    	}
    }

    上面的代码示例中,定义了3 个静态变量和一个静态代码块。执行输出如下:


    根据输出显示:

    首先调用构造函数Test() 初始化t,此时打印a,b的值为null,说明此时,a,b还未被初始化赋值。

    打印结果1说明在执行完构造函数之后,a被初始化为1。改变a值为2,当打印a时,输出2.

    接着打印b,却发现输出为null,说明此时b还未被初始化。

    给b赋值为4,打印结果输出4.

    那么b 在什么时候初始化呢,其实是在执行完第二个system.out.println(b)时,就开始初始化b为3.

    可以增加第二块静态代码块进行验证:

    public class Test
    {
    	private static Test t = new Test();
    
    	private static String a = "1";
    
    	static 
    	{
    		System.out.println(Test.a);
    		Test.a = "2";
    		System.out.println(Test.a);
    		System.out.println(Test.b);
    		Test.b = "4";
    		System.out.println(Test.b);
    	}
    
    	private static String b = "3";
    	static 
    	{
    		System.out.println(Test.b);
    	}
    
    	private Test()
    	{
    		System.out.println("Constructor");
    		System.out.println(Test.a);
    		System.out.println(Test.b);
    	}
    
    	public static void start()
    	{
    
    	}
    
    	public static void main(String[] args)
    	{
    		Test.start();
    	}
    }
    输出结果为


    在private static String b = "3" 之后增加第二块代码块之后,打印b值为3,说明b在执行完第二个system.out.println(b)时,被赋值b为3.

    由此可见,静态代码块会根据静态变量的声明顺序及静态代码块中自身的代码顺序初始化静态变量。

    上述代码等价于下面代码:

    public class Test
    {
    	private static Test t ;
    
    	private static String a;
    
    	static 
    	{
    		Test.t = new Test();
    		Test.a = "1";
    		System.out.println(Test.a);
    		Test.a = "2";
    		System.out.println(Test.a);
    		System.out.println(Test.b);
    		Test.b = "4";
    		System.out.println(Test.b);
    		Test.b = "3";
    	}
    
    	private static String b;
    	static 
    	{
    		System.out.println(Test.b);
    	}
    
    	private Test()
    	{
    		System.out.println("Constructor");
    		System.out.println(Test.a);
    		System.out.println(Test.b);
    	}
    
    	public static void start()
    	{
    
    	}
    
    	public static void main(String[] args)
    	{
    		Test.start();
    	}
    }
    实际上,jvm就是按照上述静态代码块中的顺序初始化静态变量的。

    可以执行 javap -c Test查看Test的字节码:



    为了简化不必要的指令,删除了所有的打印语句及第二次代码中的追加的静态代码块。从字节码中我们看到,在静态代码块中,首先执行初始化方法,并初始化t。然后依次从常量池中读取字符串常量初始化a,b。

    展开全文
  • 静态变量初始化

    千次阅读 2014-02-27 11:17:29
    我们大家都知道,对于静态变量、静态初始化块、变量、初始化块、构造器,它们的初始化顺序以此是(静态变量、静态初始化块(顺序按声明顺序))>(变量、初始化块)>构造器。我们也可以通过下面的测试代码来验证这...
  • Java静态变量初始化时机

    千次阅读 2015-06-05 10:55:17
    静态变量初始化方式: 1.声明时初始化; 2.静态块中初始化; 测试: package com.skymr.learn; /** * 静态变量初始化顺序测试 * @author skymr * */ public class InstanceTest2 { static int b = 11; ...
  • 静态变量初始化的时机

    千次阅读 2017-10-02 16:40:48
    静态变量的内存分配和初始化 对于C语言的全局和静态变量,不管是否被初始化,其内存空间都是全局的;如果初始化,那么初始化发生在任何代码执行之前,属于编译期初始化。由于内置变量无须资源释放操作,仅需要...
  • 我们大家都知道,对于静态变量、静态初始化块、变量、初始化块、构造器,它们的初始化顺序以此是(静态变量、静态初始化块)>(变量、初始化块)>构造器。我们也可以通过下面的测试代码来验证这一点:  Java代码 ...
  • 1.全局变量 全局变量无疑要在main函数开始前执行完成,但可细分为在编译时和在运行时初始化,即static initialization和dynamic initialization。 static initialization 静态初始化按照我的理解,是针对那些较为...
  • 静态成员变量初始化时间

    千次阅读 2020-05-02 14:28:37
    首先先搞明白 声明、定义、初始化 ...类静态成员变量在main函数执行前完成初始化,有静态初始化和动态初始化 static initialization: 静态初始化指的是用常量来对变量进行初始化,主要包括 zero initialization 和...
  • C语言静态变量初始化问题

    千次阅读 2018-02-10 12:45:45
    书上的解释是,用static修饰的变量会自动初始化。  为什么会被初始化呢?首先我们看一段话: 可执行程序和内存映像的区别在于:可执行程序位于磁盘上,内存映像位于内存中,可执行程序没有堆栈,可执行程序虽然也...
  • STL编程之--静态变量初始化方法

    千次阅读 2013-09-27 16:16:10
    静态变量在STL模板编程中,总是让新手摸不着头脑,STL奇奇怪怪的语法再加上初始化的特定...在普通中定义的静态变量初始化。 2. 在STL模板中定义的静态变量初始化。下面将分别说明在这两种情况下,应该如何正确的初
  • jvm加载机制及静态变量初始化

    千次阅读 2018-08-08 12:03:43
    1.加载:对所有进行加载,在内存中生成一个代表这个的java.lang.Class对象;这里的包涵java文件编译后的class文件, jar包和war包;jsp文件转换成的class;动态代理生成的class对象及其他。 ------jar和...
  • 单例模式中静态变量初始化与不初始化有什么区别?  public class Singleton {  private static Singleton obj = new Singleton();  public static int counter1;  public static int counter2 = 0;  ...
  • template class A { private: T m; public: A(T x) { m = x; } static A x; ...这个x怎么初始化? 如果把x的类型换成其他已知类型(如int),是可以初始化的但这个怎么搞有人知道吗?谢谢
  • Java静态变量初始化

    千次阅读 2019-06-28 01:12:53
    静态变量初始化方式 在静态变量的声明时初始化 在静态代码块中初始化 静态变量初始化时机 在的生命周期内,静态变量只会被初始化一次。 静态变量初始化时机...静态变量初始化时机与初始化时机紧密...
  • 主要介绍了Java静态和非静态成员变量初始化过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 静态成员变量初始化问题

    千次阅读 2019-08-12 20:24:37
    我们都知道静态成员变量必须在初始化,不仅如此,静态成员变量最好在源文件中初始化,而不能在头文件初始化,否则,编译的时候就会报错"symbol multiply defined". 举例: /*--testA.h--*/ class A ...
  • 静态变量初始化及使用问题

    千次阅读 2013-06-13 17:26:38
    不能在定义对象时对变量初始化,就是不能用构造函数来初始化,而且使用时应加上类名,而不是对象。 静态数据成员的使用方法和注意事项如下:  1、静态数据成员在定义或说明时前面加关键字static。  2、静态成员...
  • java基础-延伸,变量初始化顺序从这篇文章java基础-反射1(类型信息,Class对象简介,Class对象初始化) 我们可以了解到在第一次使用时加载到内存中的顺序有三个步骤 的加载:由加载器执行,根据类名查找...
  • 2.静态成员不能在定义里边初始化,只能在class body外初始化。 3.静态成员仍然遵循public,private,protected访问准则。 4.静态成员函数没有this指针,它不能返回非静态成员,因为除了对象会调用它外,本身也...
  • C++静态变量初始化

    千次阅读 2017-01-15 12:36:34
    C++静态变量 注意事项: 1.静态变量首先是存在于任何对象之外,它不属于任何一个,所以对象中不包含任何与静态数据成员有关的数据。 2.静态成员函数不与任何对象绑定在一起,它们不包含this指针。 ...
  • 静态变量初始化

    千次阅读 2015-07-21 10:20:40
    静态数据成员的使用方法和注意事项如下:  1、静态数据成员在定义或... (1) 初始化体外进行,而前面不加static,以免与一般静态变量或对象相混淆。  (2) 初始化时不加该成员的访问权限控制符private,
  • 探索了在一条继承链中静态初始化块和静态变量初始化、初始化块和实例域初始化、构造函数的执行顺序(见http://blog.csdn.net/maple1997/article/details/79508981),现在继续探索一下如果new一个自身的对象赋值...
  • Java加载器:静态变量初始化

    千次阅读 2015-11-02 21:10:14
    访问某个或接口的静态变量,或者对该静态变量赋值(如 int b = Test.a 或者 Test.a = b) * 3.调用的静态方法(如 Test.doSomething()) * 4.反射(如Class.forName("")) * 5.初始化一个的子类(如class Parent...
  • C++全局和静态变量初始化顺序的研究 我在编程的时候遇到了一个非常棘手的问题,就是静态变量初始化的问题。有的情况一个全局(静态)变量依赖另外一个全局(静态)的变量。比如在工厂模式中使用隐式注册注册一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 538,562
精华内容 215,424
关键字:

类静态变量初始化