1
00:00:04,290 --> 00:00:05,490
‫你好, 欢迎｡

2
00:00:05,490 --> 00:00:12,810
‫在这节课中, 我们将学习如何获得一个指针, 指向一个组件的所有参与者.

3
00:00:12,810 --> 00:00:16,740
‫我们要找出指针是什么, 内存中有什么地址,

4
00:00:16,740 --> 00:00:19,740
‫我们还要把它们打印到日志消息中｡

5
00:00:19,740 --> 00:00:20,640
‫我们开始吧｡

6
00:00:21,090 --> 00:00:29,130
‫所以让我们花点时间来了解一下编程中关于变量地址的核心概念｡

7
00:00:29,130 --> 00:00:30,810
‫什么是变量的地址？

8
00:00:30,810 --> 00:00:43,920
‫我们把所有变量都存储在内存中, 内存在你电脑上的内存芯片中, 变量需要内存来存储它们的数据｡

9
00:00:43,920 --> 00:00:52,740
‫因此, 浮点数需要32位数据或64位数据, 如果是双整数, 则需要一定量的内存｡

10
00:00:52,740 --> 00:00:58,440
‫而且, 结构体越大, 类也越大,

11
00:00:58,440 --> 00:01:04,230
‫比如参与者可能非常大, 包含大量数据, 每个参与者可能需要几KB的内存, 诸如此类.

12
00:01:04,590 --> 00:01:12,510
‫好吧, 这个记忆必须存在于这个巨大的空白数据领域的某个地方, 也就是你的记忆库｡

13
00:01:12,660 --> 00:01:16,410
‫而这个位置就是我们所说的地址｡

14
00:01:16,410 --> 00:01:18,420
‫那么, 这在实践中是如何工作的呢？

15
00:01:18,420 --> 00:01:21,870
‫好吧, 想象一下我们有这么大一个0和1的区域｡

16
00:01:21,870 --> 00:01:25,140
‫那是你内存上的数据｡

17
00:01:25,320 --> 00:01:32,580
‫那么这个变量和一个名为My actor的actor变量需要在内存中有一个特定的位置,

18
00:01:32,580 --> 00:01:37,110
‫用来存储actor中的数据｡

19
00:01:37,110 --> 00:01:42,300
‫所以这个红色的内存区域可能是我们存储这个特定演员的数据的地方,

20
00:01:42,300 --> 00:01:50,610
‫它有一个通常用二进制或十六进制表示的地址, 实际上就是位置｡

21
00:01:50,610 --> 00:01:59,220
‫如果你开始计算所有的字节, 这里所有的1和0, 实际上, 我们并没有计算单独的1和0｡

22
00:01:59,220 --> 00:02:03,360
‫我们以八为一级数, 但这并不重要｡

23
00:02:03,360 --> 00:02:04,410
‫我们计算字节数｡

24
00:02:04,620 --> 00:02:08,070
‫这基本上就是我们开始的地址｡

25
00:02:08,810 --> 00:02:14,180
‫谈我们的演员, 然后每一种类型都有一定的规模｡

26
00:02:14,180 --> 00:02:18,020
‫因此我们知道演员需要这么多字节的数据｡

27
00:02:18,020 --> 00:02:23,240
‫这就告诉了我们在哪里可以找到关于特定演员的数据｡

28
00:02:23,360 --> 00:02:24,880
‫为什么这很重要？

29
00:02:24,890 --> 00:02:30,680
‫好吧, 让我们来看看在什么情况下我们可能会想采取的演员｡

30
00:02:30,680 --> 00:02:34,340
‫我们希望有两个引用相同数据的变量｡

31
00:02:34,520 --> 00:02:38,240
‫在简单的情况下, 我们只需要复制这个.

32
00:02:38,240 --> 00:02:44,360
‫所以我们有一块内存分配给了my actor变量.

33
00:02:44,510 --> 00:02:52,280
‫我们有另一块内存分配给了一个空变量Your Actor, 我们还没有给它赋值｡

