类和对象(下)

博主个人主页:不是笨小孩
⏩专栏分类:数据结构与算法 C++ 刷题专栏 C语言
代码仓库:笨小孩的代码库
⏩社区：不是笨小孩
欢迎大家三连关注，一起学习，一起进步！！

初始化列表

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

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

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

初始化列表是每个成员定义的地方。
注意：

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)。
2. 类中包含以下成员，必须放在初始化列表位置进行初始化：

引用成员变量(定义时必须初始化)。
const成员变量(定义时必须初始化))
自定义类型成员(且该类没有默认构造函数时)

3. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。
4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。

explicit关键字

使用该关键字修饰构造函数可以禁止构造函数进行隐式类型转换。
构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用。

比如：

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

	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d(1,2,3);
	Date d1 = d;

	Date d2 = {1,2,3};

}

d1和d2是一样的，只不过d2是发生了隐式类型转换，会先用1,2，3先构造一个Date，再拷贝构造给d2.但是加上explicit关键字d2就无法构成就会报错。

static成员

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

class A
{
private:
	//声明静态成员变量
	static int x;
	static int n;
};
//定义静态成员变量
int A::x = 0; 
int A::n = 0;

特性：

1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员(因为它没有this指针)。
5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

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

不可以，因为它没有this指针

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

可以的，因为静态成员函数是属于整个类的。

友元

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

友元函数

如果我们在类外面有一个函数，需要访问某个类的成员，但是这个类的成员是私有的，我们无法访问，这时就可以使用友元。
友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。

现在我们假设有一个日期类，我们需要实现日期类的cout和cin的输入和输出，我们还需要保证cout和cin在前面，和我们平时使用的一样，所以就不能在类里面实现，因为在类里面实现第一个参数永远是this指针，我们无法更改，所以必须在类外面实现，这是就面临一个问题，我们无法访问类的内部成员，这时候就可以使用友元函数。

class Date
{
	friend istream& operator>>(istream& in, Date& d);
	friend ostream& operator<<(ostream& out, const Date& d);

public:
	 Date(int year = 1, int month = 1, int day =1)
		: _year(year)
		, _month(month)
		, _day(day)
	{

	}

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

istream& operator>>(istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << d._month << d._day;
	return out;
}

int main()
{
	Date d;
	cin >> d;
	cout << d;
	return 0;
}

注意：

1. 友元函数可访问类的私有和保护成员，但不是类的成员函数。
2. 友元函数不能用const修饰(在类里面const是修饰this指针的，但是友元函数没有this指针)。
3. 友元函数可以在类定义的任何地方声明，不受类访问限定符限制。
4. 一个函数可以是多个类的友元函数。
5. 友元函数的调用与普通函数的调用原理相同。

友元类

1. 友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
2. 友元关系是单向的，不具有交换性。
   比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
3. 友元关系不能传递
   如果C是B的友元， B是A的友元，则不能说明C时A的友元。
4. 友元关系不能继承

class A
{
	friend class B;
private:
	int x;
	int y;
};

//B是A的友元，B可以访问A的成员，但是A不可以访问B的成员。

class B
{
public:

	void print()
	{
		cout << x.x << x.y;
	}

private:
	int m;
	int n;
	A x;
};

内部类

如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，
它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
注意：内部类就是外部类的友元类，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

class A
{
	//B是内部类
	class B
	{
	public:
		void print(const A& a)
		{
			cout << a.x << a.y << endl;
		}
	};
private:
	int x;
	int y;
};

特性：

1. 内部类可以定义在外部类的public、protected、private都是可以的。
2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
3. sizeof(外部类)=外部类，和内部类没有任何关系。

接下来讲一个内部类和静态成员的实用场景
JZ64 求1+2+3+…+n

这个题不让使用循环还有条件判断等，也就是说常规思路肯定都行不通的。这时，我们构造函数和静态成员变量的魅力就来了。我们可以创造一个类来计算前N项和，我们定义n个这个类的对象就要执行n次构造函数，就相当于循环了n次，然后我们定义两个静态成员变量，一个记录和，一个从1走到n，就可以完成前n项和。
由于我们创建的类不想让别人使用，为了防止别人破坏，影响我们计算，我们可以定义私有的内部类。

class Solution {
    class sum
    {
     public:
        sum()
        {
            sum1 += i;
            i++;
        }
        static int Getsum1()
        {
            return sum1;
        }
    private:
        static int sum1;
        static int i;
    };
public:
    int Sum_Solution(int n) 
    {
        sum s[n];

        return sum::Getsum1();
    }
};
int Solution::sum::sum1 = 0;
int Solution::sum::i = 1;

匿名对象

匿名对象就是没有名字的对象，它的声明周期只在它定义的那一行。

class A
{
private:
	int x;
	int y;
};

int main()
{
	//匿名对象
	A();
	return 0;
}

匿名对象用起来会很方便。比如说我们需要调用该类的一个函数时，我们还要在创建一个对象，有了匿名对象我们就可以直接使用匿名对象。

class A
{
public:
	void print()
	{}
private:
	int x;
	int y;
};

int main()
{
	A().print();
	return 0;
}

还有一点，就是用匿名对象传参，如果传引用的话，会延长匿名对象的生命周期，也可以理解为匿名对象有了名字，它的生命周期就和新的名字的生命周期是一样的。

今天的分享就到这里感谢大家的关注和支持。