请回答C++类和对象【下】

1.深入构造函数

1.1 构造函数体赋值

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

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

1.2 初始化列表

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

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 = 0, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
	{
		_day = day;
	}
private:
	// 成员变量声明
	int _year;
	int _month;
	int _day;
};

1.3 初始化列表注意事项

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

成员变量声明和特殊变量的声明，包含一个额外的自定义类型A

class A
{
public:
	A(int x)
	{
		cout << "A(int x)" << endl;
		_x = x;
	}
private:
	int _x;
};
class Date
{
	friend class Time;
    
    //构造函数部分

    private:
	// 成员变量声明
	int _year;
	int _month;
	int _day;

	// 他们必须在定义的时候初始化
	const int _n;
	int& _ref;
	A _a; 
};

初始化，有些必须定义的时候初始化

	// 可以理解成，一个对象的单个成员变量在初始化列表是
	// 这个其实算是初始化列表初始化和函数体内初始化不同的地方，也是他的价值体现
	Date(int year = 0, int month = 1, int day = 1)
		: _year(year)//没要求定义的时候初始化，两个地方随便放
		, _month(month)
		, _n(10)
		, _ref(year)
		, _a(1)  // 自定义类型显式去调用
	{
		_day = day;
		//	_n = 10; // 不能在函数体内初始化，必须使用初始化列表初始化
		// _ref = year;//err
	}

类中包含以下成员，必须放在初始化列表位置进行初始化：

​ 引用成员变量
​ const成员变量
​ 自定义类型成员(该类没有默认构造函数)

默认构造函数就是无参构造函数

尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于__自定义类型成员变量__，一定会先使用初始化列表初始化。自定义类型最好使用初始化列表

下面是两种使用方式

class Time
{
public:
	Time(int hour = 0)
		:_hour(hour)
	{
		cout << "Time()" << endl;
	}
private:
	int _hour;
};
class Date
{
public:
	//自定义类型，使用初始化列表 -》 构造函数
	Date(int day, int hour)
		:_t(hour)
	{}
	// 自定义类型，不使用初始化列表 -》 构造函数 + operator=
	Date(int day, int hour)
	{
		// 函数体内初始化
		Time t(hour);
		_t = t;
	}
private:
	int _day;
	Time _t;
};

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

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();
}

上面的代码输出什么？

• 输出1 1
• 程序崩溃
• 编译不通过
• 输出1 随机值

应该是1和随机值，因为初始先_a2后_a1

小结：本质上这种初始化列表就是为了区分一般的构造函数形式

初始化列表是成员变量定义初始化的地方，写了就用初始化，没写就用缺省值初始化，如果没有缺省值，内置类型成员就是随机值

1.4 explicit关键字

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

主函数中的初始化方式有如下三种

int main()
{
	A aa1(1);//直接传参数初始化
	A aa2(aa1);//调用拷贝构造
	A aa3=2；//单参数的构造函数，支持隐式类型转换
        //隐式转换的过程是先创建一个tmp，然后把调用拷贝构造
        //早期编译器：A tmp(2) -> A aa3(tmp) 现在的编译器：做了优化直接调用构造器
	return 0;
}

如果加了关键字explicit的话，就不允许隐式类型转换的发生

class Date
{
public:
	Date(int year)
		:_year(year)
	{}
	explicit Date(int year)
		:_year(year)
	{}
private:
	int _year;
	int _month :
	int _day;
}；
void TestDate()
{
	Date d1(2018);
	// 用一个整形变量给日期类型对象赋值
	// 实际编译器背后会用2019构造一个无名对象，最后用无名对象给d1对象进行赋值
	d1 = 2019;
}

用explicit修饰构造函数，将会禁止单参构造函数的隐式转换。

这样就不可以使用匿名对象了，那匿名对象有什么好处呢？使用场景是什么？

什么场景使用：定义一个对象要用，但是这里这一行用，其他地方不用。

先定义有名对象，反而麻烦，直接定义匿名对象，方便快捷

使用匿名对象会使得有些地方用起来更加方便便捷

	vector<A> v
        
        //不适用匿名对象
	A aa1(1);
	v.push_back(aa1);
	A aa2(2);
	v.push_back(aa2);

	// 使用匿名对象方便快捷
	v.push_back(A(3));
	v.push_back(A(4));
	v.push_back(A(5));

2. 静态成员

2.1 static静态成员

声明为__static的类成员__称为__类的静态成员__，用__static__修饰的__成员变量__，称之为__静态成员变量__；用static修饰的__成员函数__，称之为__静态成员函数__。静态的成员变量一定要在类外进行初始化

