静态成员变量
static 关键字声明一个类的静态成员变量，类的静态成员变量的特点：
1️⃣ 所有类的实例中，共享类中的静态成员变量
2️⃣ 类的静态成员变量在没有类的实例的情况下，依然可以访问
3️⃣ 类的静态成员变量并不完全属于类
1
2
3
4
5
6
7
8
9
10
11
12
13
| class T
{
public:
static int count;
int hp;
};
int T::count = 100;
int main()
{
T::cout << 350;
T t1;
}
|
静态成员变量的初始化
1
2
3
4
5
6
| class T
{
inline static int count{};
public:
int hp;
};
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| class T
{
inline static int count{};
public:
int hp;
T()
{
count ++;
}
void GetCount()
{
return count;
}
};
T t4;
int main()
{
T t1, t2, t3;
T t5;
std::cout << t1.GetCount();
}
|
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
| #include <iostream>
class T
{
inline static int count{};
public:
int hp;
T()
{
count ++;
}
void GetCount()
{
return count;
}
~T()
{
count--;
}
};
T t4;
int main()
{
T t1, t2, t3;
T t5;
std::cout << t1.GetCount();
}
|
静态成员常量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| class T
{
public:
const static int count{250};
int hp;
T()
{
count ++;
}
void GetCount()
{
return count;
}
~T()
{
count--;
}
};
|
静态成员函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
class T
{
inline static int count{};
public:
int hp;
static void Test()
{
count ++ ;
}
};
int main()
{
T::Test();
}
|
友元类
友元类是一个可以访问另一个类的私有成员（private）和保护成员（protected）的类。即使是私有或保护成员，友元类也可以直接访问它们，打破了类的封装性（encapsulation）的一部分。友元类的机制为类提供了一种灵活的方式来控制哪些外部类可以访问其私有成员。
友元会破坏类的封装性，没有更好选择的情况下再使用友元，友元咧不是一种平等的关系，你能访问它的私有变量，它不一样能访问你的私有变量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| class T
{
int hp;
int mp;
void GetMP()
{
std::cout << mp;
}
friend void SetHP(T& t1);
};
void SetHP(T& t1)
{
t1.hp = 100;
t1.GetMP();
}
|
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
| #include <iostream>
class T1;
class T
{
int hp;
int mp;
void GetMP()
{
std::cout << mp;
}
friend void SetHP(T& t1, T1& t2);
friend void SetMP(T& t1, T1& t2);
};
class T1
{
int hp;
int mp;
void GetMP()
{
std::cout << mp;
}
friend void SetHP(T& t1, T1& t2);
friend void SetMP(T& t1, T1& t2);
};
void SetMP(T& t1, T1& t2)
{
t1.hp = 100;
t1.GetMP();
}
void SetHP(T& t1, T1 t2)
{
t1.hp = 100;
t1.GetMP();
}
|
嵌套类
1️⃣ 用法
2️⃣ 作用域
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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
| #include <iostream>
class Role
{
int hp;
static void test() {}
public:
static void testx() {}
enum class WeaponLv
{
normal = 0,
high,
rare,
myth
};
Role()
{
Weapon::test1();
}
class Weapon
{
int tt1;
Weapon* ReturnW();
public:
Weapon()
{
testx();
}
static void test1() {}
public:
Weapon()
{
Role role;
role.hp++;
}
short lv;
WeaponLv wlv;
};
int mp;
Weapon leftHands;
};
Role::Weapon* Role::Weapon::ReturnW()
{
return this;
}
int a1;
int main()
{
int x=250;
class T
{
int hp;
int mp;
int count;
void GetHP()
{
a1++;
}
static int GetCount()
{
}
};
T t1;
}
|
访问权限问题：嵌套类可以访问外层类的所有成员 ，外层类仅能访问嵌套类的共有成员
枚举类型也可以放进去，但有个作用域的问题
局部类
定义在函数内的类称为局部类：局部类的定义必须写在类内、 局部类中不允许使用静态成员变量、局部类可以访问全局变量。
静态成员变量不能定义在类里面，定义在外面又受作用域的问题，矛盾
虽然有inline关键字， 但避免那么写 局部类都少用
嵌套类模块化问题
1
2
3
4
5
6
7
8
|
#pragma once
class Role
{
public:
class Skill;
};
|
1
2
3
4
5
6
7
8
9
|
#pragma once
#include "Role.h"
class Role::Skill
{
public:
int hp;
int mp;
};
|
1
2
3
4
5
6
7
8
| #include <iostream>
#include "Role.h"
#include "Skill.h"
int main()
{
}
|
malloc 和 new 的本质区别：malloc仅仅分配内存，new除了分配内存以外还会调用构造函数
free() 没有调用析构函数，delete不进释放内存空间，会调用类的析构函数
从底层理解类
类的自定义函数调用
项目
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
| #include <iostream>
class HPMed
{
public:
int Recover{ 100 };
};
class Role
{
int hp;
int maxHp;
public:
Role()
{
hp = 1000;
maxHp = 3500;
}
void GetHP()
{
std::cout << "HP:" << hp << "\\" << maxHp<<"\n";
}
void EatMed(HPMed& hpMed)
{
hp += hpMed.Recover;
hp = hp > maxHp ? maxHp : hp;
}
};
int main()
{
Role user;
HPMed med;
user.GetHP();
while (1)
{
int a;
std::cin >> a;
user.EatMed(med);
system("cls");
user.GetHP();
}
}
|