1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
class
A
{
public
:
A ():m_iVal(0){test();}
virtual
void
func() { std::cout<<m_iVal<<‘ ’;}
void
test(){func();}
public
:
int
m_iVal;
};
class
B :
public
A
{
public
:
B(){test();}
virtual
void
func()
{
++m_iVal;
std::cout<<m_iVal<<‘ ’;
}
};
int
main(
int
argc ,
char
* argv[])
{
A*p =
new
B;
p->test();
return
0;
}
|
A.1 0
B.0 1
C.0 1 2
D.2 1 0
E.不可预期
F.以上都不对
1.C++继承体系中构造函数的调用顺序。
2.构造函数中调用虚函数问题。
C++继承体系中,初始化时构造函数的调用顺序如下
(1)任何虚拟基类的构造函数按照他们被继承的顺序构造
(2)任何非虚拟基类的构造函数按照他们被继承的顺序构造
(3)任何成员对象的函数按照他们声明的顺序构造
(4)类自己的构造函数
据此可知 A*p = newB;先调用A类的构造函数再调用B类的构造函数。
构造函数中调用虚函数,虚函数表现为该类中虚函数的行为,
1
2
3
4
5
6
7
8
9
10
|
struct
One{
double
d;
char
c;
int
i;
}
struct
Two{
char
c;
double
d;
int
i;
}
|
1
2
|
Class A *pclassa=
new
ClassA[5];
delete
pclassa;
|
deletepclassa; 析构一次,delete[]pclassa 这样就析构5次
这边考察delete和delete[] 的区别。
A.对于unordered_map和map这两个容器,迭代器的有效性皆不受删除操作影响
B.对于unordered_map和map这两个容器,迭代器的有效性皆不受插入操作影响
C.为了保证代码的异常安全性,应该避免在构造函数中抛异常D.为了保证代码的异常安全性,应该避免在析构函数中抛异常
A选项:当unorder_map和map某迭代器it指向的元素被删除时,只有该迭代器it失效,其他的迭代器不会失效。
B选项:map插入时不会引起迭代器失效;unorder_map插入时一般情况下不会引起迭代器失效,只有当容器增长到需要rehash时,原来的所有迭代器失效。
C选项:构造函数抛出异常后,已经构造的成员对象会被逆序析构,申请的内存资源会被系统释放,不会调用析构函数。而且构造函数抛出异常是唯一表明构造失败的方法。
D选项:effective C++“条款08:别让异常逃离析构函数”指出来如果析构函数抛出异常,对于vector<Widget>这样的一个对象数组,如果第一个Widget析构有异常抛出,这时候还要销毁数组中剩下的Widget否则会造成内存泄漏,但是如果剩下的Widget析构时也抛出异常,就会两个异常同时存在,程序如果不是结束执行就会产生不明确行为。即使不是使用容器或数组,在析构函数中抛出异常也可能导致程序过早结束或不明确行为。
5.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
#include <iostream>
using
namespace
std;
class
A{
int
a1;
protected
:
int
a2;
public
:
int
a3;
};
class
B:
public
A{
int
b1;
protected
:
int
b2;
public
:
int
b3;
};
class
C:
private
B{
int
c1;
protected
:
int
c2;
public
:
int
c3;
};
int
main(){
B obb;
C obc;
cout<<obb.a1;
//1
cout<<obb.a2;
//2
cout<<obb.a3;
//3
cout<<obc.b1;
//4
cout<<obc.b2;
//5
cout<<obc.b3;
//6
cout<<obc.c3;
//7
return
0;
}
|
-
1,2
-
2,5,7
-
3,4,7
-
4,5,6
解析:
类的继承后方法属性变化:
private 属性不能够被继承。
使用private继承,父类的protected和public属性在子类中变为private;
使用protected继承,父类的protected和public属性在子类中变为protected;
使用public继承,父类中的protected和public属性不发生改变;
private, public, protected 访问标号的访问范围:
private:只能由1.该类中的函数、2.其友元函数访问。
不能被任何其他访问,该类的对象也不能访问。
protected:可以被1.该类中的函数、2.子类的函数、以及3.其友元函数访问。
但不能被该类的对象访问。
public:可以被1.该类中的函数、2.子类的函数、3.其友元函数访问,也可以由4.该类的对象访问。
注:友元函数包括3种:设为友元的普通的非成员函数;设为友元的其他类的成员函数;设为友元类中的所有成员函数。
1
2
3
4
5
|
cout<<obb.a1;
//1 a1是A私有的
cout<<obb.a2;
//2 a2是A开放给派生类使用的,客户代码不能使用
cout<<obc.b1;
//4 C是私有继承于B,不能使用B的成员
cout<<obc.b2;
//5 同上
cout<<obc.b3;
//6 同上
|