【C++】类与对象【下】

文章目录

• 再谈构造函数
• • 构造函数的赋值
  • • 构造函数体赋值：
    • 初始化列表
    • explicit关键字
    • static成员
    • • 概念
      • 特性
      • C++11中成员初始化的新玩法
      • 友元
      • • 友元类
        • 内部类
        • • 概念

            

            再谈构造函数

            构造函数的赋值

            构造函数体赋值：

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

            class Date
            {
            public:
            	// 构造函数
            	Date(int year = 0, int month = 1, int day = 1)
            	{
            		_year = year;
            		_month = month;
            		_day = day;
            	}
            private:
            	int _year;
            	int _month;
            	int _day;
            };
            

            • 初始化和赋值的概念不同

              调用构造函数后，每个变量都有一个初始值，但是构造函数中的语句只能将其赋初值，而不能称为初始化，因为初始话只能初始化一次，构造函数体内可以及进行的多次赋值

              class Date
              {
              public:
              	// 构造函数
              	Date(int year = 0, int month = 1, int day = 1)
              	{
              		_year = year;
              		_month = month;
              		_month=6;
              		_day = day;
              	}
              private:
              	int _year;
              	int _month;
              	int _day;
              };
              

              初始化列表

              初始化列表：

              以一个冒号开始，接着以逗号分隔数据的成员列表，每个成员变量后面跟一个放在括号中的初始值或表达式，初始化完之后，结尾处要有一个“{}”的结束符号

              注意事项：

              1. 每个成员变量在初始化列表中只能出现一次
                 • 即同一成员变量不能同时出现
                 • 类中包含以下成员，必须放在初始化列表进行初始化
                   1. 引用成员变量
                      • 引用类型的变量在定义时就必须给一个初始值，引用成员变量必须使用初始化列表对齐进行初始化。

                   	int a = 10; 
                   	int& b = a;// 创建时就初始化
                   

                   1. const成员变量

                      被congst成员变量，被修饰的变量也必须在定义时给一个初始值

                   	const int a = 10;
                   	//correct 创建时就初始化 const int b;
                   	//error 创建时未初始化
                   

                   1. 自定义类型成员

                      若一个类没有默认构造函数，那么在实例化该类对象时需要传参对齐进行初始化，所以实例化没有默认构造函数的类对象时必须使用初始化列表对齐进行初始化。

              		class A //该类没有默认构造函数 
              {
              public:
              	A(int val) //注：这个不叫默认构造函数（需要传参调用）
              	{
              		_val = val;
              	}
              private:
              	int _val;
              };
              class B
              {
              public:
              	B()
              		:_a(2021) //必须使用初始化列表对其进行初始化
              	{}
              private:
              	A _a; //自定义类型成员（该类没有默认构造函数）
              };
              

              • 在这里再声明一下，默认构造函数是指不用传参就可以调用的构造函数

                1.我们不写，编译器自动生成的构造函数。

                2.无参的构造函数。

                3.全缺省的构造函数。

                二.尽量使用初始化列表初始化

              • 因为初始化列表实际上就是当你实例化一个对象时，该对象的成员变量定义的地方，所以无论你是否使用初始化，都会走怎么一个过程

                严格来说：

                 1. 对于内置类型，使用初始化列表和在构造函数体内进行初始化实际上是没有差别的，其差别就类似于如下代码：

                 // 使用初始化列表 int a = 10 // 在构造函数体内初始化（不使用初始化列表） int a; a = 10;
                

                1. 对于自定义类型，使用初始化列表可以提高代码的效率

                		class Time
                {
                public:
                	Time(int hour = 0)
                	{
                		_hour = hour;
                	}
                private:
                	int _hour;
                };
                class Test
                {
                public:
                	// 使用初始化列表
                	Test(int hour)
                		:_t(12)// 调用一次Time类的构造函数
                	{}
                private:
                	Time _t;
                };
                

                如果不走初始化列表，我们需要这样写

                class Time
                {
                public:
                	Time(int hour = 0)
                	{
                		_hour = hour;
                	}
                private:
                	int _hour;
                };
                class Test
                {
                public:
                	// 在构造函数体内初始化（不使用初始化列表）
                	Test(int hour)
                	{ //初始化列表调用一次Time类的构造函数（不使用初始化列表但也会走这个过程）
                		Time t(hour);// 调用一次Time类的构造函数
                		_t = t;// 调用一次Time类的赋值运算符重载函数
                	}
                private:
                	Time _t;
                };
                

                

                • 这当我们要实例化一个Test类的对象时，在实例化过程中会先在初始化列表时调用一次Time类的构造函数，
                • 实例化t对象时调用一次Time类的构造函数，最后还需要调用了一次Time类的赋值运算符重载函数

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

                  #include 
                  using namespace std;
                  int i = 0;
                  class Test
                  {
                  public:
                  	Test()
                  		:_b(i++)
                  		,_a(i++)
                  	{}
                  	void Print()
                  	{
                  		cout