#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修饰,则可以修改。