C++类和对象知识点整理2

#include<iostream>
using namespace std;
class Test
{
public:
	Test(int a = 5) :ma(a) 
	{
		cout << "Test(int)" << endl;
	}
	~Test()
	{
		cout << "~Test():t" <<ma<< endl;
	}
	Test(const Test &src) :ma(src.ma)
	{
		cout << "Test(const Test&)" << endl;
	}
	void operator=(const Test &src)
	{
		ma = src.ma;
		cout << "operator=" << endl;
	}
	int GetValue()
	{
		return ma;
	}
private:
	int ma;
};

Test GetTestPbject(Test &t)
{
	int value = t.GetValue();
	Test tmp(value);
	cout << "--------以上是tmp构造-------" << endl;
	return tmp;
}

int main()
{
	//第4题：
	/*Test t1(20);
	Test t2;
	cout << "--------以上为构造----------" << endl;
	t2 = GetTestPbject(t1);
	cout << "------------------" << endl;
	cout << t2.GetValue() << endl;
	cout << "---------以下为析构---------" << endl;*/

	//第5题(1)：
	//A.错
	
	/*int a = 10;
	const int *p = &a;
	int *q = p;*/  范围扩大

	
	//B.
	/*int a = 10;
	int *const p = &a;
	int *q = p;*/
	//C.
	/*
	int a = 10;
	int *const p = &a;
	int *const q = p;
	*/
	//D.
	/*int a = 10;
	int *const p = &a;
	const int *q = p;*/

	//第5题(2)：
	//A.
	/*int a = 10;
	int *p = &a;
	int *&q = p;*/

	//B.错
	/*int a = 10;
	int *const p = &a;
	int *&q = p; */ //范围扩大

	//C.错
	/*int a = 10;
	const int *p = &a;
	int *&q = p;*/   //范围扩大
	//D.错
	/*int a = 10;
	int *p = &a;
	const int * &q = p; */   // const int** =int **不行

	//第5题(3)：
	//A.错
	/*int a = 10;
	int b = 20;
	int *p = &a;
	const int **q = &p;*/   // const int** =int **不行
	

	//B.
	/*int a = 10;
	int *p = &a;
	int *const*q = &p;*/
	//C.
	/*int a = 10;
	int *p = &a;
	int **const q = &p;*/

	//D.错
	/*int a = 10;
	int *const p = &a;
	int **q = &p;*/   //范围扩大

	//E.错
	/*int a = 10;
	const int *p = &a;
	int *const* q = &p;*/  //范围扩大



	return 0;
}

第4题答案：

序号	输出结果	对应指令	生成对象性质	生存周期	解释说明
1	Test(int)	Test t1(20); 扫描二维码关注公众号，回复： 4251002 查看本文章	局部对象t1	函数结束后	t1的构造函数
2	Test(int)	Test t2;	局部对象t2	函数结束后	t2的构造函数
3	Test(int)	Test tmp(val);	局部对象tmp	对象所在函数结束后	tmp的构造函数
4	Test(const Test&)	return tmp;	把tmp拷贝构造给临时对象1	临时对象所在语句执行完	return时的拷贝构造函数
5	~Test()				局部对象tmp的析构
6	operator=	t2 = GetTestPbject(t1);
7	~Test()				临时对象1的析构
8	~Test()				t2的析构
9	~Test()				t1的析构

第6题：请解释explicit，volatile，mutable三个关键字。

1.explicit关键字

防止隐式生成临时对象。

2.volatile关键字

volatile是类型修饰符（一致性、原则性、可见性） 
2.1 防止多线程对共享变量进行缓存，保证各线程实时从内存中读取变量值； 
2.2 防止编译器对指令顺序进行调整。 

3.mutable关键字

在C++类中，如果一个成员函数被const修饰（常方法），那么它将无法修改其他成员变量。但是，如果这个变量被mutable修饰，则可以修改。