2.2 静态成员变量的初始化和定义

class A
{
public:
	A()
	{
		cout << "A()" << endl;
	}
private:
	// 这里只是声明，不在构造函数初始化，在类外面全局位置初始化
	static int _n;  // n是存在静态区，属于整个类，也属于类的所有对象
	int _a;
};
// 静态成员变量的定义初始化
int A::_n = 0;

2.2.1 利用static计算构造出多少对象

实现一个类，计算中程序中创建出了多少个类对象。

class A
{
public:
	A() { ++_scount; }
	A(const A& t) { ++_scount; }
private:
	static int _scount;
};
int A::_count = 0;

可以利用static一个变量n来计算，每构造一个对象就n++

那获取n的值也可以有多种，可以来一个getN的方法

int GetN() 
	{
		return _n;
	}

2.3 静态方法

一般要去访问静态成员变量，要使用静态方法

	// 跟普通成员函数区别：没有this指针，不能访问非静态成员
	static int GetN() 
	{
		return _n;
	}

2.4 static静态成员快速入门

静态成员__为所有__类对象所共享，不属于某个具体的对象，他是放在静态区的

静态成员变量__必须在__类外定义，定义时不添加static关键字

类静态成员即可用类名::静态成员或者对象.静态成员来访问（突破类域）

int main()
{
	A a1;
	//cout << sizeof(A) << endl;
	// 静态成员，不属于某个对象，突破类域就能访问
	cout << a1.GetN() << endl;
	cout << A().Ge tN() << endl;
	cout << A::GetN() << endl;
	return 0;
}

静态成员函数__没有__隐藏的__this指针__，不能访问任何非静态成员

静态成员和类的普通成员一样，也有public、protected、private3种访问级别，也可以具有返回值（类外访问还要看访问限定符）

静态成员函数可以调用非静态成员函数吗？

不能

非静态成员函数可以调用类的静态成员函数吗？

可以

void f()
	{
		GetN();
	}
	static int GetN() 
	{
		return _n;
	}

2.5 Java中的类变量和类方法

类变量也叫静态变量/静态属性,是该类的所有对象共享的变量,任何一个该类的对象去访问它时,取到的都是相同的值,同样任何一个该类的对象去修改它时,修改的也是同一个变量。

2.5.1 static变量快速入门

2.5.1.1 定义类变量

2.5.1.2 如何访问类变量

