1
00:00:04,350 --> 00:00:05,520
‫你好, 欢迎｡

2
00:00:05,520 --> 00:00:12,630
‫在这节课中, 我们将实现自己的类成员功能, 移动平台和旋转平台｡

3
00:00:12,630 --> 00:00:17,190
‫我们要看看如何让他们接受争论.

4
00:00:17,190 --> 00:00:21,030
‫它将帮助我们整理一下代码｡

5
00:00:21,030 --> 00:00:23,370
‫让我们深入了解一下它是如何工作的｡

6
00:00:24,060 --> 00:00:29,550
‫所以到目前为止, 我们一直在使用已经为我们创建的C++函数｡

7
00:00:29,550 --> 00:00:34,740
‫我们一直在使用TIC V, 在编写其功能方面使用big｡

8
00:00:34,740 --> 00:00:38,130
‫我们还使用了其他人为我们编写的函数｡

9
00:00:38,130 --> 00:00:41,070
‫我们一直在调用它们, 如获取活动位置和获取名称｡

10
00:00:41,280 --> 00:00:49,110
‫现在, 我们如何创建新的自定义函数来帮助组织我们的代码, 并使这些函数保持较小的规模,

11
00:00:49,110 --> 00:00:51,900
‫使所有内容更加清晰？

12
00:00:52,320 --> 00:00:57,990
‫好了, 我们已经有了基本的构建块已经到位接近年底的部分｡

13
00:00:57,990 --> 00:01:00,330
‫我们对C++语法有了更多的了解｡

14
00:01:00,330 --> 00:01:08,400
‫所以我想做的就是在移动平台上创建一个新的函数, 它允许我们只输入,

15
00:01:08,490 --> 00:01:12,600
‫比如说调用移动平台｡

16
00:01:12,870 --> 00:01:14,220
‫我为什么要这么做？

17
00:01:14,220 --> 00:01:22,590
‫因为能够进行像MOVE Platform这样的函数调用, 它确实说明了我们目前正在尝试做什么｡

18
00:01:22,590 --> 00:01:28,440
‫我们在技术领域有很多事情要做,

19
00:01:28,440 --> 00:01:34,500
‫我不太清楚我们为什么要做这些事情, 如果我只是来看一眼, 如果我进入技术领域,

20
00:01:34,590 --> 00:01:42,480
‫看到一个功能是“移动平台”, 那么我突然就有了所有这些事情应该做什么的上下文, 我不需要任何评论来告诉我发生了什么｡

21
00:01:42,480 --> 00:01:48,240
‫当我们把旋转平台的可能性加入到混合中时, 这将特别有用｡

22
00:01:48,810 --> 00:01:52,740
‫那么我们如何定义声明函数呢？

23
00:01:52,740 --> 00:01:56,670
‫声明方面在头文件中完成了｡

24
00:01:56,670 --> 00:02:03,270
‫这就是我们所说的, 对于C++, 我们将有一个函数, 看起来像这样.

25
00:02:03,300 --> 00:02:06,930
‫在C++中, 我们实际上是在定义函数.

26
00:02:06,930 --> 00:02:09,900
‫我们给予它一个主体, 然后用C++精确地告诉它.

27
00:02:09,900 --> 00:02:12,660
‫这就是函数的工作原理｡

28
00:02:13,140 --> 00:02:16,320
‫让我们来看看我们如何做到这一点｡

29
00:02:16,320 --> 00:02:20,070
‫我们已经有了一些函数的例子, 它们发挥了很大的作用｡

30
00:02:20,070 --> 00:02:29,040
‫我们已经有了tick, 这是一个很好的时间点, 让我们看看我们在我们的头文件中的不同部分｡

31
00:02:29,040 --> 00:02:35,190
‫我们这里提到了公共和受保护, 这里又提到了公共｡

32
00:02:35,370 --> 00:02:36,510
‫这是什么意思？

