Lesson 02 类与对象 (终)

C++:渴望力量吗,少年?


一、初始化列表

  在构造函数中,以一个冒号开始,接着是一个以逗号分隔的数据成员列表,每个"成员变量"后面跟一个放在括号中的初始值或表达式
【注意】
(1)每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)。
(2)类中包含以下成员,必须放在初始化列表位置进行初始化:
    a. 引用成员变量
    b. const成员变量
    c. 没有默认构造函数的自定义类型成员
(3)尽量使用初始化列表初始化,因为不管你是否使用初始化列表,对于自定义类型成员变量, 一定会先使用初始化列表初始化。
(4)成员变量在类中声明次序就是其在初始化列表中的初始化顺序,与其在初始化列表中的先后次序无关。
(下面的代码比较长,是对上述内容的实现)

typedef int DataType;
class Stack
{
public:
	//Stack(size_t capacity)
	//{
	//	cout << "Stack()" << endl;

	//	_array = (DataType*)malloc(sizeof(DataType) * capacity);
	//	if (NULL == _array)
	//	{
	//		perror("malloc申请空间失败!!!");
	//		return;
	//	}

	//	_capacity = capacity;
	//	_size = 0;
	//}

	Stack(size_t capacity)//把上面的代码改成下面这段,这段代码就是初始化列表和函数体的混合使用
		:_array((DataType*)malloc(sizeof(DataType) * capacity))
		,_size(0)
		,_capacity(capacity)
	{
		cout << "Stack()" << endl;
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}

		memset(_array, 0, sizeof(DataType) * _capacity);
	}

	// s1(s)
	Stack(const Stack& s)
	{
		cout << "Stack(Stack& s)" << endl;
		// 深拷贝
		_array = (DataType*)malloc(sizeof(DataType) * s._capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}

		memcpy(_array, s._array, sizeof(DataType) * s._size);
		_size = s._size;
		_capacity = s._capacity;
	}

	Stack& operator=(const Stack& st)
	{
		if (this != &st)
		{
			// ...
		}
		return *this;
	}

	void Push(DataType data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}

	~Stack()
	{
		cout << "~Stack()" << endl;

		free(_array);
		_array = nullptr;
		_size = _capacity = 0;
	}
private:
	// 内置类型
	DataType* _array;
	int _capacity;
	int _size;
};

class MyQueue
{
public:
	MyQueue(int capacity = 10)
		:_st1(capacity)
		,_st2(capacity)
	{}

private:
	Stack _st1;
	Stack _st2;
};

class A
{
public:
	A(int a = 0)
		:_a(a)
	{}
private:
	int _a;
};

class Date
{
public:
	// 初始化列表是每个成员定义的地方,不管你写不写,每个成员都要会在初始化列表定义
	// 编译器对不写在初始化列表的内置类型用随机值初始化,对自定义类型会去调用其默认构造函数(可以在监视窗口看出)
	// 如果在初始化列表已经初始化,并且也在默认构造函数使用了缺省参数,那么以初始化列表的为主
	Date(int year, int month, int day, int& i)//从下面可以看出来初始化列表和在函数体里面赋值可以混合使用
		: _year(year)
		, _month(month)
		,_a(1)
		,_refi(i)
		//,_x(1)     //这句话不能写在下面的函数体,因为const修饰的变量要在定义时初始化
	{
		// 这里已经不算初始化列表了,算赋值
		_day = day;
	}

	void func()
	{
		++_refi;
		++_refi;
	}
private://注意下面的变量全部只是声明,在定义的时候是按照变量声明的顺序走的
	int _year;  
	int _month = 1;
	int _day = 1;
	// C++11支持给缺省值,这个缺省值是给初始化列表的
	// 如果初始化列表没有显式给值,就用这个缺省值
	// 如果显式给值了,就不用这个缺省值

	// 下面的变量必须在定义时初始化
	const int _x = 10;
	int& _refi;
	A _a;
};
 //能用初始化列表就用初始化列表
 //有些场景还是需要初始化列表和函数体混着用
int main()
{
	//MyQueue mq;

	int n = 0;
	Date d1(2023, 7, 28, n);
	d1.func();

	cout << n << endl;

	return 0;
}

二、explicit关键字、匿名对象

1. explicit关键字

  构造函数不仅可以构造与初始化对象,还具有类型转换的作用。用explicit修饰构造函数,将会禁止构造函数的隐式转换。

2. 匿名对象

以上内容在下面的代码中可以得到体现:

class A
{
public:
	explicit A(int i)//explicit关键字可以阻止单/多参数构造函数的隐式类型转换
		//A(int i)
		:_a(i)
	{
		cout << "A(int i)" << endl;
	}

	A(const A& aa)
		:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

class B
{
public:
	B(int b1, int b2)
		//explicit B(int b1, int b2)
		:_b1(b1)
		, _b2(b2)
	{
		cout << "B(int b1, int b2)" << endl;
	}
private:
	int _b1;
	int _b2;
};

struct SeqList
{
public:
	void PushBack(const A& x)
	{
		// ... 扩容
		_a[_size++] = x;
	}

	size_t size() const
	{
		return _size;
	}

	// 读
	const A& operator[](size_t i) const
	{
		assert(i < _size);

		return _a[i];
	}

	// 读/写
	A& operator[](size_t i)
	{
		assert(i < _size);

		return _a[i];
	}

private:
	// C++11
	A* _a = (A*)malloc(sizeof(A) * 10);
	size_t _size = 0;
	size_t _capacity = 0;
};

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

int main()
{
	//A aa1(1);

	//A aa2 = 2;// 单参数构造函数的隐式类型转换
	 正常的步骤是用int类型的2调用A的构造函数生成一个临时对象,再用这个对象去拷贝构造aa2
	 但是一般编译器会再优化,优化为用2直接构造 
	
	//上面的两个语句结果都是等价的,但是实现的过程不一样

	//const A& ref1 = 2;//不加上const就无法编译,因为按照上一条语句,类型转换会先生成临时对象,而临时对象具有常属性,把int类型赋值给常属性属于权限放大

	/*SeqList s;
	A aa3(3);
	s.PushBack(aa3);
    //上面的两个语句也可以被下面更加简洁的语句替代,之所以可以是因为的单参数构造函数的隐式类型转换
	s.PushBack(4);

	double d = 1.1;
	int i = d;//这个语句是对的,但是下面的语句不加上const就是错的,因为类型转换会生成临时对象,临时对象具有常属性,不加上const是权限的放大
	const int& j = d;*/

	// C++11 也支持多参数的隐式类型转换
	B bb1(1, 1);
	B bb2 = { 2, 2 };//注意要用花括号
	const B& ref2 = { 3,3 };

	// 有名对象 特点:生命周期在当前局部域,该语句结束之后还可以使用aa6
	A aa6(6);

	// 匿名对象 特点:生命周期只在这一行
	A(7);//没有其他地方可以使用这个对象,在这里调用完就直接析构了

	SeqList s;

	A aa7(7);
	s.PushBack(aa7);

	s.PushBack(A(8));//匿名对象

	Solution sl;
	sl.Sum_Solution(10);

	Solution().Sum_Solution(100);//匿名对象

	//Date d1(2023, 7, 28);
	//cout << d1;
	//cout << Date(2023, 7, 28);

	return 0;
}

三、static成员

1. 概念

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

2. 特性

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

四、友元

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

1. 友元函数

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

2. 友元类

友元类的所有成员函数都可以是另一个类的友元函数,都可以访问另一个类中的非公有成员
(1)友元关系是单向的,不具有交换性
    比如上述Time类和Date类,在Time类中声明Date类为其友元类,那么可以在Date类中直接访问Time类的私有成员变量,但想在Time类中访问Date类中私有的成员变量则不行。
(2)友元关系不能传递
    如果C是B的友元, B是A的友元,则不能说明C时A的友元。
(3)友元关系不能继承,在继承位置再给大家详细介绍。
下面是友元类的用法,友元函数的用法也是类似的。

class Time
{
	friend class Date;	// 声明日期类为时间类的友元类,则在日期类中就直接访问Time类中的私有成员变量
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;
};

五、内部类

1. 概念

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

2. 特性

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

class A
{
public:
	class B//默认B是A的友元类,所以B里面可以使用A的私有成员,但是反过来是不可以的
	{
	public:
		void FuncB()
		{
			A aa;
			aa._a = 1;
		}
	private:
		int _b;
	};

	void func()
	{
		B bb;
		//bb._b = 1;
	}

private:
	int _a;
};
int main()
{
	cout << sizeof(A) << endl;

	A aa;
	//B bb;//未加 A::
	A::B bb1;//如果内部类B不是public的话,那就不可以这样访问
	return 0;
}

总结

  类与对象的基础知识大概就掌握这些,接下来我们会更加深入地学习并使用它们。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值