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

一、再谈构造函数

【构造函数体赋值】

1）初始化：一个变量或者一个对象在产生的时候就赋予一个值，属于伴随性质

2）赋值：在一个变量或者一个对象在产生之后的任意时刻赋予一个值，属于任意性质

class Date
{
public:
	//构造函数
	Date(int year = 2022, int month = 4, int day = 19)
	{
		_year = year;
		_month = month;
		_day = day;
        _year = 2023;//构造函数体内允许对成员变量进行多次赋值
	}
 
private:
	int _year;
	int _month;
	int _day;
};

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

1.1 初始化列表

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

【注意】

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

2.1 引用成员变量

2.2 const成员变量

2.3 自定义类型成员(且该类没有默认构造函数时)

都不能先定义后初始化。

class MyQueue
{
public:
	// Stack不具备默认构造。MyQueue也无法生成默认构造
	// 初始化列表
	// 初始化列表本质可以理解为每个对象中成员定义的地方
	MyQueue(int n,int& rr)
		:_push(n)
		,_pop(n)
		,_size(0)
		,_x(1)
		,_ref(rr)
	{}
private:
	// 声明
    // 缺省值是给初始化列表使用的
	int _size = 0;
	// 必须在定义时初始化
    Stack _push;
	Stack _pop;
	const int _x;//const int _x = 10;不要误理解这个地方只是声明！！！
	int& _ref;
};
int main()
{
	int xx = 10;
	// 定义
	MyQueue q1(10,xx);
	return 0;
}

它们在初始化列表内定义，并且必须在定义时就初始化，因此必须在初始化列表内初始化。

3.初始化列表，不管你写不写，每个成员变量都会先走一遍（可以自己调试一下）

3.1自定义类型的成员会调用默认构造(没有默认构造就编译报错)

3.2内置类型有缺省值用缺省值，没有的话，不确定看编译器，有的编译器会处理，有的不会处理

4.先走初始化列表 + 再走函数体(MyQueue内部{})

实践中:尽可能使用初始化列表初始化，不方便（就比如@地方），再使用函数体初始化

class MyQueue
{
public:
	//   @
	MyQueue()
		:_ptr((int*)malloc(40))
	{
		//所有的字节初始化为0
		memset(_ptr, 0, 40);
	}
private:
	int* _ptr;
};

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

先走_a2，再走_a1

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

先走_a1，再走_a2

class A
{
public:
	A(int a)
		:_a1(a)
		,_a2(_a1)
	{}
	void Print() {
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a1;
	int _a2;
};
int main() {
	A aa(1);
	aa.Print();
}

1.2 隐式类型转换

【单参数构造】

class A
{
public:
	A(int a)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	A(const A& a)
		:_a(a._a)
	{
		cout << "A(const A& a)" << endl;
	}
private:
	int _a;
};

在main函数中

	// 构造
	A aa1(1);
	// 拷贝构造
	A aa2 = aa1;

下面就是隐式类型转换，内置类型转换为自定义类型，3构造一个A的临时对象，在用这个临时对象拷贝构造aa3，编译器遇到连续构造+拷贝构造--->优化为直接构造。隐式类型转换跟我在C++入门当中的常引用那一篇文章中很类似。

A aa3 = 3;

raa引用的是类型转换中用3构造的临时变量，只发生3构造一个A的临时对象

const A& raa = 3;

如果不想发生隐式类型转换------>explicit 修饰构造函数 ,禁止类型转换---explicit去掉之后，代码可以通过编译

如果在构造函数中添加explicit修饰

【多参数构造】

class A
{
public:
	A(int a1, int a2)
		:_a(0)
		,_a1(a1)
		,_a2(a2)
	{}
	A(const A& a)
		:_a(a._a)
		,_a1(a._a1)
		,_a2(a._a2)
	{}
private:
	int _a;
	int _a1;
	int _a2;
};

main函数