33
00:02:36,510 --> 00:02:43,410
‫这些结尾带有冒号的关键字基本上定义了一个可访问性部分｡

34
00:02:43,410 --> 00:02:46,470
‫这些功能, 可以从哪里访问？

35
00:02:46,650 --> 00:02:51,390
‫我们已经看到了在得到安全正常｡

36
00:02:51,390 --> 00:02:59,880
‫这是一个函数, 我们在一个F向量上调用它, 但我们是从另一个类调用它, 而不是从一个F向量中调用它.

37
00:03:00,150 --> 00:03:05,070
‫所以这意味着这个函数的可访问性需要是公共的｡

38
00:03:05,070 --> 00:03:09,900
‫现在我们暂时把protected放在一边, 因为这里会变得更复杂.

39
00:03:09,900 --> 00:03:14,400
‫但是我们可以使用另一种类型的关键词, 那就是私有｡

40
00:03:14,700 --> 00:03:19,410
‫所以我会在tick后面加上, 我会加上私钥｡

41
00:03:19,410 --> 00:03:24,360
‫请注意, 我没有缩进这些部分, 我们将在最后添加代码｡

42
00:03:24,360 --> 00:03:29,100
‫这意味着接下来的所有内容, 直到下一节, 我在这里输入的下一个关键词,

43
00:03:29,100 --> 00:03:31,710
‫都将是私密的｡

44
00:03:31,710 --> 00:03:38,310
‫所以这意味着我们已经把所有这些变量都取出来了, 嘿, 其他类不允许碰这些变量｡

45
00:03:38,310 --> 00:03:40,380
‫这通常是最好的做法｡

46
00:03:40,380 --> 00:03:44,640
‫我们还没有做到这一点, 因为我不想让事情有点太混乱, 你｡

47
00:03:44,640 --> 00:03:49,350
‫但是类中的变量通常应该是它们自己的事情｡

48
00:03:49,350 --> 00:03:55,980
‫这是面向对象编程的一个核心租户, 我们让类来管理它们自己的变量,

49
00:03:55,980 --> 00:04:02,280
‫并且我们只使用类表示为公共的函数来访问它们｡

50
00:04:03,060 --> 00:04:12,300
‫我们要做的就是在这里添加一些私有函数因为我们不想从类外调用Move Platform之类的函数.

51
00:04:12,300 --> 00:04:16,590
‫我们希望它由我们自己的tick函数来管理｡

52
00:04:16,860 --> 00:04:20,370
‫那么我们如何定义私有函数呢？

53
00:04:20,370 --> 00:04:22,680
‫我们把它放在了私人区域｡

54
00:04:22,680 --> 00:04:24,780
‫我们在这里得到了我们的私有关键字｡

55
00:04:24,780 --> 00:04:31,470
‫我将把它放在变量之后, 我们从返回类型开始｡

56
00:04:31,470 --> 00:04:40,020
‫如果我们的函数没有返回任何东西, 我们就输入void来表示这个函数没有返回｡

57
00:04:40,470 --> 00:04:42,570
‫然后我们给予它一个函数名｡

58
00:04:42,570 --> 00:04:51,180
‫所以我们把平台移到我们想要的位置, 然后给予它一些括号, 表示这是一个函数, 开括号和闭括号, 然后用分号结束这一行,

59
00:04:51,180 --> 00:04:57,330
‫然后说, 好的, 就是这样｡

60
00:04:57,330 --> 00:05:03,180
‫这就是我想在头文件中声明的函数｡

61
00:05:03,260 --> 00:05:08,990
‫这是函数的形状, 这是返回值, 这是它所带的参数, 它的名字,

62
00:05:08,990 --> 00:05:11,670
‫它属于哪个类.

63
00:05:11,690 --> 00:05:16,280
‫现在, 为了给予它一个实际的实现, 我们必须在C++文件中定义它｡

64
00:05:16,280 --> 00:05:17,540
‫我们去那边吧｡

