精华内容
下载资源
问答
  • 类的初始化列表
    千次阅读
    2019-04-15 10:08:27

    一、const类型的成员变量

       const对象或引用只能初始化但是不能赋值。构造函数的函数体内只能做赋值而不是初始化,因此初始化const对象或引用的唯一机会是构造函数函数体之前的初始化列表中。

      从无到有叫初始化,初始化(调用拷贝构造函数)创建了新对象;赋值(调用赋值操作符)没有创建新对象,而是对已有的对象赋值。

    二、引用类型的成员变量

    #include <iostream>
    using namespace std;
    
    class A
    {
        public:
            A(int &v) : i(v), p(v), j(v) {}
            void print_val() { cout << "hello:" << i << "  " << j << endl;}
        private:
            const int i;
            int p;
            int &j;
    };
    
    int main(int argc ,char **argv)
    {
        int pp = 45;
        A b(pp);
        b.print_val();
    }

    三、带有引用的类的成员变量

    class A {
    private:
           int &a;
    };
    class B{
    private:
      A c;       //这里的c需要在初始化列表中进行初始化
    }
    

    四、如果类中存在继承关系,派生类必须在初始化列表中调用基类的构造函数

    #include <iostream>
    using namespace std;
    
    class Base
    {
        public:
            Base(int a) : val(a) {}
        private:
            int val;
    };
    
    class A : public Base
    {
        public:
            A(int v) : p(v), Base(v) 
            {}
            void print_val() 
             { cout << "hello:" << p << endl;}
        private:
            int p;
    };
    
    int main(int argc ,char **argv)
    {
        int pp = 45;
        A b(pp);
        b.print_val();
    }

    五、类成员没有默认的构造函数的类类型

    #include <iostream>
    using namespace std;
    
    class Base
    {
        public:
            Base(int a) : val(a) {}
        private:
            int val;
    };
    
    class A
    {
        public:
            A(int v) : p(v), b(v) {}
            void print_val() 
             { cout << "hello:" << p << endl;}
        private:
            int p;
            Base b;
    };
    
    int main(int argc ,char **argv)
    {
        int pp = 45;
        A b(pp);
        b.print_val();
    }

     

    更多相关内容
  • 下面小编就为大家带来一篇关于C++的成员初始化列表的相关问题。小编觉得挺
  • 构造函数初始化列表以一个冒号开始,接着是以逗号分隔的数据成员列表,每个数据成员后面跟一个放在括号中的...而没使用初始化列表的构造函数是对的成员赋值,并没有进行显式的初始化。  初始化和赋值对内置类型的
  • C++为中提供成员的初始化列表 对象的构造 顺序是这样的:1.分配内存,调用构造函数 时,隐式/显示的初始化各数据 成员2.进入构造函数后在构造函数中执行一般计算 使用初始化列表有两个原因: 1.必须这样做:...
  •  Derive 构造函数两个 Base 类型的参数,分别赋给该两个 Base 类型的成员变量 b1、b2,一个使用初始化列表,一个使用等于号赋值。输出结果如下:  前两行输出是主函数前两行构造 b1、b2 对像时调用的带...
  • C++初始化列表

    千次阅读 2022-06-06 16:14:32
    初始化列表中构造函数的一部分,用于实例化中变量时 赋初值。

    意义

    初始化列表是类中构造函数的一部分,用于实例化类中变量时 赋初值。

    需要先了解  构造函数的基本知识。CSDN-构造函数https://blog.csdn.net/weixin_44212838/article/details/124901019?spm=1001.2014.3001.5501

    用法

    在函数头与函数体之间,用一个‘ ’列出变量,变量后用‘()’ 给出实例化该变量时要赋予的初值

    用例:

    class Date {
    public:
    
        Date(int year, int month, int day)
            :_year(year), _month(month),_day(day)//初始化列表
        {
            ;
        }
    private:
        int _year;
        int _month;
        int _day;
    };

    与在函数体内初始化的区别

    初始化列表 实在实例化,也就是为变量开辟空间后,立刻赋予初始值。

    类似于 

    int a=10;//实例化时赋予初始值

    而在构造函数体内初始化 ,则是先为变量开辟空间,后赋予值。

    类似于

    int a;//先为变量开辟空间
    a=10;//后赋予值

    常见的使用场景

    1.调用类中 自定义类型成员的构造函数

    #include<iostream>
    class a {
    public:
        a(int val,int date) {
            _val = val;
        }
    private:
        int _val;
        int _date;
    };
    class  A {
    public:
        A(int val = 1) 
            :ma(5,4)
        {
            _val = val;
        }
        int _val;
        a ma;
    };

    因为 class a没有默认构造函数,需要主动传参,而构造函数只能在实例化对象的时候调用,并且要先实例化成员变量才会进入class A的构造函数体内,所以,只能使用class A的初始化列表来调用class a的构造函数 初始化A的 成员变量ma。 

    2.类中 const修饰的成员变量

    #include<iostream>
    class A {
    public:
    	A(int val):_val(val){}
    	const int _val;
    };
    int main() {
    	A a (2);
    	std::cout << a._val;
    	return 0;
    }

    具有常属性的变量需要在实例化时赋初值

    3.类中 引用类型的成员变量

    #include<iostream>
    class A {
    public:
    	A(int val):_val(val),mval(_val){}
    	const int _val;
    	const int& mval;
    };
    int main() {
    	A a (2);
    	std::cout << a.mval;
    	return 0;
    }

    以上这就是初始化列表非常典型的使用场景。

    展开全文
  •  static const为全局静态常量,全局的意思是该变量属于整个而非某个实例,所以不能再初始化列表中进行初始化。 以上就是小编为大家带来的关于C++中构造函数初始化成员列表的总结全部内容了,希望
  • 对于成员是const修饰,或是引用类型的情况,是不允许赋值操作的,(显然嘛,const就是防止被错误赋值的,引用类型必须定义赋值在一起),因此只能用初始化列表对齐进行初始化。成员类型是没有默认构造函数的。若...
  • 在C++11中,结构体或的数据成员在申明时可以直接赋予一个默认值,初始化的方式有两种,一是使用等号“=”,二是使用大括号列表初始化的方式。注意,使用参考如下代码: class C { private: int a=7; //C++11 ...
  • c++中的初始化列表

    千次阅读 2022-04-13 21:52:28
    4. 成员变量在中声明次序就是其在初始化列表中的初始化顺序,与其在初始化列表中的先后次序无关 初始化列表的概念和使用 初始化列表:以一个冒号开始,接着是一个以逗号分隔的数据成员列表,每个"成员变量"后面...

    目录

    初始化列表的概念和使用

    初始化列表的注意事项

    1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

    2. 类中包含以下成员,必须放在初始化列表位置进行初始化:

    3.最好使用初始化列表进行初始化,因为对于自定义类型,我们还是需要使用初始化列表进行初始化的

    4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序,与其在初始化列表中的先后次序无关


    初始化列表的概念和使用

    初始化列表:以一个冒号开始,接着是一个以逗号分隔的数据成员列表,每个"成员变量"后面跟一个放在括号中的初始值或表达式

    Data(int year = 0, int month = 0, int day = 0) : _year(year), _month(month), _day(day)	
    //以构造函数声明后的:(冒号)开始,每个成员变量用,(逗号)隔开,()括号中放的是初始化的值
    	{}

    初始化列表的注意事项

    一个对象的当个成员变量在初始化列表是定义阶段(构造函数),而在构造函数里面就是赋值了,假如我们没写成员变量的初始化列表也会初始化,只不过初始化为随机值

    1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)


    2. 类中包含以下成员,必须放在初始化列表位置进行初始化:

    1、引用成员变量

    class Data
    {
    public:
    	Data(int year = 0, int month = 0, int day = 0):_a(year)	//使用初始化列表初始化
    	{
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    
    private:
    	int _year;
    	int _month;
    	int _day;
    	int& _a;	//定义一个引用成员变量
    };

    引用在类中只是被声明,没有被定义,所以可以先不初始化,当我们实例化一个对象之后,必须进行初始化,所以引用要在初始化列表初始化
     

    2、const成员变量

    class Data
    {
    public:
    	Data(int year = 0, int month = 0, int day = 0):_a(0)	//使用初始化列表初始化
    	{
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    
    private:
    	int _year;
    	int _month;
    	int _day;
    	const int _a;	//定义一个const修饰的成员变量
    };

    const修饰的成员变量不能够被修改,所以需要在定义时候进行初始化
     

    3、自定义类型成员(该类没有默认构造函数)

    class A
    {
    public:
    	A(int x)	//因为我们写了构造函数,所以这个类没有默认构造函数了
    	{
    		_a = x;
    	}
    public:
    	int _a;
    };
    
    class Data
    {
    public:
    	Data(int year = 0, int month = 0, int day = 0) :a(0)	//使用初始化列表初始化
    	{
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    
    private:
    	int _year;
    	int _month;
    	int _day;
    	A a;	//创建一个类的对象
    };

    因为类没有默认构造函数,所以类里面的成员变量不会自动赋值,我们必须对它进行初始化,这个初始化就在初始化列表

    3.最好使用初始化列表进行初始化,因为对于自定义类型,我们还是需要使用初始化列表进行初始化的

    4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序,与其在初始化列表中的先后次序无关

    #include<iostream>
    using namespace std;
    
    class A
    {
    public:
    	A(int a)
    		:_a1(a)
    		, _a2(_a1)    //使用初始化列表初始化
    	{}
    	void Print() {
    		cout << _a1 << " " << _a2 << endl;
    	}
    private:
    	int _a2;
    	int _a1;
    };
    
    int main() {
    	A aa(1);
    	aa.Print();
    }

    结果为因为初始化列表进行初始化的时候是按照成员变量声明的顺序来的,所以_a2先被初始化为随机值,_a1再被初始化为a

     

    展开全文
  • C++之初始化列表

    千次阅读 多人点赞 2022-06-11 17:56:53
    在创建对象时,编译器通过调用构造函数,给对象中各个成员变量一个合适的初始值。 虽然上述构造函数调用...尽量使用初始化列表初始化,因为不管你是否使用初始化列表,对于自定义类型成员变量,一定会先使用初始化列表


    前言

    一、构造函数体赋值

    在创建对象时,编译器通过调用构造函数,给对象中各个成员变量一个合适的初始值。

    class Date
    {
    public:
    Date(int year, int month, int day)
    {
    _year = year;
    _month = month;
    _day = day;
    }
    private:
    int _year;
    int _month;
    int _day;
    };
    

    虽然上述构造函数调用之后,对象中已经有了一个初始值,但是不能将其称作为类对象成员的初始化,构造函数体中的语句只能将其称作为赋初值,而不能称作初始化。因为初始化只能初始化一次,而构造函数体内可以多次赋值。

    二、初始化列表

    初始化列表:以一个冒号开始,接着是一个以逗号分隔的数据成员列表,每个"成员变量"后面跟一个放在括号中的初始值或表达式。

    class Date
    {
    	
    public:
    	
    	Date(int year = 1, int month = 1, int day = 1)//带参数的构造函数
    		:_year(1)//初始化列表
    		,_month(1)
    		,_day(1)
    	{}
    	
    	
    	Date(const Date& d)//拷贝构造函数
    	{
    		_year = d._year;
    		_month = d._month;
    		_day = d._day;
    	}
    	
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    

    注意:

    1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
    2. 类中包含以下成员,必须放在初始化列表位置进行初始化:
      引用成员变量
      const成员变量
      自定义类型成员(该类没有默认构造函数)
    class A
    {
    public:
    A(int a)
    :_a(a)
    {}
    private:
    int _a;
    };
    class B
    {
    public:
    B(int a, int ref)
    :_aobj(a)
    ,_ref(ref)
    ,_n(10)
    {}
    private:
    A _aobj; // 没有默认构造函数
    int& _ref; // 引用
    const int _n; // const
    };
    
    1. 尽量使用初始化列表初始化,因为不管你是否使用初始化列表,对于自定义类型成员变量,一定会先使用初始化列表初始化。
    2. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序,与其在初始化列表中的先后次序无关

    3.explicit关键字

    构造函数不仅可以构造与初始化对象,对于单个参数的构造函数,还具有类型转换的作用。
    列如:

    class Date
    {
    public:
    explicit Date(int year)
    :_year(year)
    {}
     Date(int year)
    :_year(year)
    {}
    private:
    int _year;
    int _month:
    int _day;
    }void TestDate()
    {
    Date d1(2018);
    // 用一个整形变量给日期类型对象赋值
    // 实际编译器背后会用2019构造一个无名对象,最后用无名对象给d1对象进行赋值
    d1 = 2019;
    // 上述类型含有隐式类型转换 “d1= 2019” 相当于 “Date d2(2019); Date d1(d2)”
    //编译器自动将整型转换为Date类对象
    }
    

    上述代码可读性不是很好,用explicit修饰构造函数,将会禁止单参构造函数的隐式转换。
    explicit的详细理解

    总结

    以上就是关于初始化列表的全部内容,感谢大家的观看

    展开全文
  • C++ 类初始化列表基类成员变量无效

    千次阅读 2019-08-16 14:54:54
    初始化列表时,仅支持该成员变量和基类构造函数初始化,基类的成员变量报错! #include<iostream> class Base { public: int m_value; }; class Son :public Base { public: Son() :m_value(value) //...
  • 考虑一下效率的可以再构造函数的初始化列表中进行。  class CA  {  public:  int data;  ……  public:  CA();  ……  };  CA::CA():data(0)//……#1……初始化列表方式  {  //data = 0;//...
  • C++构造函数之初始化列表

    千次阅读 2022-03-04 10:07:39
    C++构造函数的初始化列表详解
  • 一、中嵌套结构或声明 在中嵌套结构或声明,可以使其作用域为整个。可以使用嵌套的结构或来声明成员,也可以将它作为方法中 的类型名称,但只能在中使用。可以查看如下示例代码: typedef ...
  • C++初始化列表详解

    千次阅读 2020-07-01 12:21:32
    使用初始化列表的原因         必须使用初始化列表的时候         成员变量的顺序 定义 与其他函数不同,构造函数除了有名字,...
  • EnumTest-初始化成员对象(初始化列表方式)
  • c# 声明的时候初始化The task is to create/declare a... 任务是在C#中使用初始化列表创建/声明一个列表 。 C#清单 (C# List) A list is used to represent the list of the objects, it is represented as ...
  • C++中类初始列表与类内初始化

    千次阅读 2020-09-22 12:18:56
    的构造函数的作用是对其成员进行初始化。而在构造函数中可以使用初始值列表为新创建的对象的成员进行赋值。 1 初始值列表的构造函数名之后紧跟着冒号,冒号后面是要初始化的成员名,之后是圆括号或者花括号...
  • C++之列表初始化详解

    千次阅读 2022-04-11 16:40:04
    详细介绍列表初始化适用于哪些场景以及列表初始化所具有的优点,每个观点均有详细的代码验证,方便理解!
  • C++ 初始化列表给数组初始化

    千次阅读 2020-03-27 21:32:37
    一般的初始化是使用小括号()。 给数组初始化是使用大括号{}。 class base{ char a[10]; public: base():a{{}}{} } 上例的初始化就相当于:a[10] = {};。
  • 本文探讨C++构造函数体内初始化与列表初始化的区别: ...2、若B通过初始化列表去初始化,则只调用A的拷贝构造函数。 另外,虽然对于成员类型是内置类型的情况,通过上述两种情况去初始化是相同的,但是为了标...
  • 在刚接触QT的时候我们都会看到自动生成...B中包含另一个A的对象a,但是A的构造函数含有参数例如A(int x),那么当B初始化时,若没有初始化列表,无法正常初始化B,正确做法是将B的构造函数写为B():a(x)。 代码如
  • 原博地址:... 1. 成员为const类型 2. 成员为引用类型 #include using namespace std; class A { public: A(int &v) : i(v), p(v), j(v) {} vo
  • 一开始,我其实不打算把初始化列表单独拿出来写一篇文章的,我打算在创建一个的那一篇文章里一起写掉,但是写着写着就发现事情没有我想的那么简单,这里面的内容还是比较多地。 二、初始化列表格式: 在构造函数...
  • 初始化列表初始化顺序

    千次阅读 2018-07-23 09:15:01
    初始化列表是按中声明变量的先后顺序来初始化,与初始化列表的顺序无关。   class Printer{ public: Printer(std::string name) {std::cout &lt;&lt; name;} }; class Container{ public: ...
  • C++和对象(下)——初始化列表、static成员和友元

    千次阅读 多人点赞 2021-03-08 09:23:18
    C++和对象——初始化列表、static成员和友元一、再谈构造函数1.1 构造函数整体赋值1.2 初始化列表三级目录 关于C++和对象的学习 C++和对象(上)——的基本概念、的限定符及封装和成员函数的this指针 C++...
  • 成员变量初始化方法一、成员变量初始...因此初始化列表初始化的变量值会覆盖掉声明时初始化的值,而构造函数中初始化的值又会覆盖掉初始化列表的。 注意: 初始化列表中初始化的顺序是和变量声明的顺序一样,而与列表
  • C++列表初始化的好处

    千次阅读 2020-07-11 23:21:04
    列表初始化的好处的个人理解,边学边归纳理解,如果有错误希望能够指出 首先推荐使用列表初始化的原因是,it‘s either required or fast required:必须使用列表初始化的场合 成员中有常量,例如 const int a...
  • 文章目录初始化和赋值的区别列表初始化类数据成员 初始化和赋值的区别 初始化的含义是床关键变量时赋予其一个初始值,而赋值的含义时把对象的当前值擦除,而已一个新值来替代。 列表初始化 C++定义了初始化的好几...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 665,606
精华内容 266,242
关键字:

类的初始化列表