类名.类变量名或者``对象名.类变量名 `【静态变量的访问修饰符的访问权限和范围和普通属性是一样的】

推荐使用:类名类变量名

2.5.1.3 类变量特点

static 变量是同一个类的所有所有对象共享

static 类变量，在类加载的时候就生成了

2.5.2 static变量使用细节

什么时候需要用类变量？
当我们需要让某个类的所有对象都共享一个变量时,就可以考虑使用类变量(静态变量):比如:定义学生类,统计所有学生共交多少钱.Student (name, static fee)

类变量与实例变量(普通属性)区别？
类变量是该类的所有对象共享的,而实例变量是每个对象独享的。

加上static称为类变量或静态变量,否则称为实例变量/普通变量/非静态变量

类变量可以通过类名类.变量名或者对象名.类变量名来访问,但java设计者推荐使用类名.类变量名方式访问。【前提是满足访问修饰符的访问权限和范围】

实例变量不能通过类名.类变量名方式访问。

类变量是在类加载时就初始化了,也就是说,即使你没有创建对象,只要类加载了,就可以使用类变量了。

类变量的生命周期是随类的加载开始,随着类消亡而销毁。

2.5.3 类方法快速入门

2.5.3.1 定义类方法

类方法调用

类名.类方法名 或者 对象名.类方法名【前提是满足访问修饰符的访问权限和范围】

2.5.4 类方法使用细节

类方法和普通方法都是随着类的加载而加载,将结构信息存储在方法区类方法中无this的参数普通方法中隐含着this的参数

类方法可以通过类名调用,也可以通过对象名调用。

普通方法和对象有关,需要通过对象名调用,比如对象名.方法名(参数),不能通过类名调用。

类方法中不允许使用和对象有关的关键字,比如this和super,普通方法(成员方法可以

类方法(静态方法)中只能访问静态变量或静态方法。

普通成员方法,既可以访问非静态成员,也可以访问静态成员。

小结:静态方法,只能访问静态的成员,非静态的方法,可以访问静态成员和非静态成员(必须遵守访问权限)

2.6 练习题

求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

条件限制不能用循环递归和公式，于是想到构造函数里面又一个静态成员变量，每次调用就可以实现加法，⚠️注意每次调用要有一个Init函数初始化回0，不然多次调用结果出错

class Add
    {
        public:
        Add()//放到构造函数里面就可以实现多次调用，每次调用的时候加一下 
        {
            _ret += _i;
            _i++;
        }
      static int GetRet()
        {
            return _ret;
        }
      static void Init()
      {
          _ret=0;
          _i=1;
      }
        private:
        static int _i;
        static int _ret;
            
    };
int Add::_i=1;
int Add::_ret=0;

class Solution {
public:
    
    int Sum_Solution(int n) {
        Add::Init();
        Add arr[n];
        return Add::GetRet();
    }
};

或者用友元就不用初始化和get静态函数

    class Add
    {
        public:
        friend class Solution;
        Add()//放到构造函数里面就可以实现多次调用，每次调用的时候加一下 
        {
            _ret += _i;
            _i++;
        }
        private:
        static int _i;
        static int _ret;
    };
//这两个初始化还是不能shne
int Add::_i=0;
int Add::_ret=0;

class Solution {
public:
    int Sum_Solution(int n) {
        Add::_i=1;
        Add::_ret=0;
        Add arr[n];
        return Add::_ret;
    }
};

3. C++11 成员变量初始值

C++11支持非静态成员变量在声明时进行初始化赋值，但是要注意这里__不是初始化__，这里是__给声明的成员变量缺省值__。

class B
{
public:
	B(int x = 0)
		:_x(x)
	{
		cout << "B()" << endl;
	}
	int _x;
};

class A
{
public:
	A(int a = 1, int* p = nullptr)
		:_a(a)
		, _p(p)
	{}
private:
	// 声明 《= 缺省值
   //常规	
    int _a = 0;
	int* _p = nullptr;
    //更BUG的玩法
	int* arr = (int*)malloc(sizeof(int) * 10);
	B _b = 6;//自定义类型也可以缺省  
	static int _n;
};

4. 友元

友元分为：友元函数__和__友元类

友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

4.1 友元函数

我们先通过一个现实的栗子来描述友元的作用

之前提到的cin和cout对印的对象分别是ostream和``istream，之所以它们能够格式化输入和输出就是因为在类中对于>>`使用了operator运算符重载，使得可以接受各种内置类型，所以自动识别类型就是函数重载所实现的

那实现自定义类型的输入和输出怎么办呢，我们就要想办法自己去实现

但是发现我们没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。

void operator<<(ostream& out) // void operator<<(Date* this, ostream& out)
	{
		out << _year << "-" << _month << "-" << _day << endl;
	}

导致我使用该函数的时候，总是要这样去使用，但是实际使用中cout需要是第一个形参对象，才能正常使用，这大大这影响了代码的可读性

d1 << cout;

所以我们要将operator<<重载成全局函数。但是这样的话，又会导致类外没办法访问成员，那么这里就需要友元来解决。operator>>同理。

