#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); | 局部对象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修饰,则可以修改。