精华内容
下载资源
问答
  • C++11中变量初始化方法汇总

    千次阅读 2019-10-25 17:19:58
    参考资料 [1] C++ Primer中文版(第5版) 1 背景     参考资料[1]P39提到,在C++语言中,初始化...

    参考资料

    [1] C++ Primer中文版(第5版)

    1 背景

        参考资料[1]P39提到,在C++语言中,初始化赋值并不是同一个概念:

        初始化创建变量时赋予其一个初始值。

        赋值:把对象(已经创建)的当前值擦除,而用一个新值来代替。

        参考资料[1]P39指出,初始化是一个异常复杂的问题,因此有必要专门对这个问题进行总结。

    2 列表初始化

        参考资料[1]P39指出,作为C++11新标准的一部分,用花括号来初始化变量得到了全面应用(在此之前,只是在初始化数组的时候用到)。列表初始化有两种形式,如下所示:

    int a = {0};  // 列表初始化方式1
    int a{0};      // 列表初始化方式2
    

        说明:上述的两种方式都可以将变量a初始化为0。

    2.1 局限

        当对内置类型使用列表初始化时,若初始值存在丢失的风险,编译将报错,如:

    int a = 3.14;   // 正确,虽然会丢失小数部分,但是编译器不报错。
    int a = {3.14}; // 错误,因为将会丢失小数部分(其实,g++只是对此提示警告而已,并非错误)。
    

       使用g++ 4.8.4对上述两个初始化方式分别进行测试,前者无错误无警告,但是后者提示警告(不是错误!):

    warning: narrowing conversion of ‘3.1400000000000001e+0’ from ‘double’ to ‘int’ inside { } [-Wnarrowing]
    

    2.2 拓展

        参考资料[1]P39还提到,由花括号括起来的初始值,不仅可以用于初始化变量,还可以用于为对象(旧变量)赋新值

    int a = 1;   // 定义变量,并且初始化为1
    a = {3};     // 为变量a赋新值3
    

    2.3 用处

        可以用在任何需要变量初始化的地方,例如第6章的类成员初始化,以及在for()中定义的变量:

    for (int i{0}; i > 10; i++) {
    ...
    }
    

    3 拷贝初始化

        参考资料[1]P76指出,如果使用等号初始化一个变量,实际上执行的是拷贝初始化(copy initialization),编译器把等号右侧的初始值拷贝到新创建的对象中去:

    string s1;       // 默认初始化为空字符串
    string s2 = s1;  // 拷贝初始化,s2是s1的副本
    

    4 直接初始化

        参考资料[1]P76指出,如果在新创建的变量右侧使用括号将初始值括住(不用等号),则执行的是直接初始化(direct initialization):

    string s1();        // 直接初始化为空字符串 
    string s2("hi");    // 直接初始化
    string s3(3, 'c');  // 直接初始化,s2的内容是ccc
    

        参考资料[1]P89指出,使用圆括号提供初值是用来构造(construct)对象,因此可以知道,所谓的直接初始化就是显式的调用相应的构造函数。参考资料[1]P262归纳了值初始化的3种情况:

    a)在数组初始化过程中如果提供的初值数量少于数组大小时;
    b)当不使用初始值定义一个局部静态变量时;
    c)当通过T()形式的表达式显式地请求值初始化时(T是类型名)。

        参考资料[1]P265指出,explicit构造函数只能用于直接初始化。


    4.1 特例——vector

        vector使用直接初始化时,需要指定一个重复次数:

    vector<string> v1("hello", "world"); // 错误
    vector<string> v2{"hello", "world"}; // 正确,可以列表初始化
    vector<string> v3(2, "hello");       // 正确,直接初始化要指定一个重复次数,此处v3初始化为"helloheloo"
    

        有时候,就算是用的是花括号,也是起到直接初始化的作用(相当于圆括号):

    vector<string> v4{10};      // 直接初始化,v4有10默认初始化的元素
    vector<string> v5{10, "hi"};// 直接初始化,v5有10个值为“hi”的元素
    

        原则:参考资料[1]P89指出,初始化过程会尽可能地把花括号内的值当成是元素初始值列表来处理(列表初始化),只有无法执行列表初始化时才会考虑其他初始化方式。

    5 默认初始化

        参考资料[1]P40指出,如果定义变量时没有指定初值,则变量被默认初始化,具体值由变量类型及其所在位置决定。参考资料[1]P262归纳了发生默认初始化的3种情况。

    5.1 内置类型

    5.1.1 局部变量

    5.1.1.1 非static局部变量

        参考资料[1]P40指出,在函数体内部内置类型变量(包括指针 )不被初始化。参考资料[1]P47指出,与其它内置类型一样,在块作用域内定义的指针如果没有被初始化,也将拥有一个不确定的值。参考资料[1]P185介绍自动对象的时候,也指出这个问题。

    3.1.1.2 static局部变量

        参考资料[1]P185指出,如果局部变量没有显式的初始化值,它将执行值初始化(不是默认初始化!),内置类型的局部静态变量初始化为0。

    5.1.2 全局变量

        初始化为0。

    5.2 类类型

        参考资料[1]P236指出,类通过一个特殊的构造函数来控制默认初始化过程,这个类叫做默认构造函数。默认构造函数无需任何实参。参考资料[1]P637也指出,每个类各自定义其初始化对象的方式(默认构造函数)。例如,std::string,不管是定义于局部还是全局,都会默认初始化为

    string a;                             // 默认初始化为空字符串
    tuple<size_t, size_t, size_t> threeD; // 使用tuple的默认构造函数对每个成员进行值初始化
    

    5.3 例外情况

        参考资料[1]P89指出,有些类不支持默认初始化,必须明确地提供初始值。根据参考资料[1]P236的说明可猜测,此类无默认构造函数。例如下面的定义,将会出现编译错误。

    class Person {
    	public:
    	Person(string name, string addr):  // 由于自定义了构造函数,编译器
    	name(this->name), addr(this->addr) // 不会为Person生成默认构造函数,
    	{}								   // 而Person中并没有显式定义默认
    									   // 构造函数,因此Person没有默认
    									   // 构造函数!
    	private:
    	  const string name;
    	  const string addr;
    };
    
    int main(void)
    {
    	Person p;
    }
    

        使用g++4.8.4编译上述代码,提示:

    test.cpp|36 col 9| error: no matching function for call to ‘Person::Person()

    6 值初始化

        参考资料[1]P88提到了值初始化的例子,只提供vector对象容纳元素数量而不提供初始值,此时会创建一个值初始化的元素初值,并把它赋给容器中的所有元素。这个初值由vector对象中元素的类型决定:

    vector<int> ivec(10);  // 10个元素,每个都初始化为0
    

        参考资料[1]P262则指出,对象 默认初始化值初始化时自动执行 默认构造函数

    7 类成员初始化

    7.1 类内初始值

        参考资料[1]P65指出,C++11新标准规定,可以为类内数据成员提供一个类内初始值。参考资料[1]P88则指出,类内初始值只能使用拷贝初始化列表初始化(不能直接初始化)。参考资料[1]P246则指出,当我们提供一个类内初始值时,必须以符号=或者花括号表示。没有提供类内初始值的成员将被默认初始化。

    class A {
        int a{0};    // 列表初始化为0
        int b = {1}; // 列表初始化为1
        int c = 2;   // 传统初始化为2
        int d;       // 默认初始化,具体值未定义
        int e(3);    // 错误:不能将初始值放在括号内(直接初始化)! 
    };
    

    展开全文
  • Java成员变量初始化顺序

    千次阅读 2018-11-24 22:28:49
    1、类变量初始化 类变量简单来说就是被static修饰的变量,类变量属于类本身 1.1 初始化时机 定义类变量时指定初始化 静态代码块中对类变量指定初始化 1.2 初始化顺序 上述两种方式在程序中的排列顺序即为执行顺序 ...

    Java中成员变量分为两类:1、类变量 2、实例变量

    1、类变量初始化

    类变量简单来说就是被static修饰的变量,类变量属于类本身

    1.1 初始化时机

    • 定义类变量时指定初始化
    • 静态代码块中对类变量指定初始化

    1.2 初始化顺序

    上述两种方式在程序中的排列顺序即为执行顺序

    class ClassVarInit{
    	static int value=10;
    	static{
    		value=100;
    		name="静态代码块中对类变量指定初始化";
    	}
    	static String name="定义类变量时指定初始化";
    	public static void main(String[] args){
    		System.out.println(value);//输出:100
    		System.out.println(name);//输出:"定义类变量时指定初始化"
    	}
    }
    

    利用javap工具可以明显的看到类变量的赋值顺序

    javap -c ClassVarInit.class
    
    Compiled from "ClassVarInit.java"
    public class demo.ClassVarInit {
      static int value;
    
      static java.lang.String name;
    
      public demo.ClassVarInit();
        Code:
           0: aload_0
           1: invokespecial #1                  // Method java/lang
    /Object."<init>":()V
           4: return
    
      public static void main(java.lang.String[]);
        Code:
           0: getstatic     #2                  // Field java/lang/
    System.out:Ljava/io/PrintStream;
           3: getstatic     #3                  // Field value:I
           6: invokevirtual #4                  // Method java/io/P
    rintStream.println:(I)V
           9: getstatic     #2                  // Field java/lang/
    System.out:Ljava/io/PrintStream;
          12: getstatic     #5                  // Field name:Ljava
    /lang/String;
          15: invokevirtual #6                  // Method java/io/P
    rintStream.println:(Ljava/lang/String;)V
          18: return
    
      static {};
        Code:
           0: bipush        10
           2: putstatic     #3                  // Field value:I
           5: bipush        100               
           7: putstatic     #3                  // Field value:I
          10: ldc           #7                  // String 静态代码
    块中对类变量指定初始化
          12: putstatic     #5                  // Field name:Ljava
    /lang/String;
          15: ldc           #8                  // String 定义类变
    量时指定初始化
          17: putstatic     #5                  // Field name:Ljava
    /lang/String;
          20: return
    }
    

    2、实例变量初始化

    实例变量属于实例对象

    2.1 初始化时机

    • 定义实例变量时指定初始化
    • 非静态代码块中对实例变量指定初始化
    • 构造器中对实例变量指定初始化

    2.2 初始化顺序

    前两种方式在程序中的排列顺序即为执行顺序,且都优先于构造器初始化

    class InstanceVarInit{
    	public InstanceVarInit(int value,String name){
    		this.value=value;	
    		this.name=name;
    	}
    	int value=10;
    	{
    		value=100;
    		name="非静态代码块中对实例变量指定初始化";
    	}
    	String name="定义实例变量时指定初始化";
    	public static void main(String[] args){
    		InstanceVarInit obj=new InstanceVarInit(1000,"构造器中对实例变量指定初始化");	
    		System.out.println(obj.value);//输出:1000
    		System.out.println(obj.name);//输出:"构造器中对实例变量指定初始化"
    	}
    }
    
    javap -c InstanceVarInit.class
    
    Compiled from "InstanceVarInit.java"
    public class demo1.InstanceVarInit {
      int value;
    
      java.lang.String name;
    
      public demo1.InstanceVarInit(int, java.lang.String);
        Code:
           0: aload_0
           1: invokespecial #1                  // Method java/lang
    /Object."<init>":()V
           4: aload_0
           5: bipush        10
           7: putfield      #2                  // Field value:I
          10: aload_0
          11: bipush        100
          13: putfield      #2                  // Field value:I
          16: aload_0
          17: ldc           #3                  // String 非静态代
    码块中对实例变量指定初始化
          19: putfield      #4                  // Field name:Ljava
    /lang/String;
          22: aload_0
          23: ldc           #5                  // String 定义实例
    变量时指定初始化
          25: putfield      #4                  // Field name:Ljava
    /lang/String;
          28: aload_0
          29: iload_1
          30: putfield      #2                  // Field value:I
          33: aload_0
          34: aload_2
          35: putfield      #4                  // Field name:Ljava
    /lang/String;
          38: return
    
      public static void main(java.lang.String[]);
        Code:
           0: new           #6                  // class demo1/Inst
    anceVarInit
           3: dup
           4: sipush        1000
           7: ldc           #7                  // String 构造器中
    对实例变量指定初始化
           9: invokespecial #8                  // Method "<init>":
    (ILjava/lang/String;)V
          12: astore_1
          13: getstatic     #9                  // Field java/lang/
    System.out:Ljava/io/PrintStream;
          16: aload_1
          17: getfield      #2                  // Field value:I
          20: invokevirtual #10                 // Method java/io/P
    rintStream.println:(I)V
          23: getstatic     #9                  // Field java/lang/
    System.out:Ljava/io/PrintStream;
          26: aload_1
          27: getfield      #4                  // Field name:Ljava
    /lang/String;
          30: invokevirtual #11                 // Method java/io/P
    rintStream.println:(Ljava/lang/String;)V
          33: return
    }
    
    展开全文
  • 全局变量和局部变量初始化问题

    千次阅读 2019-08-23 16:08:42
    这里需要分清一个事实,是变量系统都会默认给初始化,只不过全局变量默认初始化为0,而局部变量被初始化为随机数,这个随机数用不了,后面会验证。现在,我们要讨论的是程序猿或者程序媛需不需要给全局变量和局部...

    总结 

    这里需要分清一个事实,是变量系统都会默认给初始化,只不过全局变量默认初始化为0,而局部变量被初始化为随机数,这个随机数用不了,后面会验证。 现在,我们要讨论的是程序猿或者程序媛需不需要给全局变量和局部变量赋初值的问题。因为全局变量的初始值是系统默认的且是可使用的,因此,全局变量一般不需要自己去赋初值,不过为了养成良好的代码习惯,最好还是赋初值,定义的全局变量在代码中未被使用,编译器也不会报错。局部变量被定义,没有赋初值,系统会抛出警告“xxx未使用的局部变量”,同时未赋初值的局部变量,是不能在其它地方作为右值使用的,系统会抛出错误“使用了未初始化的局部变量”。因此,局部变量如果被定义,就必须要赋初值,下面通过一段代码来验证。

    #include <iostream>
    #include <string>
    #include <vector>
    
    int a;
    bool b;
    char c;
    double d;
    
    std::string str;
    std::vector<int> vec;
    
    int main()
    {
    	int a2;
    	bool b2;
    	char c2;
    	double d2;
    	std::string str2;
    	std::vector<int> vec2;
    
    	//Microsoft C++ 异常: std::out_of_range
    	//vec.at(0) = 1;
    	//vec2.push_back(1);
    	/*
    	std::cout << "a:"<<a << std::endl;
    	std::cout << "b:"<<b << std::endl;
    	std::cout << "c:"<<c << std::endl;
    	std::cout << "d:"<<d << std::endl;
    	std::cout << "a2:"<< a2 << std::endl;
    	std::cout << "b2:"<< b2 << std::endl;
    	std::cout << "c2:"<< c2 << std::endl;
    	std::cout << "d2:"<< d2 << std::endl;
    	*/
    	system("pause");
    	return 0;
    }

    全局变量 

    我把所有的全局变量都添加到监视中,调试后可以发现,普通数据类型变量的值系统会默认初始化为0。int类型初始化为0,bool类型初始化为false,char类型初始化为‘\0’,double类型初始化为0.00000000000000000。

    局部变量

    在局部变量窗口中可以看到,局部变量的初始化值都是随机的。普通数据类型中,int类型初始化为-858993460,bool类型初始化为true (204),char类型初始化为-52 '?',double类型初始化为-9.2559631349317831e+61。

    编译时,会给出警告信息:

    通过两个窗口数据可以看到,string类型和vector类型的变量初始化是一样的,string的size为0,capacity为15;vector的size为0,capacity也为0。

    把主函数里面这段代码的注释取消,发现int、bool、double的打印值都为0,char的打印值为空,也就是‘\0’。

    std::cout << "a:"<<a << std::endl;
    std::cout << "b:"<<b << std::endl;
    std::cout << "c:"<<c << std::endl;
    std::cout << "d:"<<d << std::endl;

     

    把主函数里面这段代码注释取消,直接Game over,系统报错。

    std::cout << "a2:" << a2 << std::endl;
    std::cout << "b2:" << b2 << std::endl;
    std::cout << "c2:" << c2 << std::endl;
    std::cout << "d2:" << d2 << std::endl;

    这里多说两句关于vector容器初始化的:

    size是当前vector容器真实占用的大小,也就是容器当前拥有多少个容器。

    capacity是指在发生realloc前能允许的最大元素数,即预分配的内存空间。

    这两个属性分别对应两个方法:resize()和reserve()。

    使用resize(),容器内的对象内存空间是真正存在的。

    使用reserve()仅仅只是修改了capacity的值,容器内的对象并没有真实的内存空间(空间是"野"的)。

    1、如果对容器直接赋值,会报out_of_range,也就是越界。

    vec.at(0) = 1;

    2、如果没有对容器赋初值,打印其中一个,也会报out_of_range,因为vector的size为0,capacity也为0。

    std::cout << "vec:" << vec.at(0) << std::endl;

    如果要打印第一个值,需要先resize一下,不能用reserve,此时的值为0,但还是不能赋值

    vec.resize(1);
    //vec.reserve(1);
    std::cout << "vec:" << vec.at(0) << std::endl;

    3、如果要赋值,需要先往vector里面push_back值,这个不需要resize都可以

    vec.push_back(1);
    std::cout << "vec:" << vec.at(0) << std::endl;
    vec.at(0) = 2;
    std::cout << "vec:" << vec.at(0) << std::endl;

     

    展开全文
  • Java全局变量和局部变量初始化问题

    千次阅读 2020-02-21 23:24:53
    我们先来看一个比较的例子,最近在知乎看到的帖子。... //类的成员变量 public static void main(String[] args) { TestDemo td =new TestDemo(); //默认的构造方法 System.out.println(td.a); ...

    变量的初始化问题

    我们先来看一个例子,最近在知乎看到的帖子。

     
      public class TestDemo {
        int a;  //类的成员变量
        public static void main(String[] args) {
            TestDemo td =new TestDemo(); //默认的构造方法
            System.out.println(td.a);
        }
    }
    
        // 第二种类型 
      public  class TestDemo {
        public static void main(String[] args) {
           int a;
           System.out.println(a);
        }
    }
    
    

      我先验证了一下结果给大家说,上面部分代码运行结果为 0 . 下面部分代码编译执行报错(变量可能未初始化)。

    成员变量和局部变量的区别

      上面两部分代码的区别是上面代码,变量 a 是作为类的成员变量,主方法中创建了对象,我们发现此时的 a 结果是 0,如果我们换成字符串就是 null ,boolean型变量默认就是 false ,所以我们发现当变量作为类的成员变量的时候类在创建对象的时候会默认给它们赋初值。

      而下面部分代码则是方法中的变量,也就是局部变量。我们直接打印它或者用到它的时候直接会报错。

      如何解释这一现象?局部变量必须赋初始值?下面我们多方面分析一下。

      首先,Java语言是这么明文规定的。局部变量使用前必须赋值。为什么Java 语言要这么规定呢。我们知道Java 是一门面向对象的语言,它将重点放在 数据 和对象的接口上。就好比一个木匠,一个“面向对象”的木匠始终关注的是所制作的椅子,第二位才是所使用的工具和打造的过程;而一个“非面向对象的”木匠首先考虑的是所用的工具。

      最上面部分代码,将 a 变量作为类的成员变量,当我们创建对象的时候,Java 虚拟机会在系统的堆 (heap)区域申请一块内存区域来存放类的数据,在这里成员变量就是类的数据,这个时候JVM为加载的类要分配内存啦!成员变量作为类的数据是会随着类的加载在堆中分配内存,注意了,JVM 在申请内存时自动给它们赋了初值。这里附上下面一个堆栈简单示意图,
    在这里插入图片描述

      至于默认给类的成员变量赋初值有什么机理吗?我们可以想到类都有一个默认的构造方法的。(因为我们没有给出显式的构造方法)我们创建对象的时候实际上是调用了默认的构造方法的,会给成员变量赋一个默认的初始值,这样在打印输出的时候才会有值输出而不报错。这时我们看一下第二段代码,并没有涉及到任何实例化对象的操作,在主函数里面 a 是没有任何东西对其初始化的,所以直接对其输出会直接报错。

      现在我们想一想如果Java 设计的时候也给方法里的局部变量赋初始值会怎样? 一个方法里面可能会有很多个局部变量,类里面也会有很多个方法,而且生命周期短。如果我们都给它们赋初值,一定是一笔很大的开销,而且安全性也达不到要求,所以换成我是虚拟机也不想干这等活儿…但程序员们最好有给局部变量初始化的习惯。我们不妨看下下面这个例子。

        public static void main(String[] args) {
            for (int i = 0; i < 100; i++) {
                int a;
                if (i % 2 == 0) {
                    a = 1;
                } else {
                    a = 2;
                }
            }
        }
    

    如果我们每次都对 a 进行初始化,那真的是丝毫没有必要的。

      我们还可以换个角度来想这个问题,假如你是开发 Java 这门伟大语言的开发者,你在设计的时候,类的成员变量是要在堆中分配内存的,方法中的局部变量是在栈中的。其实,不管是局部变量还是成员变量,都是必须要初始化的,那为什么成员变量会自动初始化?其实正是因为成员变量属于对象,而对象是保存在堆中的,随着类的加载在为对象开辟空间的时候自动为成员变量赋初值,如果我们还要给局部变量都赋初值,那性能影响太大了吧,开发者想到这里的时候可能就直接将给局部变量初始化的想法抹杀掉了吧。同时在一般情况下成员变量也不会有初始值,你可以联想一下,有一个class 比如说是人类,里面的身高体重如果定义时候给了初始值,是不是觉得一点都不抽象了,所以成员变量不初始化可能更符合需求,创建类的对象的时候它们也会有初始值。(ps: static 修饰的成员变量不用创建对象也可以哦)

      最后套用《Thinking in Java》作者的话:

    编译器当然可以为局部变量附一个默认值,但是未初始化的局部变量更有可能是程序员的疏忽,所以采用默认值范围会掩盖这种失误。因此强制程序员提供一个初始值,往往能够帮助找出程序里的缺陷。

    果然是大佬,说出来的话就是让人无可反驳。

    展开全文
  • Java变量初始化的四种方式

    千次阅读 2019-11-03 22:53:35
    //Java 尽量保证所有变量在使用前都能得到恰当的初始化,否则会报异常 //Java中提供了四种初始化方法:默认初始化、显式赋值初始化、调用...## 成员变量初始化方式之一————默认初始化: public class InitialV...
  • c语言static变量初始化

    千次阅读 2020-10-30 11:39:55
    《程序员面试笔试宝典》第123页,举了个例子 #include <stdio.h> void fun(int i) { static int value=i++; printf("%d\n",value);...是变量value由于static的修饰,只会定义一次value变量,并且
  • Verilog 变量初始化

    千次阅读 2021-04-22 16:47:06
    reg型变量需要初始化 方法: always来时钟,用复位信号rst控制(通常用方法1) 定义时直接赋值,通常为0(没有复位信号时用方法2) 示例:用计数器生成复位信号,将寄存器变量初始化为零: //复位:1;工作:0 ...
  • Java实例变量初始化

    千次阅读 2018-04-11 10:04:08
    任意实例变量初始化方法的字节码————>对应定义变量时的赋值代码  实现了对应构造方法的方法体的字节码——>构造函数里面的代码 注:Java保证了一个对象被初始化前其父类也必须被初始化。有下面机制来保证:Java...
  • 全局变量,static变量初始化时间

    万次阅读 2019-04-24 22:04:41
    首先,静态局部变量和全局变量一样,数据都存放在全局区域,所以在主程序之前,编译器已经为其分配好了内存,但在C和C++中静态局部变量初始化节点又有点不太一样。在C中,初始化发生在代码执行之前,编译阶段分配...
  • C++变量初始化问题

    千次阅读 2019-03-25 14:39:57
    在C++中,变量初始化和赋值操作符是两个完全不同的概念。 初始化不是赋值,初始化的含义是创建变量分配存储空间时为其赋一个初始值,而赋值的含义是把内存空间的当前值擦除,用一个新值代替。 C++中列表初始化 ...
  • java类中变量初始化

    千次阅读 2018-08-10 15:03:14
    一般的初始化 public class BedAndBreakfast { // initialize to 10 public static int capacity = 10; // initialize to false ...当变量值有效且可以写成一行时,便可以在变量初始化的时候同时赋上处值...
  • Simulink中MATLAB Function的变量初始化

    千次阅读 2020-12-23 15:19:04
    MATLAB Function内部的M语言有严格的要求: 变量必须要给定初始值及其维度,变量类型及其虚实性,不支持变维度变量 simulink中的运行机制,每个采样点会调用一次MATLAB Function的函数,两次调用之间,同一个变量的...
  • C语言变量初始化是必须的吗?不初始化会怎样?

    千次阅读 多人点赞 2020-10-15 13:58:15
    所谓初始化就是“第一次赋值”的意思。我们先来看一个程序:   #include <stdio.h>int main(void){int i;printf("i = %d\n", i);return 0;} 这里i没有被赋值,只是定义了一个存储空间。这时输出这个...
  • (1)C语言从语法上规定全局变量只能用常量表达式来初始化,因此下面这种全局变量初始化是不合法的: int minute = 360; int hour = minute / 60; (2)如果全局变量在定义时不初始化则初始值是0,如果局部...
  • 变量初始化变量的三种方式

    千次阅读 2019-06-04 16:42:33
    tf.Variable() :一般变量用这种方式定义。 * 可以选择 trainable 类型 * tf.get_variable() :一般都是和 tf.variable_scope() 配合使用,从而实现变量共享的功能。 * 可以选择 trainable 类型 * 【注意:】tf.get_...
  • c++类的成员变量初始化总结

    千次阅读 2019-06-14 17:04:11
    1.c++变量初始化方式 首先把需要初始化的成员变量分为几类: a.一般变量(int) b.静态成员变量(static int) c.常量(const int) d.静态常量(static const int) 对应的初始化方式是: a.一般变量可以...
  • C++用变量初始化数组

    千次阅读 2019-10-10 16:54:23
    void aaa( int i) { int *a = new int[i]; delete []a; int a= (int)malloc(sizeof(int)*i); free(a); }
  • c++成员变量初始化方法:声明时初始化、初始化列表、构造函数初始化 有人说在声明的时候初始化相当于在构造函数中初始化,其实不是的,成员变量初始化的顺序为:先进行声明时初始化,然后进行初始化列表初始化,最后...
  • Java中全局变量初始化顺序

    千次阅读 2019-02-27 19:20:58
    首先,在加载类或者创建类的第一个对象的时候,初始化静态变量。但是无论创建多少个对象,静态变量初始化一次。 然后,初始化非静态变量。如果非静态变量在声明的位置没有初始化,则编译器为基本类型数据赋值0,...
  • c++成员变量初始化

    千次阅读 2019-04-04 11:09:40
    static变量在类内声明,在类外定义和初始化,类外定义和初始化时不用加static关键字 using namespace std ; class A { public : static int a ; } ; int A :: a = 1 ; int main ( )...
  • Java静态变量和成员变量初始化顺序

    千次阅读 2018-08-01 19:22:49
    首先放一段代码,帮助我们分析变量初始化过程,大家可以先想一下他的输出,然后在看下面的运行结果: public class InitTest{ public static int k = 0; public static InitTest t1 = new InitTest("t1"...
  • Java 局部变量初始化问题

    千次阅读 2018-06-08 09:05:49
    Java 中类的成员变量会被自动初始化,但是方法里头的局部变量不会被自动初始化   上图中 i 是成员变量,默认会自动初始化,所以直接使用没有报错。但是 j 是方法中的局部变量,没有初始化直接使用会出现编译...
  • c++类static成员变量初始化

    万次阅读 2019-05-10 23:12:38
    今天看到一个写法,竟然不知道这种写法。。。我是不是脑子完犊子了。。。 在test.h文件中: class A { public: ... //静态数据成员的定义和初始化 ...类中的静态成员变量初始化必须在类外实现!! ...
  • JAVA之成员变量初始化

    千次阅读 2019-07-07 13:53:28
    java中成员变量初始化,如果是普通成员变量可以赋初值,如果没赋初值,则系统会自动赋初值。而对于局部变量必须手动赋初值。 package MyText2; public class MyText1 { int str1; public static void ...
  • 【Java笔试真题】:构造方法、成员变量初始化以及静态成员变量初始化三者的先后顺序是什么样的? 【解答】: 当类第一次被加载的时候,静态变量会首先初始化,接着编译器会把实例变量初始化为默认值,然后执行构造方法...
  • 1.全局变量 全局变量无疑要在main函数开始前执行完成,但可细分为在编译时和在运行时初始化,即static initialization和dynamic initialization。 static initialization 静态初始化按照我的理解,是针对那些较为...
  • java,final变量初始化方式

    千次阅读 2018-08-01 19:59:08
    //声明时直接初始化 private final int j;//构造函数赋值(在构造代码块之后执行) private final static int k;//静态代码块中赋值(先于构造代码块执行) private final int m;//构造代码块中赋值...
  • 类的静态成员变量初始化时间

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

    千次阅读 多人点赞 2016-07-19 20:17:35
    今天在看剑指offer这本书时,看待一个简单的举例,说应聘C++岗位的不知道成员变量初始化顺序!我很惊讶,因为我也不知道,所以就看上网查了一下,看到了一个博客()以及其中的内容,现在将我的学习过程分享出来! ...
  • javac 中的if-else变量初始化问题

    万次阅读 2018-09-27 17:22:56
    在前几篇文章中我们介绍过了AbstractAssignAnalyzer.visitIf(JCIf),该方法是用来判断在if语句中变量初始化情况的.例如如下代码: public void assgin(){ int c; int a = 0; if(c != 0){ } } 在IDE ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,657,205
精华内容 662,882
关键字:

变量初始化