ostream& operator<<(ostream& out, const Date& d) // void operator<<(Date* this, ostream& out)
{
	out << d._year << "-" << d._month << "-" << d._day << endl;
	return out;
}
istream& operator>>(istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

如果没有友元函数的声明的话，私有无法调用，但是去掉私有又影响封装，所以要使用友元函数的声明

class Date
{
	// 友元函数的声明
	friend ostream& operator<<(ostream& out, const Date& d);
	friend istream& operator>>(istream& in, Date& d);
private:
	int _year;
	int _month;
	int _day;
};

4.1.1 友元函数快速入门

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。

友元函数可访问类的私有和保护成员，但__不是类的成员函数__

友元函数不能用__const修饰__

友元函数可以在类定义的任何地方声明，不受类访问限定符限制

一个函数可以是多个类的友元函数

友元函数的调用与普通函数的调用和原理相同

4.2 友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。

4.2.1 友元类快速入门

友元关系是单向的，不具有交换性。

class Date; // 前置声明
class Time
{
	friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:

private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
public:

private:
	int _year;
	int _month;
	int _day;
	Time _t;
};

比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。

友元关系不能传递：如果B是A的友元，C是B的友元，则不能说明C时A的友元。

5. 内部类

提到内部类，先回忆一下Java中的几种内部类，Java中内部类使用很多，特别是源码中有很多内部类的使用

5.1 内部类 of Java

内部类的特点就是可以直接访问私有属性，并可以体现类与类之间的包含关系

5.1.1 Java的四种内部类

定义类在局部位置(方法中/代码块)	特点
局部内部类	有类名
匿名内部类	没有类名
定义在成员位置
成员内部类	没用static修饰
静态内部类	有static修饰

5.1.2 局部内部类

局部内部类是定义在外部类的局部位置,比如方法中,并且有类名

5.1.2.1 局部内部类快速入门

可以直接访问外部类的所有成员,包含私有的

不能添加访问修饰符,因为它的地位就是一个局部变量。局部变量是不能使用修饰符的。但是可以使用final修饰,因为局部变量也可以使用final

作用域:仅仅在定义它的方法或代码块中。

局部内部类访问外部类的成员[访问方式:直接访问]

外部类访问局部内部类的成员访问方式:创建对象,再访问(注意:必须在作用域 内)
局部内部类定义在方法中/代码块
作用域在方法体或者代码块中
本质仍然是一个类

外部其他类不能访问局部内部类(因为 局部内部类地位是一个局部变量)

如果外部类和局部内部类的成员重名时,默认遵循就近原则,如果想访问外部类的成员,则可以使用(外部类名.this.成员)去访问

System.out.println("外部类pn2-"+外部类名.this.n2): 

5.1.3 匿名内部类

匿名内部类不说没有名字，是编译器取的，匿名内部类本质是类，是一个内部类，同时该类没有名字，而且还是一个对象，该类定义在外部类的局部位置，一般是方法中，并且没有类名

5.1.3.1 基本语法

5.1.3.2 匿名内部类快速入门

匿名内部类既是一个类的定义,同时它本身也是一个对象,因此从语法上看,它既有定义类的特征,也有创建对象的特征,可以调用匿名内部类方法。

可以直接访问外部类的所有成员,包含私有的

外部其他类不能访问匿名内部类（因为匿名内部类地位是一个局部变量）

不能添加访问修饰符,因为它的地位就是一个局部变量

作用域:仅仅在定义它的方法或代码块中

如果外部类和匿名内部类的成员重名时,匿名内部类访问的话,默认遵循就近原则,如果想访问外部类的成员,则可以使用(外部类名.this.成员)去访问

5.1.4 成员内部类

成员内部类是定义在外部类的成员位置,并且没有static修饰。之前两个必须是在类中的方法中，成员内部类是不需要在方法中，直接作为外部类成员的一部分

5.1.4.1 成员内部类快速入门

可以直接访问外部类的所有成员,包含私有的

可以添加任意访问修饰符(public、protected、default、private),因为它的地位就是一个成员

作用域和外部类的其他成员一样,为整个类体,在外部类的成员方法中创建成员内部类对象,再调用方法

成员内部类访问外部类成员(比如:属性) [访问方式:直接访问]

外部类访问成员内部类[访问方式:创建对象,再访问]

外部其他类访问成员内部类

​ 直接new

outer.new Inner(); 相当于把new Inner()当做是outer 成员

​ 外部类中编写方法返回对象

如果外部类和内部类的成员重名时,内部类访问的话,默认遵循就近原则,如果想访问外部类的成员,则可以使用(外部类名.this.成员)去访问

5.1.5 静态内部类

静态内部类是定义在外部类的成员位置,并且有static修饰

5.1.5.1 静态内部类快速入门

可以直接访问外部类的所有静态成员,包含私有的,但不能直接访问非静态成员

可以添加任意访问修饰符(public、protected、默认、private)，因为它的地位就是一个成员。

作用域：同其他的成员，为整个类体

静态内部类访问外部类（比如：静态属性）[访问方式：直接访问所有静态成员]

外部类访问静态内部类访问方式：创建对象，再访问

外部其他类访问静态内部类

​ 直接通过类名访问（满足访问权限）

Outer.Inner inner = new Outer.Inner();

​ 编写方法返回静态内部类的对象实例

如果外部类和静态内部类的成员重名时，静态内部类访问的时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.成员)去访问

5.2 内部类 of C++

C++内部类用的不是特别多

5.2.1 内部类的概念

内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。

内部类就是外部类的友元类。注意友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

5.2.2 内部类快速入门

内部类可以定义在外部类的public、protected、private都是可以的。

注意内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名。

sizeof(外部类)=外部类，和内部类没有任何关系。

class A
{
private:
	static int k;
	int h;
public:
	class B
	{
	public:
		void foo(const A& a)
		{
			cout << k << endl;//OK
			cout << a.h << endl;//OK
		}
	};
};
int A::k = 1;
int main()
{
	A::B b;
	b.foo(A());
	return 0;
}

类与对象完结，干净又卫生兄弟们