65
00:05:17,780 --> 00:05:23,540
‫在文件的末尾, 就在任何花括号的外面, 这就是我们要做的｡

66
00:05:23,540 --> 00:05:25,670
‫我们再次从返回类型开始｡

67
00:05:25,670 --> 00:05:32,750
‫所以它是空的, 因为我们在C++文件中, 而不是在类的花括号中.

68
00:05:32,750 --> 00:05:42,590
‫我们必须使用作用域解析操作符来表示我们我们正在尝试从移动平台类中定义一个函数｡

69
00:05:42,590 --> 00:05:50,630
‫所以我们输入类的名字, 它是一个移动的平台, 记住前缀是用来表示它是一个演员的｡

70
00:05:51,320 --> 00:05:55,970
‫然后我们使用冒号, 冒号,

71
00:05:55,970 --> 00:06:03,440
‫作用域解析运算符, 然后我们使用我们定义的函数的名称, 即MOVE平台, 然后我们使用与头文件中相同的参数集｡

72
00:06:03,440 --> 00:06:07,970
‫在本例中, 我们有一个空的参数集, 所以我们只有括号｡

73
00:06:08,300 --> 00:06:18,830
‫然后我们在这一行的末尾加上一个左花括号和一个相应的右花括号, 而不是在另一行的末尾加上一个分号｡

74
00:06:18,950 --> 00:06:24,860
‫在这些花括号之间, 我们放了函数的代码, 太棒了.

75
00:06:24,860 --> 00:06:29,750
‫所以我现在要做的是试着说, 好吧, 我们这里有所有这些功能, 事实上,

76
00:06:29,750 --> 00:06:32,330
‫我打算删除评论, 因为我们不再需要它们｡

77
00:06:32,330 --> 00:06:38,150
‫它们是我们用来实现这一点的伪代码, 但现在它有点服务于它的目的｡

78
00:06:38,150 --> 00:06:40,400
‫我们知道代码行在做什么｡

79
00:06:40,520 --> 00:06:51,590
‫我将从TTIC中取出除MOVE平台函数以外的所有内容, 并将其复制粘贴到MOVE平台函数中｡

80
00:06:52,040 --> 00:06:57,800
‫所以这应该是一样的, 因为当我们进入tick时, 我们调用move platform,

81
00:06:57,800 --> 00:06:59,540
‫它只运行同样的代码｡

82
00:06:59,540 --> 00:07:06,950
‫除了现在我们把它捆绑到一个函数中, 这使得我们更容易阅读, 并有可能在未来重用它｡

83
00:07:07,160 --> 00:07:11,390
‫但是如果你这样做了, 你会注意到有一个问题｡

84
00:07:11,900 --> 00:07:21,110
‫我们正在访问Delta time, 但由于它是传递给tick的参数, 因此我们无法再访问该参数｡

85
00:07:21,440 --> 00:07:29,930
‫所以如果我们想得到它, 我们需要在函数中有一个参数｡

86
00:07:29,930 --> 00:07:33,020
‫因此, 当我们定义参数时, 我们必须在两个地方进行｡

87
00:07:33,020 --> 00:07:37,760
‫就像我们定义函数时一样, 我们返回到头文件,

88
00:07:37,760 --> 00:07:40,190
‫并在MOVE平台函数的括号之间｡

89
00:07:40,190 --> 00:07:45,770
‫我们在这里说我们想要什么参数, 这就像定义一个变量｡

90
00:07:45,770 --> 00:07:48,110
‫你需要给予它一个类型和一个名字｡

91
00:07:48,110 --> 00:07:53,000
‫所以我们说它是浮点型的, 我们可以称它为Delta时间.

92
00:07:53,000 --> 00:07:54,320
‫不一定要用同一个名字｡

93
00:07:54,320 --> 00:07:56,870
‫我们可以称之为D｡  T的｡  , 我们可以称之为时间｡

94
00:07:56,870 --> 00:08:04,460
‫但是给它取相同的名字会更容易, 因为对于任何阅读它的人来说, 这里应该传递什么是显而易见的｡

