C++面向对象程序设计之类与对象（3）

1. 取地址运算符重载

1.1 const 成员函数 

1. 将 const 修饰的成员函数称之为const成员函数，const 修饰成员函数放到成员函数参数列表        的后面
2. const实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修          改。const 修饰 Date 类的 Print 成员函数， Print 隐含的this指针由 Date* const this 变为          const  Date* const this

3. 一般地，建议不对类成员变量进行修改的函数都定义为 const 成员函数

#include<iostream>

using namespace std;

class Date{
public:

	Date(int year,int month,int day);
	~Date();
	Date(const Date& d);
	Date& operator=(const Date& d);
	void Show() const;
	int Get_year() const;
	int Get_month() const;
	int Get_day() const;
private:
	int _year;
	int _month;
	int _day;
};

//构造函数
Date::Date(int year, int month, int day)
{
	cout << "Date(int year, int month, int day)" << endl;
	_year = year;
	_month = month;
	_day = day;
}

//析构函数
Date::~Date()
{
	cout << "~Date()" << endl;
	_year = 0;
	_month = 0;
	_day = 0;
}

//拷贝构造函数
Date::Date(const Date& d)
{
	cout << "Date(const Date& d)" << endl;
	_year = d._year;
	_month = d._month;
	_day = d._day;
}

//赋值重载
Date& Date::operator=(const Date& d)
{
	cout << "Date operator=(const Date& d)" << endl;
	_year = d._year;
	_month = d._month;
	_day = d._day;

	return *this;
}

void Date::Show()const
{
	cout << _year << "年" << _month << "月" << _day << "日" << endl;
}

int Date::Get_year() const
{
	return _year;
}
int Date::Get_month() const
{
	return _month;
}
int Date::Get_day() const
{
	return _day;
}

int main()
{
	//Date d1(2024, 7, 19);
	//Date d2(2024, 7, 20);

	赋值重载
	//d1 = d2;

	拷贝构造
	//Date d3 = d2;
	//Date d4(d2);

	const Date d1(2024, 7, 21);
	d1.Show();

	//权限的缩小，合法
	Date d2(2024, 7, 22);
	d2.Show();
	int year = d2.Get_year();
	int month = d2.Get_month();
	int day = d2.Get_day();
	cout << "<" << year << ">" << "<" << month << ">" << "<" << day << ">" << endl;

	return 0;
}

1.2 取地址运算符重载

1. 取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载，一般这两个函数编译      器自动生成的就可以够我们用了，不需要去显示实现。除非一些很特殊的场景，比如我们不想        让别人取到当前类对象的地址，就可以自己实现一份，胡乱返回一个地址

2. 初始化列表 

1. 之前我们实现构造函数时，初始化成员变量主要使⽤函数体内赋值，构造函数初始化还有⼀种        ⽅式，就是初始化列表，初始化列表的使⽤⽅式是以⼀个冒号开始，接着是⼀个以逗号分隔            的数据成员列表，每个"成员变量"后⾯跟⼀个放在括号中的初始值或表达式
• 每个成员变量在初始化列表中只能出现⼀次，语法理解上初始化列表可以认为是每个成员变量定     义初始化的地⽅。 
• 引⽤成员变量，const成员变量，没有默认构造的类类型变量，必须放在初始化列表位置进⾏初    始化，否则会编译报错。 
• C++11⽀持在成员变量声明的位置给缺省值，这个缺省值主要是给没有显⽰在初始化列表初始化    的成员使⽤的 

注意:在类内定义的变量均为声明，没有开辟空间都是声明，如果后面赋值则为缺省值

class Time
{
public:
    //没有合适的默认构造,需要在初始化列表进行初始化
    Time(int hour)
    {
       cout<<"Time(int hour = 0)"<<endl;
    }
private:
    int _hour;
};

class Date{
public:

	Date(int year,int month,int day,int& ret);
	
private:
    //声明,缺省值
	int _year = 1;
	int _month = 1;
	int _day = 1;
    const int _n;
    int& _ret;
};

//初始化列表
//const 成员变量和引用变量必须在初始化列表初始化
Date::Date(int year,int month,int day,int& ret)
	:_year(year),
	_month(month),
	_day(day),
    _n(1),
    _ret(ret)
{
	//函数体
	cout << "Date(int year, int month, int day,int& ret)" << endl;
}

//Date(int year = 1,int month = 1.int day = 1);
//注意括号内的值不是初始化,作用是在定义时未显式传参时的默认值
//例如：Date d;
//     d.Print();//(1,1,1)

3. 静态成员

  static 成员