34
00:02:52,550 --> 00:02:59,690
‫然后我们要做的是因为我们希望它们包含相同的数据, 我们只是把一个分配给另一个｡

35
00:02:59,690 --> 00:03:10,400
‫这基本上导致我们只是复制我的演员中的所有数据位, 并将它们放入组成你的演员的所有位中｡

36
00:03:10,730 --> 00:03:17,990
‫因此, 这可能是一个相当昂贵的过程, 因为您的CPU必须检查和评估原始内存中的每一块内存, 并将其放入新的位置,

37
00:03:17,990 --> 00:03:22,680
‫这会占用时间｡

38
00:03:22,700 --> 00:03:25,760
‫现在有一种方法可以解决这个问题, 那就是使用一种叫做指针的东西｡

39
00:03:25,760 --> 00:03:33,530
‫这里, 我们没有存储我的演员的全部, 我们有一个名为我的演员或演员的变量,

40
00:03:33,530 --> 00:03:38,840
‫演员指针, 它不存储整个演员.

41
00:03:38,840 --> 00:03:42,170
‫它只存储你能找到一个表演的地址｡

42
00:03:42,170 --> 00:03:46,580
‫因此, 您可以看到, 实际上存储地址占用的内存要少得多｡

43
00:03:46,580 --> 00:03:54,140
‫然后我们要做的是进入你的参与者, 我们存储我的参与者的地址, 所以它最终指向原始的参与者, 而不是复制数据,

44
00:03:54,140 --> 00:03:59,090
‫因此命名为指针｡

45
00:03:59,240 --> 00:04:01,880
‫这并不是C++中的实际语法｡

46
00:04:01,880 --> 00:04:04,430
‫在C++中, 语法更加精简｡

47
00:04:04,640 --> 00:04:09,650
‫我们说某个东西是指针, 在类型后面加一个星星｡

48
00:04:09,650 --> 00:04:17,660
‫所以一个演员星星意味着这是一个演员指针, 而要得到一个变量的地址, 我们用了一个&符号,

49
00:04:17,660 --> 00:04:25,250
‫我们不会使用太多的地址, 因为在unreal中有很多函数返回指针｡

50
00:04:25,250 --> 00:04:31,160
‫所以我们现在只需要知道如何使用这些指针, 而不是创建它们｡

51
00:04:31,640 --> 00:04:40,070
‫因此, 一个允许我们访问场景中其他对象的函数是get owner｡

52
00:04:40,070 --> 00:04:46,460
‫那么, 为什么当我们有一个组件时, 它是由一个参与者拥有的呢？

53
00:04:46,460 --> 00:04:53,690
‫所以如果我们想让这个组件和我们的参与者对话, 获取它的位置, 设置它的位置, 然后做类似的事情,

54
00:04:53,690 --> 00:04:58,400
‫那么我们需要能够得到一个指向那个参与者的指针｡

55
00:04:58,400 --> 00:05:00,040
‫我们不想复制它｡

56
00:05:00,050 --> 00:05:03,350
‫事实上, 我们不想复制它, 因为我们想改变演员｡

57
00:05:03,350 --> 00:05:07,160
‫如果我们对副本进行更改, 它实际上不会显示在场景中｡

58
00:05:07,280 --> 00:05:13,850
‫所以我们需要能够存储一个变量, 它是一个演员的指针｡

59
00:05:14,330 --> 00:05:19,760
‫正如我们在幻灯片中看到的, 我们这样做的方法是拥有一个A型演员｡

60
00:05:19,760 --> 00:05:28,880
‫但是我们在末尾加了一个星星, 这就告诉我们这里存储的不是一个演员, 这只是一个演员的地址.

61
00:05:29,150 --> 00:05:39,140
‫我们取这个参与者, 调用这个所有者, 然后把它设置为等于调用get owner的结果.

62
00:05:39,140 --> 00:05:46,970
‫因此, get owner是一个actor组件的函数, 它允许您获取所有者指针｡

63
00:05:46,970 --> 00:05:53,690
‫获取一个指向所有者的参与者指针, 在该行的末尾放置一个分号｡

