一、情况一

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#include<iostream>
using namespace std;
template<class _Ty>
class Base
{
private:
_Ty val;
public:
Base(_Ty x = _Ty()): val(x)
{
}
public:
static int num;
};

template<class _Ty>
int Base<_Ty>::num = 0;

class Son1 : public Base<int>
{
public:
Son1(): Base()
{
num +=1;
}
void PrintNum()const
{
cout << num << endl;
}
};
class Son2 : public Base<int>
{
public:
Son2(): Base()
{
num +=1;
}
void PrintNum()const
{
cout << num << endl;
}
};

int main()
{
Son1 s1, s2;
Son2 c1, c2;

s2.PrintNum();
c2.PrintNum();
return 0;
}

分析:
由于Son1和Son2两个派生类都继承的是代码推演的Base类(只有一份,num只有一个); 因此两个派生类的构造函数对基类中静态num进行+1时,构建四个对象,加了4次。结果是4,4
结果:
在这里插入图片描述


二、情况二

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#include<iostream>
using namespace std;
template<class _Ty>
class Base
{
private:
_Ty val;
public:
Base(_Ty x = _Ty()): val(x)
{
}
public:
static int num;
};

template<class _Ty>
int Base<_Ty>::num = 0;

class Son1 : public Base<int>
{
public:
Son1(): Base()
{
num +=1;
}
void PrintNum()const
{
cout << num << endl;
}
};
class Son2 : public Base<char>
{
public:
Son2(): Base()
{
num +=1;
}
void PrintNum()const
{
cout << num << endl;
}
};

int main()
{
Son1 s1, s2;
Son2 c1, c2;

s2.PrintNum();
c2.PrintNum();
return 0;
}

分析:
由于Son1继承Base类;Son1构造函数对Base::num进行+1时,构建两个对象,加了2次。结果是2
同理Son2继承Base类;Son2构造函数对Base::num进行+1时,构建两个对象,加了2次。结果是2
结果:
在这里插入图片描述