• ⽤static修饰的成员变量，称之为静态成员变量，静态成员变量⼀定要在类外进⾏初始化
• 静态成员变量为所有类对象所共享，不属于某个具体的对象，不存在对象中，存放在静态区
• ⽤static修饰的成员函数，称之为静态成员函数，静态成员函数没有this指针
• 静态成员函数中可以访问其他的静态成员，但是不能访问⾮静态的，因为没有this指针
• ⾮静态的成员函数，可以访问任意的静态成员变量和静态成员函数
• 突破类域就可以访问静态成员，可以通过类名::静态成员或者对象.静态成员来访问静态成员变量    和静态成员函数
• 静态成员也是类的成员，受public、protected、private访问限定符的限制
• 静态成员变量不能在声明位置给缺省值初始化，因为缺省值是个构造函数初始化列表的，静态成    员变量不属于某个对象，不⾛构造函数初始化列表

class A
{
public:
	A() {};
	//静态成员函数
	static int GetCount()
	{
		return count;
	}
private:
	//在类内声明
	static int count;
};
//类外初始化
int A::count = 1;

int main()
{

	cout << A::GetCount() << endl;//运行结果为1
	return 0;

}

练习： 

解答：C 对象是全局变量先初始化先构造，然后A、B分别构造，D是局部静态成员变量，第一次               运行到D才进行构造，所以构造顺序为 C A B D

           由后定义先析构，所以B比A先析构，D的声明周期为全局，所以在A、B局部变量之后析                 构，所以析构顺序为 B A D C

4. 友元 

友元定义 

• 友元提供了⼀种突破类访问限定符封装的⽅式，友元分为：友元函数和友元类，在函数声明或者    类声明的前⾯加friend，并且把友元声明放到⼀个类的⾥⾯
• 外部友元函数可访问类的私有和保护成员，友元函数仅仅是⼀种声明，他不是类的成员函数。 
• 友元函数可以在类定义的任何地⽅声明，不受类访问限定符限制
• ⼀个函数可以是多个类的友元函数
• 友元类中的成员函数都可以是另⼀个类的友元函数，都可以访问另⼀个类中的私有和保护成员
• 友元类的关系是单向的，不具有交换性，⽐如A类是B类的友元，但是B类不是A类的友元 
• 友元类关系不能传递，如果A是B的友元，B是C的友元，但是A不是C的友元
• 有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多⽤

class A
{
	// 友元声明 
	friend class B;

private:
	int _a1 = 1;
	int _a2 = 2;
};

class B
{
public:
	void func1(const A& aa)
	{
		cout << aa._a1 << endl;
		cout << _b1 << endl;
	}
	void func2(const A& aa)
	{
		cout << aa._a2 << endl;
		cout << _b2 << endl;
	}

private:
	int _b1 = 3;
	int _b2 = 4;
};

int main()
{
	A aa;
	B bb;
	bb.func1(aa);
	bb.func1(aa);
	return 0;
}

5. 内部类

   内部类定义 

• 如果⼀个类定义在另⼀个类的内部，这个内部类就叫做内部类。内部类是⼀个独⽴的类，跟定义    在全局相⽐，他只是受外部类类域限制和访问限定符限制，所以外部类定义的对象中不包含内部    类
• 内部类默认是外部类的友元类
• 内部类本质也是⼀种封装，当A类跟B类紧密关联，A类实现出来主要就是给B类使⽤，那么可以    考虑把A类设计为B的内部类，如果放到private/protected位置，那么A类就是B类的专属内部        类，其他地⽅都⽤不了

#include<iostream>

using namespace std;

class A

{
private:
     static int _k;
     int _h = 1;

public:
     class B // B默认就是A的友元 
     {
      public:
          void foo(const A& a)
          {
                cout << _k << endl; //OK
                cout << a._h << endl; //OK
          }
      private:
          int _b = 1;
     };
};

int A::_k = 1;

int main()
{

   cout << sizeof(A) << endl;//4
   A::B b;
   A aa;
   b.foo(aa);
   return 0;

}

6. 匿名对象

匿名对象的定义

• ⽤类型(实参)定义出来的对象叫做匿名对象，相⽐之前我们定义的类型对象名(实参)定义出来的      叫有名对象

• 匿名对象⽣命周期只在当前⼀⾏，⼀般临时定义⼀个对象当前⽤⼀下即可，就可以定义匿名对        象

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}

private:
	int _a;
};

class Solution 
{
public:
	int Sum_Solution(int n) 
    {
		//...
		return n;
	}
};

int main()
{
	A aa1;
	// 不能这么定义对象，因为编译器⽆法识别下⾯是⼀个函数声明，还是对象定义 
	//A aa1();

	// 但是我们可以这么定义匿名对象，匿名对象的特点不⽤取名字， 
    // 但是他的⽣命周期只有这⼀⾏，我们可以看到下⼀⾏他就会⾃动调⽤析构函数 
	A();
	A(1);
	A aa2(2);
	// 匿名对象在这样场景下就很好⽤，当然还有⼀些其他使⽤场景，这个我们以后遇到了再说 
	Solution().Sum_Solution(10);
	return 0;
}