64
00:05:53,690 --> 00:06:01,670
‫我们这里有一个变量, 它存储了拥有这个特定组件的参与者的地址｡

65
00:06:01,670 --> 00:06:07,580
‫所以我想挑战你们, 打印出这个变量的地址｡

66
00:06:07,580 --> 00:06:14,690
‫因此, 使用参与者变量并使用您格式化的百分比, 在日志中指定它｡

67
00:06:14,690 --> 00:06:19,550
‫所以percent实际上意味着你使用的是一个无符号整数｡

68
00:06:19,550 --> 00:06:25,250
‫这意味着一个不能为负的整数, 这是有意义的, 因为当我们讨论在哪里找到内存,

69
00:06:25,730 --> 00:06:31,790
‫然后计算它打印什么, 去玩, 看看日志消息, 看看它打印出来什么时,

70
00:06:31,820 --> 00:06:33,980
‫地址不能为负｡

71
00:06:34,250 --> 00:06:38,000
‫如果你停下来再玩, 不同的游戏之间会发生变化吗？

72
00:06:38,000 --> 00:06:41,900
‫如果移动者在多个参与者上呢？

73
00:06:41,900 --> 00:06:45,680
‫控制台中是否打印出多个不同的地址？

74
00:06:45,710 --> 00:06:48,620
‫暂停视频, 进行一点调查｡

75
00:06:52,030 --> 00:06:52,390
‫好吧, 我会的

76
00:06:52,390 --> 00:06:53,410
‫欢迎回来｡

77
00:06:53,440 --> 00:07:04,380
‫我们看一下圣诞节日志, 我们会写搬家公司, 地址, 冒号, 百分比, 你.

78
00:07:04,510 --> 00:07:07,540
‫这就是指针值的存放位置.

79
00:07:07,930 --> 00:07:10,210
‫然后我们要把真正的指针｡

80
00:07:10,210 --> 00:07:12,430
‫所以我们要把主人带到这里来｡

81
00:07:12,940 --> 00:07:16,360
‫所以它会打印出主人的地址｡

82
00:07:16,450 --> 00:07:19,150
‫让我们进入不真实｡

83
00:07:19,180 --> 00:07:21,910
‫按控制键11.

84
00:07:21,910 --> 00:07:24,610
‫编译完成后, 我们开始播放｡

85
00:07:24,610 --> 00:07:32,300
‫我们看到, 日志消息移动器所有者地址正在通过, 它为我们提供了一个非常大的地址｡

86
00:07:32,320 --> 00:07:36,460
‫如果我停下来再弹一秒钟呢？

87
00:07:36,460 --> 00:07:42,250
‫你可以看到地址有很大的不同,

88
00:07:42,250 --> 00:07:51,850
‫这是因为每次我们点击play, Unreal都会在场景中创建一组全新的演员, 基本上准备好了, 从头开始｡

89
00:07:51,850 --> 00:07:57,220
‫这就是为什么我们每次点击播放时都会看到新的地址位置｡

90
00:07:57,220 --> 00:08:05,320
‫例如, 如果我转到这个支柱, 并在支柱上添加一个移动组件, 然后我们点击播放并向下滚动到日志的底部,

91
00:08:05,320 --> 00:08:08,020
‫会发生什么情况｡

92
00:08:08,020 --> 00:08:15,310
‫你可以看到, 这里有两个不同的地址, 因为有两个不同的参与者,

93
00:08:15,310 --> 00:08:20,890
‫存储在内存中的两个不同的位置｡

94
00:08:20,890 --> 00:08:31,810
‫这是两个地址, 你可以看到这两个地址之间有几兆字节的差异, 这正好告诉你有多少信息被Unreal存储在内存中,

95
00:08:31,810 --> 00:08:38,290
‫也告诉你为什么高效不做太多的拷贝是很重要的｡

96
00:08:38,290 --> 00:08:39,700
‫这节课到此为止｡

97
00:08:39,700 --> 00:08:43,570
‫我们下一节课再见我们会用指针做更多有趣的事情｡