【C++】：类和对象(下)

目录

• 一，再谈构造函数
• • 1.初始化列表
  • 2. 隐式类型转换的过程及其优化
  • 3. 隐式类型转换的使用
  • 4. explcit关键字
  • 5. 单参数和多参数构造函数的隐式类型转换
  • 二，static成员
  • • 1.静态成员变量
    • 2.静态成员函数
    • 3. static 成员的应用
    • 三，友元
    • • 3.1 友元函数
      • 3.2 友元类
      • 四，内部类
      • 五，匿名对象

        一，再谈构造函数

        这个语法其实是对前面的构造函数的补充。最重要的是初始化列表的使用，及其特性，隐式类型转换，还有当前阶段需要了解的 explicit 关键字。

        1.初始化列表

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

        1.1 初始化列表的使用

        当我们实现一个MyQueue(用两个栈模拟一个队列)时，如果栈不具备默认构造，MyQueue也无法生成默认构造，此时MyQueue要显示实现默认构造。

        如何实现呢？必须用初始化列表。

        初始化列表的本质：可以理解为每个对象中成员定义的地方。

        typedef int DataType;
        class Stack
        {
        public:
        	Stack(size_t capacity )
        	{
        		_array = (DataType*)malloc(sizeof(DataType) * capacity);
        		if (NULL == _array)
        		{
        			perror("malloc申请空间失败!!!");
        			return;
        		}
        		_capacity = capacity;
        		_size = 0;
        	}
        	void Push(DataType data)
        	{
        		// CheckCapacity();
        		_array[_size] = data;
        		_size++;
        	}
        	~Stack()
        	{
        		if (_array)
        		{
        			free(_array);
        			_array = NULL;
        			_capacity = 0;
        			_size = 0;
        		}
        	}
        private:
        	DataType* _array;
        	int _capacity;
        	int _size;
        };
        class MyQueue
        {
        public:
            //初始化列表
        	MyQueue(int n= 20)
        		:_pushst(n)//自定义类型会调用构造函数
        		, _popst(n)
        		//, _size(0) //ok
        	{
        		//函数体内
        		_size = 0;//ok
        	}
        private:
        	//声明
        	Stack _pushst;
        	Stack _popst;
        	int _size;
        };
        int main()
        {
        	MyQueue q1(10);
        	MyQueue q2;//有缺省值时可以不用赋值，没传默认用缺省值
        	return 0;
        }
        

        1.2 有些变量只能在初始化列表中初始化，不能在函数体中初始化。

        (1) const 成员变量；

        const 成员变量必须在定义的地方初始化，因为它只有一次初始化机会。或是在声明时用缺省值。

        (2) 引用成员变量；

        引用也必须在定义的时候初始化。

        (3) 没有默认构造的自定义类型成员。

        因为没有默认构造时，必须显式传参调用构造函数。

        class MyQueue
        {
        public:
        	MyQueue(int n,int& rr)//这里也可以写缺省值
        		:_pushst(n)//自定义类型会调用构造函数
        		, _popst(n)
        		//, _size(0) //ok
        		,_x (1)
        		,_ref(rr)
        	{
        		//函数体内
        		_size = 0;//ok
        		//_x =1; //err
        	}
        private:
        	//声明
        	Stack _pushst;
        	Stack _popst;
        	int _size;
        	//const变量必须在定义的时候初始化。因为它只有一次初始化的机会
        	const int _x;
          const int _x = 10;//在这里给缺省值ok
            
        	//引用变量必须在定义的时候初始化
        	int& _ref;
        };
        int main()
        {
        	int xx = 0;
        	MyQueue q1(10,xx);
        	MyQueue q1(10);
        	int& aa = xx;
        	return 0;
        }
        

        1.3 初始化列表，不管你写不写，每个成员变量都会先走一遍，此时自定义类型的成员会调用默认构造(没有默认构造就编译报错)，内置类型看编译器，有点会处理，有的不会处理。

        1.4 在C11中我们知道可以在成员变量声明时给缺省值，实际上这个缺省值就是给初始化列表用的。但是与此同时，如果在初始化列表中给定了值，就以列表中的为准，与缺省值无关。

        class MyQueue
        {
        public:
        	//实践总结：尽可能使用初始化列表初始化，不方便再使用函数体初始化
        	MyQueue()
        		:_pushst(10)
        		,_ptr((int*)malloc(40)) //ok
        	{
        		_size = 2;
        	}
        private:
        	//声明
        	Stack _pushst;
        	Stack _popst;
        	
            //这里的缺省值是1，但是初始化列表中是2，此时_size = 2
        	int _size = 1;
        	int* _ptr;
        };
        

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

        比如下面的代码，运行结果是：1 ，随机值。

        这是因为先声明的是_a2 ，所以在初始化时会先走_a2(_a1)这条语句，而此时_a1没有初始化，是随机值，所以_a2是随机值。再初始化_a1。

        class A
        {
        public:
        	A(int a)
        		:_a1(a)
        		, _a2(_a1)
        	{}
        	void Print() 
        	{
        		cout 
        	A aa(1);
        	aa.Print();
        }
        
        public:
        	//单参数构造函数
        	A(int a)
        		:_a(a)
        	{
        		cout 
        		cout 
        	A aa1(1);
        	//拷贝构造
        	A aa2 = aa1;//ok
        	
        	//过程：先用3构造了一个A的临时对象，再用临时对象去拷贝构造给aa3
        	//优化：在一个表达式中，编译器遇到构造 + 拷贝构造，会优化成直接构造
        	A aa3 = 3;
        	//A& raa = 4;//err
        	
        	//当用引用时，由于用3构造了一个临时对象，临时对象具有常性，所以加const
        	//过程：这里只用3构造了一个临时对象，没有拷贝构造
        	
        	//raa引用的是类型转换中用3构造的临时对象
        	const A& raa = 4;//ok
        	return 0;
        }
        
        public:
        	A(int a)
        		:_a1(a)
        		, _a2(_a1)
        	{}
        	void Print()
        	{
        		cout 
        public:
        	//方式1：ok
        	//void Push(A& aa)
        	//{
        	//	//.......
        	//}	
        	//方式2：ok
        	void Push(const A& aa)
        	{
        		//....
        	}
        	//.....
        };
        int main()
        {
        	Stack st;
        	//方式1：会进行先构造，后拷贝构造
        	A a1(1);
        	st.Push(a1);
        	//方式2：10进行了隐式类型转换，时代码更简洁
        	st.Push(10);
        	return 0;
        }
        
        public:
        	//单参数构造函数
        	explicit A(int a)
        	//A(int a)
        		:_a(a)
        	{
        		cout 
        		cout 
        	A aa1(1);
        	//拷贝构造
        	A aa2 = aa1;
        	A aa3 = 3;
        	const A& raa = 4;
        	return 0;
        }
        
        public:
        	//单参数构造函数
        	//explicit A(int a)
        	A(int a)
        		:_a(a)
        	{
        		cout }
        	//拷贝构造
        	A(const A& aa)
        		:_a(aa._a)
        	{
        		cout 
        	A aaa1(1, 2);
        	A aaa2 = { 1,2 };//传参时要用花括号
        	const A& aaa3 = { 3,2 };
        	return 0;
        }
        
        public:
        	A()
        	{
        		cout 
        		cout 
        		cout 
        	A aa1;
        	cout 
        public:
        	A()
        	{
        		++_scount;
        	}
        	A(const A& t)
        	{
        		++_scount;
        	}
        	~A()
        	{
        		--_scount;
        	}
        private:
        	//声明
        	int _a1;
        	int _a2;
        public:
        	static int _scount;
        };
        int A::_scount = 0;
        int main()
        {
        	A aa1;
        	//cout 
        public:
        	A()
        	{
        		++_scount;
        	}
        	A(const A& t)
        	{
        		//但是非静态的可以调用静态的
        		GetCount();//ok
        		++_scount;
        	}
        	~A()
        	{
        		--_scount;
        	}
        	//特点：static修饰成员函数，没有this指针，意味着只能访问静态成员
        	//不能访问其他的成员变量
        	static int GetCount()
        	{
        		return _scount;
        	}
        private:
        	//声明
        	int _a1;
        	int _a2;
        	static int _scount;
        };
        int A::_scount = 0;
        int main()
        {
        	A aa1;
        	A aa2;
        	A aa3;
        	//调用方式
        	cout 
        public:
            Sum()
            {
               _ret += _i;
               _i++;
            }
            
            //由于静态成员变量是私有的，要拿到它们的值，
            //就要使用静态成员函数
            static int GetRet()
            {
                return _ret;
            }
        private:
            static int _i;
            static int _ret;
        };
        //静态成员变量要在全局定义，要指定类域
        int Sum::_i = 1;
        int Sum::_ret = 0;
        class Solution {
        public:
            int Sum_Solution(int n) {
                //变长数组
                //定义一个Sum类的数组，调用n次构造函数
                Sum arr[n];
                return Sum::GetRet();
            }
        };
        
        public:
         Date(int year, int month, int day)
             : _year(year)
             , _month(month)
             , _day(day)
         {}
         
        // d1 
             _cout 
         //友元函数的声明
         friend ostream& operator}
        private:
        	 int _year;
        	 int _month;
        	 int _day;
        };
        ostream& operator
         _cout 
        	 _cin  d._year;
        	 _cin  d._month;
        	 _cin  d._day;
        	 
        	 return _cin;
        }
        int main()
        {
        	 Date d;
        	 cin  d;
        	 cout 
           //声明 Date是Time的友元
           //则在Date中可以访问Time中的私有，但是反过来不行
           friend class Date; 
           
        public:
         Time(int hour = 0, int minute = 0, int second = 0)
         : _hour(hour)
         , _minute(minute)
         , _second(second)
         {}
           
        private:
           int _hour;
           int _minute;
           int _second;
        };
        class Date
        {
        public:
           Date(int year = 1900, int month = 1, int day = 1)
               : _year(year)
               , _month(month)
               , _day(day)
           {}
           
           void SetTimeOfDate(int hour, int minute, int second)
           {
               // 直接访问时间类私有的成员变量
               _t._hour = hour;
               _t._minute = minute;
               _t._second = second;
           }
           
        private:
           int _year;
           int _month;
           int _day;
           Time _t;
        };
        
        private:
        	 static int k;
        	 int h;
        public:
         class B // B天生就是A的友元
         {
         public:
         void foo(const A& a)
         {
        	 cout 
            A::B b;
            b.foo(A());
            
            return 0;
        }
        
        public:
         A(int a = 0)
         :_a(a)
         {
        	 cout 
        	 cout 
        public:
         int Sum_Solution(int n) 
         {
        	 //...
        	 return n;
         }
        };
        int main()
        {
        	 A aa1;
        	 
        	 // 不能这么定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义
        	 //A aa1();
        	 
        	 // 但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，
        	 // 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数
        	 A();
        	 A aa2(2);
        	 
        	 // 匿名对象在这样场景下就很好用，当然还有一些其他使用场景，这个我们以后遇到了再说
        	 Solution().Sum_Solution(10);
         
             return 0;
        }