95
00:08:04,460 --> 00:08:09,590
‫然后在C++文件中, 我们需要匹配参数列表｡

96
00:08:09,590 --> 00:08:13,790
‫同样, 你可以通过复制粘贴或键入来完成｡

97
00:08:13,790 --> 00:08:18,350
‫如果你把它打出来, 确保你没有打错, 因为编译器会抱怨｡

98
00:08:18,350 --> 00:08:24,740
‫我们将把一个名为Delta Time的浮点数作为参数传入或定义为移动平台的参数,

99
00:08:24,740 --> 00:08:30,800
‫但实际上我们还没有将它作为参数传入以在tick中移动平台｡

100
00:08:30,800 --> 00:08:33,800
‫你会看到这里有一条红色的曲线｡

101
00:08:33,800 --> 00:08:39,860
‫如果我将鼠标悬停在它上面,

102
00:08:39,860 --> 00:08:46,400
‫它会说函数调用中的参数太少, 因为我已经在头文件中定义了它, 现在在C++中也需要一个float类型的参数｡

103
00:08:46,670 --> 00:08:48,770
‫所以我必须提供那个参数｡

104
00:08:48,770 --> 00:08:58,760
‫我将确保提供的参数和值来自增量时间变量或tick的增量时间参数｡

105
00:08:58,940 --> 00:09:03,950
‫因此, 通过对值进行线程处理,

106
00:09:03,950 --> 00:09:12,830
‫该值将传递到tick, 然后传递到MOVE平台, 并最终在MOVE平台函数的参数中结束, 在该参数中, 它可用于执行MOVE平台功能｡

107
00:09:12,830 --> 00:09:18,950
‫我希望你们创建自己的旋转平台函数, 我们将从TIC调用它｡

108
00:09:18,950 --> 00:09:23,720
‫因此, 您将把它添加到头文件中, 就像我们对MOVE平台函数所做的那样｡

109
00:09:23,720 --> 00:09:26,390
‫我们也要用同样的方法把它添加到C++文件中｡

110
00:09:26,390 --> 00:09:34,190
‫因此, 从我们对这些函数的处理方式中得到提示, 然后从tick函数调用它｡

111
00:09:34,190 --> 00:09:45,980
‫确保传入Delta时间并定义任何参数以允许您传入Delta时间并实现Rotate平台的主体, 以便它注销消息｡

112
00:09:45,980 --> 00:09:51,410
‫它实际上还不会旋转平台, 而是作为占位符,

113
00:09:51,410 --> 00:09:56,360
‫以确保使用我们学过的UI日志打印日志消息｡

114
00:09:56,360 --> 00:09:58,430
‫暂停视频, 开始体验｡

115
00:10:01,720 --> 00:10:02,110
‫好吧, 我会的

116
00:10:02,110 --> 00:10:02,900
‫欢迎回来｡

117
00:10:02,920 --> 00:10:10,030
‫因此, 我们将从头文件开始, 我们将主要做与我们为MOVE平台所做的相同的事情｡

118
00:10:10,030 --> 00:10:14,590
‫我们将把它放在一个私有区域, 这样它就只能在我们的类中访问了｡

119
00:10:14,910 --> 00:10:19,900
‫我会给予它一个void返回类型, 我们会称它为rotate platform｡

120
00:10:19,900 --> 00:10:21,460
‫我们将打开参数列表｡

121
00:10:21,460 --> 00:10:24,550
‫我们将在其中放入一个参数, 浮点型参数.

122
00:10:24,580 --> 00:10:30,940
‫我们称之为Delta时间, 关闭参数, 用分号结束｡

123
00:10:31,150 --> 00:10:36,310
‫现在, 我们在C++文件中所做的大部分工作与在头文件中所做的完全相同｡

124
00:10:36,310 --> 00:10:41,650
‫我将复制这一行, 转到C++文件, 向你们展示不同之处｡

