精华内容
下载资源
问答
  • 成员变量初始化
    千次阅读
    2022-04-15 10:08:24

    1.类初始化顺序

    当类初始化的时候,会调用其构造函数并进行初始化。当对象结束其生命周期,会调用析构函数进行资源回收。

    注意类在调用资深构造函数之前,首先会调用其成员变量构造函数并进行初始化,再进入自身构造函数进行初始化。成员变量的声明顺序,就是初始化顺序。后面我们提到的很多情况就跟这个有关系,后面再进行详细解读。

    2.声明时初始化

    第一种方式是在成员变量声明时初始化。可以看如下示例。

    class D {
        int a = 10;
    };
    

    在声明变量a的时候即给其初始化为10。不过注意这种写法是c++11以后才有的。上述代码在IDE中会有如下警告信息:

    in-class initialization of non-static data member is a C++11 extension [-Wc++11-extensions]
    

    3.构造函数初始化列表

    第二种方式是在构造函数中加入一个初始化列表,对成员变量进行初始化。

    class D {
        int a, b;
        string c;
        public:
            D() : a(1), b(2), c("sss") {
                cout<<"a is: "<<a<<endl;
                cout<<"b is: "<<b<<endl;
                cout<<"c is: "<<c<<endl;
            }
    };
    

    如果我们对D进行实例化,

    int main(int argc, char const *argv[])
    {
        D d;
        return 0;
    }
    

    代码会有如下输出

    a is: 1
    b is: 2
    c is: sss
    

    4.构造函数内部赋值

    在其他语言中,比如java,最常用的方式为在构造函数内部赋值。

    class D {
        int a, b;
        string c;
        public:
            D(int a, int b, string c) {
                this->a = a;
                this->b = b;
                this->c = c;
                cout<<"a is: "<<a<<endl;
                cout<<"b is: "<<b<<endl;
                cout<<"c is: "<<c<<endl;
            }
    };
    
    int main(int argc, char const *argv[])
    {
        D d(1, 2, "sss");
        return 0;
    }
    

    上面代码输出为

    a is: 1
    b is: 2
    c is: sss
    

    5.只能构造函数初始化列表的情况

    如果一个类成员,他本身是一个类或者结构,而且这个类成员没有默认的无参构造函数,只有带参数的构造函数,这个时候对类成员初始化时,必须调用类成员带参数的构造函数。如果再初始化列表中没有完成类成员初始化,代码会报错。

    };
    
    class F {
        E e;
        public:
            F() {cout<<"init F class!"<<endl;}
    };
    
    int main(int argc, char const *argv[])
    {
        F f;
        return 0;
    }
    

    上述代码是可以正常运行的,因为类E有默认无参构造函数。

    而如果将代码改为下面的样子,给E加一个带参数的构造函数

    class E {
        int num;
        public:
            E(int n) {
                this->num = n;
            }
    };
    
    class F {
        E e;
        public:
            F() {cout<<"init F class!"<<endl;}
    };
    
    int main(int argc, char const *argv[])
    {
        F f;
        return 0;
    }
    

    上面代码在IDE里直接会报错:

    constructor for 'F' must explicitly initialize the member 'e' which does not have a default constructor
    

    此时需要将F的构造函数改成如下形式:

    class F {
        E e;
        public:
            F() : e(10) {cout<<"init F class!"<<endl;}
    };
    

    另外,如果类的成员变量中有const时候,也需要在成员初始化列表中赋值完成初始化。

    class F {
        private:
            const int num;
        public:
            F(): num(10) {}
    };
    

    比如上面类F中有一个const常量num,就需要再F构造函数列表中对其进行赋值,否则代码会报错。

    6.列表初始化与构造函数初始化区别

    当采用列表初始化的时候,代码直接调用了成员变量的构造函数,只需要一步就可以完成。
    而在构造函数中初始化的时候,先调用的是成员变量的默认构造函数构造了类成员,然后再调用赋值运算符对之前默认构造的类成员进行赋值,这实际上进行了两步操作。
    当类的结构较为复杂的时候,会存在性能上的差异。

    更多相关内容
  • 考虑一下效率的可以再构造函数的初始化列表中进行。  class CA  {  public:  int data;  ……  public:  CA();  ……  };  CA::CA():data(0)//……#1……初始化列表方式  {  //data = 0;//...
  • C++静态成员变量初始化

    千次阅读 2021-06-17 10:35:00
    静态成员变量初始化 静态成员变量可以初始化,但只能在类体外进行初始化。如: long long student::number = 13926572996; //在类体外对静态成员变量赋值 其一般形式为: 数据类型 类名::静态成员变量名 = ...

    静态成员变量初始化

           静态成员变量可以初始化,但只能在类体外进行初始化。如:

    long long student::number = 13926572996;    //在类体外对静态成员变量赋值

    其一般形式为:

    数据类型 类名::静态成员变量名 = 初值;

    不必在初始化赋值语句中加 static。

           注意:不可以在构造函数的参数初始化表中对静态成员变量初始化,例如:

        student(char* pn, char* pa, int n):number(n)

        {

            strcpy(name, pn);

            strcpy(addr, pa);

        }

           在构造函数中,对static类型的number成员进行初始化,是错误的操作。

    如果未对静态成员变量赋值,则编译系统会自动赋初值为0。

    如果一个成员变量定义为const类型,同时,也是static类型,那么,应该怎么样初始化?有如下的分析:

    (1) static类型的成员变量,需要在类外进行初始化;

    (2) const类型的成员变量,需要在构造函数的初始化列表进行初始化;

           那么,const类型的static成员变量,不可以在构造函数的初始化列表中进行初始化,例如:

           程序编译错误,如下:

           提示 student::number成员变量是static类型,仅仅在定义的时候可以初始化。所以,不可以在构造函数列表中初始化。所以,在类外对static类型的成员变量进行初始化,程序测试代码如下:

           程序运行结果如下:

           所以,可以在类外对const类型的静态成员变量进行初始化。

           注意:对于const 类型的static成员变量,可以在定义它的时候进行初始化,如下:

           在student类内对number成员进行初始化。这是合法的语句。

    韦凯峰 Linux C/C++ 程序设计教程,Linux 系统编程,Openwrt 系统开发,微信:13926572996,QQ:1523520001,博客:www.mylinux.vip

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

    千次阅读 2021-07-12 21:37:24
    一、成员变量初始化步骤(三步) 二、程序代码 三、执行过程 1、主函数先进栈空间 2、开一个对象空间给对象空间开辟一个地址(地址是随机的)对成员变量初始化(num) 3、构造函数进入空间 4、针对性初始化...

    目录

    一、成员变量初始化步骤(三步)

    二、程序代码

    三、执行过程

            1、主函数先进栈空间

            2、开一个对象空间给对象空间开辟一个地址(地址是随机的)对成员变量初始化(num) 

            3、构造函数进入空间

             4、针对性初始化过程

             5、主函数的执行过程


    一、成员变量初始化步骤(三步)

    默认初始化 -> 显示初始化(调用super时)->针对性(看构造函数)


    二、程序代码

    Demo类

    public class Demo {
    	public int num = 10;
    	public Demo(){
    	this.num=20;
    	}
    
    }

    主函数

    public class Main {
    	public static void main(String[] args) {
    		Demo d = new Demo();
    		System.out.print(d.num);
    	}
    }

    三、执行过程

            1、主函数先进栈空间

            2、开一个对象空间给对象空间开辟一个地址(地址是随机的)对成员变量初始化(num) 

     注意:成员变量默认初始化为0值整数为0,浮点数为0.0,引用数据类型null

            3、构造函数进入空间

    注意:构造函数进来首先调用super()默认的父类是(Object)所以super走成员变量就是显示初始化,所以显示初始化在本程序中就是10

             4、针对性初始化过程

    注意:this是指向当前对象的应用,当构造函数刚刚进栈时就指定了this,通过this来区分我们调用的是哪一个构造函数(在构造函数还未进入栈时是存放在方法区的),代码中的this.num就是this指向的地址去查找地址中的num并赋值,这就是针对性初始化。记住构造函数结束后会有一个默认的return,构造函数弹出栈。

             5、主函数的执行过程

    解释:构造函数弹出栈new Demo()过程执行完,主函数的局部变量的d拿到该地址,并通过该地址去执行相关的操作(如d.num就是去该地址查找到num的值为20)。

     

     

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

    千次阅读 2021-03-09 17:45:28
    成员变量:定义在类里面,为类所有;可以被public、private、protect、static修饰;存储在堆中;没有被static修饰必须先new对象才能使用;当前类的所有方法都可以调用;如果该类有子类,则子类也可以调用;可以不...

    成员变量:  定义在类里面,为类所有;可以被public、private、protect、static修饰;存储在堆中;没有被static修饰必须先new对象才能使用;当前类的所有方法都可以调用;如果该类有子类,则子类也可以调用;可以不赋值,如果没有赋值基本数据类型返回对应的值,非基本数据类型返回null。

    定义:

    public class Test{

    public int num;

    }

    初始化方式:

    1、如果只是单纯的定义一个成员变量而没有赋值,则编译器会自动添加相应的默认值。如:

    public class Test{

    //基本数据类型

    private boolean flag; //默认值:false

    private int _int; //默认值:0

    private byte _byte; //默认值:0

    private char _char; //默认值:'\u0000',但是Eclipse中打印的时候会是空白符"方框",因为空白符的code是0x20,0x20以下为不可见的控制字符。

    private short _short; //默认值:0

    private float _float; //默认值:0.0

    private long _long; //默认值:0

    private double _double; //默认值:0.0

    //引用类型默认为null

    private String string;

    }

    2、直接赋值

    public class Test {

    private int num = 1;

    private String name = "xiaomin";

    public Person person = new Person();

    }

    3、通过方法初始化

    public class Test{

    private int i = f();

    private int j = g(i);

    private int f() {

    return 10;

    }

    private int g(int i){

    return i*2

    }

    }

    但是,编译器在初始化对象的时候是按顺序执行的,所以不能像下面那样的方法来初始化:

    public class Test{

    private int j = g(i);

    private int i = f();

    private int f() {

    return 10;

    }

    private int g(int i){

    return i*2

    }

    }

    4、通过构造函数初始化

    public class Test{

    int num ;

    public Test(){

    num = 10;

    }

    }

    在进入构造器之前,编译器会先给num默认初始化为0,进入构造器之后再赋值为10。

    初始化顺序:

    一个类在编译的时候是成员变量优先初始化,而成员变量的初始化顺序是由成员变量在该类里面定义的顺序决定的。

    package com.extendstest;

    public class OrderOfInitialization {

    public static void main(String[] args) {

    Card card = new Card();

    card.f();

    }

    }

    class Tag {

    Tag(int num) {

    System.out.println("Tag" + num);

    }

    }

    class Card {

    Tag tag1 = new Tag(1); //定义tag1变量

    Card() {

    System.out.println("Card()");

    tag3 = new Tag(33); //tag3重新初始化了

    }

    Tag tag2 = new Tag(2); //定义tag2变量

    void f() {

    System.out.println("f()");

    }

    Tag tag3 = new Tag(3); //定义tag3变量

    }

    在main方法里面创建了一个card对象的,编译器在编译Card类时,成员变量tag1、tag2、tag3的初始化工作是在构造器Card()之前,因此,上述代码输出结果为:

    Tag1

    Tag2

    Tag3

    Card()

    Tag33

    f()

    static变量的初始化顺序:static成员变量优先于非static成员变量。

    public class StaticInitialization {

    public static void main(String[] args) {

    System.out.println("Creating new Cupboard() in main");

    new Cupboard();

    System.out.println("Creating new Cupboard() in main");

    new Cupboard();

    t2.f2(1);

    t3.f3(1);

    }

    static Table t2 = new Table();

    static Cupboard t3 = new Cupboard();

    }

    class Bowl{

    Bowl(int i){

    System.out.println("Bowl"+i);

    }

    void f(int i){

    System.out.println("f"+i);

    }

    }

    class Table{

    static Bowl b1 = new Bowl(1);

    Table(){

    System.out.println("Table()");

    b2.f(1);

    }

    void f2(int i){

    System.out.println("f2("+i+")");

    }

    static Bowl b2 = new Bowl(2);

    }

    class Cupboard{

    Bowl b3 = new Bowl(3);

    static Bowl b4 = new Bowl(4);

    Cupboard(){

    System.out.println("Cupboard()");

    b4.f(2);

    }

    void f3(int i){

    System.out.println("f3("+i+")");

    }

    static Bowl b5 = new Bowl(5);

    }

    因为static仅在Class对象首次创建的时候初始化仅发生一次,所以,上面代码执行结果为:

    Bowl1

    Bowl2

    Table()

    f1

    Bowl4

    Bowl5

    Bowl3

    Cupboard()

    f2

    Creating new Cupboard() in main

    Bowl3

    Cupboard()

    f2

    Creating new Cupboard() in main

    Bowl3

    Cupboard()

    f2

    f2(1)

    f3(1)

    还有以下静态块里初始化方式也是:

    class Cup{

    Cup(int i){

    System.out.println("Cup("+i+")");

    }

    void f(int i){

    System.out.println("f("+i+")");

    }

    }

    class Cups{

    static Cup c1;

    static Cup c2;

    static { //静态块初始化

    c1 = new Cup(1);

    c2 = new Cup(2);

    }

    Cups(){

    System.out.println("Cups()");

    }

    }

    public class StaticInitialization {

    public static void main(String[] args) {

    System.out.println("Inside main()");

    Cups.c1.f(99);

    }

    static Cups x = new Cups();

    static Cups y = new Cups();

    }

    执行结果:

    Cup(1)

    Cup(2)

    Cups()

    Cups()

    Inside main()

    f(99)

    另外一种,非静态实例初始化,没有static关键字,:

    package com.extendstest;

    class Mug{

    Mug(int i){

    System.out.println("Mug("+i+")");

    }

    void f(int i ){

    System.out.println("f("+i+")");

    }

    }

    public class Mugs {

    Mug c1;

    Mug c2;

    { //非静态初始化,创建对象时会多次调用

    c1 = new Mug(1);

    c2 = new Mug(2);

    System.out.println("c1&&c2inin....");

    }

    Mugs(){

    System.out.println("Mugs()");

    }

    public static void main(String[] args) {

    System.out.println("inin..main");

    Mugs x = new Mugs();

    Mugs y = new Mugs();

    }

    }

    执行结果:

    inin..main

    Mug(1)

    Mug(2)

    c1&&c2inin....

    Mugs()

    Mug(1)

    Mug(2)

    c1&&c2inin....

    Mugs()

    展开全文
  • C++ 类成员变量初始化顺序

    千次阅读 2020-01-16 23:02:50
    首先,看一段程序: #include using namespace std;...下面是C++类成员变量初始化顺序: 1) 基类的静态变量或全局变量 2) 派生类的静态变量或全局变量 3) 基类的成员变量 4) 派生类的成员变量
  • 成员变量初始化总结

    千次阅读 2019-10-11 09:34:11
    类中的成员变量类型可分为: 普通成员 常量成员 (const) 引用成员 (&) 静态成员 (static) 静态常量成员 (static const / const static) 成员的初始化有3中方式: 类内初始化 初始化成员列表 类外初始化 普通...
  • 成员变量初始化方法一、成员变量初始化方法二、成员变量初始化顺序三、成员变量声明时初始化好处 一、成员变量初始化方法 c++11标准中允许类成员变量在声明时初始化, 成员变量初始化有三种方法:声明时初始化、...
  • c++成员变量初始化

    千次阅读 2019-04-04 11:09:40
    const static成员变量如果只声明不定义,并且声明时没有进行初始化,也就没法当一个立即数使用,自然也就无法输出A::a using namespace std ; class A { public : const static int a ; //...
  • c++类的成员变量初始化总结

    千次阅读 2019-06-14 17:04:11
    首先把需要初始化成员变量分为几类: a.一般变量(int) b.静态成员变量(static int) c.常量(const int) d.静态常量(static const int) 对应的初始化方式是: a.一般变量可以在初始化列表里或者构造...
  • const成员变量初始化详解

    千次阅读 2019-11-27 21:47:48
    const成员变量初始化 在构造函数的初始化列表里进行,不可以通过赋值来初始化 例如: class Time { public: int hour; int minute; int second; const int a;//const成员变量 }; //此时类里没有...
  • 类的静态成员变量初始化问题

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

    千次阅读 2020-05-02 14:28:37
    首先先搞明白 声明、定义、初始化 ...类静态成员变量在main函数执行前完成初始化,有静态初始化和动态初始化 static initialization: 静态初始化指的是用常量来对变量进行初始化,主要包括 zero initialization 和...
  • c++成员变量初始化方法:声明时初始化、初始化列表、构造函数初始化 有人说在声明的时候初始化相当于在构造函数中初始化,其实不是的,成员变量初始化的顺序为:先进行声明时初始化,然后进行初始化列表初始化,最后...
  • 【Java笔试真题】:构造方法、成员变量初始化以及静态成员变量初始化三者的先后顺序是什么样的? 【解答】: 当类第一次被加载的时候,静态变量会首先初始化,接着编译器会把实例变量初始化为默认值,然后执行构造方法...
  • c++类static成员变量初始化

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

    万次阅读 2015-04-08 11:52:23
    首先把需要初始化成员变量分为几类: Ø 一般变量(int) Ø 静态成员变量(static int) Ø 常量(const int ) Ø 静态常量(static const int)  对应的初始化方式是: Ÿ 一般变量可以在初始化列表里或者...
  • Java静态变量和成员变量初始化顺序

    千次阅读 2018-08-01 19:22:49
    首先放一段代码,帮助我们分析变量初始化过程,大家可以先想一下他的输出,然后在看下面的运行结果: public class InitTest{ public static int k = 0; public static InitTest t1 = new InitTest("t1"...
  • 用参数初始化表对成员变量初始化 通过前面的学习,我们可以在类中定义带参数的构造函数。同时,在定义类对象的时候,给构造函数传递参数。通过给构造函数传递参数,可以给类的成员变量进行初始化。 C++还提供另一...
  • C和C++中的结构体不同:以下测试均在vs2010,作者水平有限,有误请指出。 1.C++对struct关键字进行了增强:如下代码...//在c中这样定义变量编译通不过,必须要加上struct,而在c++中这样是允许的 return 0; } 2.C+...
  • C++类成员变量初始化顺序问题

    千次阅读 多人点赞 2016-07-19 20:17:35
    今天在看剑指offer这本书时,看待一个简单的举例,说应聘C++岗位的不知道成员变量初始化顺序!我很惊讶,因为我也不知道,所以就看上网查了一下,看到了一个博客()以及其中的内容,现在将我的学习过程分享出来! ...
  • 一、成员变量初始化列表 与其他函数不同,构造函数除了有名字,参数列表和函数体之外,还可以有初始化列表,初始化列表以冒号开头,后跟一系列以逗号分隔的初始化字段。 class foo { public: foo(string s, int i)...
  • C++成员变量初始化顺序

    千次阅读 2017-01-15 14:47:05
    1、成员变量在使用初始化列表初始化时,与构造函数中初始化成员列表的顺序无关,只与定义成员变量的顺序有关。因为成员变量初始化次序是根据变量在内存中次序有关,而内存中的排列顺序早在编译期就根据变量的定义...
  • Java中成员变量初始化过程

    千次阅读 2021-03-09 17:45:24
    Java中的成员变量分为两种:第一种是成员变量,第二种是...1.没有被修饰符修饰的成员变量和局部变量的初始化在java中所有的成员变量都会被系统赋予默认是初始值,这个初始值根据不同的数据类型有着不同的定义:Bool...
  • C++类const成员变量初始化

    万次阅读 2016-11-08 16:37:23
    class CExample { public: CExample():m_a(1),m_b(2){/*m_a = 1; compile error*/} CExample(const CExample&c):m_a...3、构造函数列表初始化执行顺序与成员变量在类中声明相同,与初始化列表中语句书写先后无关。
  • Java成员变量初始化顺序

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

    千次阅读 2017-09-15 10:36:27
    Java 类加载顺序与成员变量初始化
  • Java中的成员变量、局部变量初始化的问题
  • 1、实践是检验真理的唯一标准,废话不多说,上代码。 #include <QCoreApplication> #include <...// 定义变量类 class Variable { public: Variable(const string& type) :_type(typ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 582,331
精华内容 232,932
关键字:

成员变量初始化

友情链接: txbh.zip