	A aaa1(1, 2);
	A aaa2 = { 1,2 };
	const A& aaa3 = {1,2};

与单参数区别就是需要用 { }括起来

class Stack
{
public:
	void Push(const A& aa)
	{
		//...
	}

	//...
};

main函数

	Stack st;
	st.Push({ 1,2 });

{1, 2}先传给aa ，再构造临时变量，最后调用Push

二、static成员

我在C语言那里提到过static修饰变量，函数的的生命周期以及内部属性外部链接属性

http://t.csdnimg.cn/WujM2

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

对象中只包括成员变量，不包括静态成员变量

在某类中，例如：

private:
	int _a1;
	int _a2;
	static int _scount;

这个对象大小是8个字节

那在思考

静态成员变量能给缺省值吗？

不能 ---- 缺省值是给初始化列表使用而静态成员变量在静态区，不走初始化列表

2.1 特性

static修饰成员变量

静态数据成员属于整个类，而不属于某个对象，所有对象共享静态数据成员

静态成员变量必须在类外定义 ，定义时不添加static关键字，类中只是声明

类静态成员即可用类名::静态成员或者对象.静态成员来访问

静态成员也是类的成员，受public、protected、private 访问限定符的限制

class A 
{
public:
	static int _a;
private:
	static int _b;
};
//定义
int A::_a = 1; // 2特性
int A::_b = 1;
int main()
{
	A aa1;
	cout << A::_a << endl;// 3
	cout << aa1._a << endl;// 3
	A aa2;
	aa2._a = 2;// 1
	cout << aa1._a << endl;
	cout << aa2._a << endl;// 1
	return 0;
}

static修饰成员函数

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

非static成员函数**既可以访问static数据成员，也可以访问非static数据成员。**static成员函数只能访问satic成员

class A 
{
public:
	static int _a;
	static int GetA()
	{
		//_c = 1;//不能访问
		return _b; // 1
	}
	void func()
	{
		_c = 1;
		_b++; // 2
	}
private:
	static int _b;
	int _c;
};
//定义
int A::_a = 1;
int A::_b = 1;
int main()
{
	A aa1;
	cout << A::_a << endl;
	cout << aa1._a << endl;
	A aa2;
	aa2._a = 2;
	cout << aa1._a << endl;
	cout << aa2._a << endl;
	return 0;
}

我们在修改一下，验证一下 static修饰成员变量特性，4

class A 
{
public:
	static int _a;
	static int GetA()
	{
		//_c = 1;
		return _b;
	}
	void func()
	{
		_b++;
	}
private:
	static int _b;
};
//定义
int A::_a = 1;
int A::_b = 100;
int main()
{
	A aa2;
	cout << aa2.GetA() << endl;
	return 0;
}

上面的代码解释了，静态成员也受访问限定符的限制，A类中public static int _a可以通过类名::静态成员或者对象.静态成员来访问，而私有的只能调用static成员函数

三、友元

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

3.1 友元函数

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

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

友元函数不能用const修饰

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

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

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

class Date
{
	friend ostream& operator<<(ostream& _cout, const Date& d);
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "-" << d._month << "-" << d._day;
	return _cout;
}

3.2 友元类

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

class A
{
	//声明 B是A的友元
	// B可以访问A的私有，但是A不能访问B的私有
	friend class B;
private:
	int _a;
	int _b;
};
class B
{
	void Print()
	{
		_bb._a = _c;
		_bb._b = _d;
	}
private:
	int _c;
	int _d;
	A _bb;
};

四、内部类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员 。外部类对内部类没有 任何优越的访问权限。

class A
{
private:
	static int k;
	int h;
public:
	class B // B天生就是A的友元
	{
	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改为私有，就不能访问内部类
	b.foo(A());
	return 0;
}

五、匿名对象

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a = 0)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
int main()
{
	//有名对象，生命周期当前作用域
	A aa1;
	//匿名对象，生命周期只在当前一行
	A(2);
	A aa2;
	return 0;
}