125
00:10:41,650 --> 00:10:50,470
‫所以我会在文件末尾的一个新空行上粘贴它, 然后不同的是在这里我们需要在类名中使用作用域解析操作符.

126
00:10:50,470 --> 00:10:58,120
‫所以我们要有一个移动平台, 结肠, 结肠旋转平台｡

127
00:10:58,210 --> 00:11:01,390
‫然后我们就有了参数列表, 我们不需要在末尾加上分号｡

128
00:11:01,390 --> 00:11:08,140
‫所以去掉分号, 加一行, 然后加大括号, 在两个大括号之间加一行｡

129
00:11:08,620 --> 00:11:12,070
‫我们要做的是打印出一条日志消息｡

130
00:11:12,070 --> 00:11:15,190
‫所以我将输入log并按回车键｡

131
00:11:15,490 --> 00:11:17,560
‫这只是一条简单的显示消息｡

132
00:11:17,560 --> 00:11:24,460
‫在文本中, 我会写上我们平台的名称｡

133
00:11:24,460 --> 00:11:26,800
‫所以是百分制｡

134
00:11:26,800 --> 00:11:32,590
‫然后输入rotating dot, 然后传入名称.

135
00:11:32,590 --> 00:11:37,660
‫现在我们可以把它放到一个变量中, 但是因为这行代码很短, 我只需要输入星星,

136
00:11:37,660 --> 00:11:45,640
‫get name, 然后加上括号, 这样我们实际上就是在调用get name｡

137
00:11:45,640 --> 00:11:48,280
‫这是获取F字符串的表达式｡

138
00:11:48,280 --> 00:11:53,620
‫然后, 我们将转换结果, 并将其放入日志消息中｡

139
00:11:53,890 --> 00:12:01,390
‫所以在我们所有的平台上, 我希望看到旋转被打印出来, 但这只有在我真正调用它的时候才会发生｡

140
00:12:01,390 --> 00:12:09,430
‫那么让我们上到tick函数MOVE平台后就可以添加新行并调用rotate平台｡

141
00:12:09,670 --> 00:12:16,870
‫我们需要看到, 当我打开括号的时候, 它给了我一个提示, 我需要传入一个Delta时间的参数｡

142
00:12:16,870 --> 00:12:21,490
‫所以我们再一次从这里传递Delta时间变量.

143
00:12:21,490 --> 00:12:24,850
‫就像我说的, 这里的名字不一定要一样｡

144
00:12:24,850 --> 00:12:28,720
‫因此, 该增量时间需要与tick内的增量时间匹配｡

145
00:12:28,990 --> 00:12:35,680
‫但是我们可以选择在rotate平台中调用date变量, 在rotate平台中的任何地方, 我们都必须使用date作为参数的名称,

146
00:12:35,680 --> 00:12:41,470
‫参数基本上可以是不同的｡

147
00:12:41,470 --> 00:12:46,870
‫所以, 让我们跳到unreal并点击compile, 因为我们已经对头文件做了一些修改｡

148
00:12:46,870 --> 00:12:52,990
‫编译时间会比我们只修改C++文件时稍长, 一旦编译完成, 我们将继续,

149
00:12:52,990 --> 00:12:57,820
‫点击播放, 打开输出日志｡

150
00:12:57,970 --> 00:13:04,030
‫您可以看到, 我们确实显示了有关每个平台旋转的日志消息｡

151
00:13:04,030 --> 00:13:08,890
‫所以看起来我们的函数在tick中被有效调用了｡

152
00:13:09,010 --> 00:13:09,640
‫好东西｡

153
00:13:09,640 --> 00:13:15,160
‫现在我们了解了如何创建属于类成员的函数｡

154
00:13:15,190 --> 00:13:21,490
‫这是一个非常有用的工具, 可以重用代码, 也可以像Blueprint中那样组织代码｡

155
00:13:21,820 --> 00:13:23,710
‫我们下节课再见｡