1
00:00:04,410 --> 00:00:05,370
‫你好, 欢迎｡

2
00:00:05,370 --> 00:00:10,350
‫在这节课中, 我们将学习一种奇怪的现象, 叫做输出参数｡

3
00:00:10,350 --> 00:00:18,240
‫这是一个参数, 在C++中, 我们倾向于将值从函数中传递出来, 而不是将值传入｡

4
00:00:18,330 --> 00:00:25,620
‫我们还将学习常量引用, 以及这两个概念是如何相互交织在一起的｡

5
00:00:25,650 --> 00:00:27,900
‫让我们一起来解决这个问题吧｡

6
00:00:28,850 --> 00:00:29,180
‫现在就去

7
00:00:29,180 --> 00:00:36,980
‫引用的真实的地方是函数的参数,

8
00:00:36,980 --> 00:00:49,580
‫因为每次我们在技术组件中创建这样的浮点增量时间时, 我们所做的就是复制原始浮点数并将其传递给函数｡

9
00:00:49,580 --> 00:00:56,000
‫所以我们不应该这么做, 我们应该做的是取一个对它的引用, 然后把它传递进去.

10
00:00:56,090 --> 00:01:03,020
‫让我们想象一下, 我们要创造一个引力函数, 叫做指纹损伤｡

11
00:01:03,020 --> 00:01:09,360
‫作为这个函数的一个参数, 我们要传入一个浮点损坏.

12
00:01:09,380 --> 00:01:14,780
‫现在, 正如我所说的, 这将复制我们传递进来的任何东西, 并将其复制到那个变量中｡

13
00:01:14,780 --> 00:01:18,980
‫在打印损坏函数中创建此参数变量｡

14
00:01:19,930 --> 00:01:24,610
‫我们还需要一个void的返回值, 在结尾用分号来完成｡

15
00:01:24,640 --> 00:01:28,630
‫让我们转到C++继续这个对话｡

16
00:01:28,630 --> 00:01:31,030
‫让我们在这里制造指纹破坏｡

17
00:01:31,300 --> 00:01:39,490
‫让我们把你抓一个类放在它前面, 让我们用大括号代替分号｡

18
00:01:39,670 --> 00:01:48,340
‫所以我们有一个damage参数变量的副本, 它是安全的, 因为如果damage等于5, 我只在print

19
00:01:48,340 --> 00:01:53,980
‫damage中改变这个变量｡

20
00:01:53,980 --> 00:01:55,600
‫我自己也有一份｡

21
00:01:55,600 --> 00:01:58,160
‫我不能因为意外而搞砸｡

22
00:01:58,180 --> 00:02:01,460
‫如果我不想复制呢？

23
00:02:01,480 --> 00:02:04,530
‫我的另一个选择是接受推荐｡

24
00:02:04,540 --> 00:02:10,840
‫所以我可以在这里把一个float引用放到print damage中,

25
00:02:10,840 --> 00:02:14,500
‫我还需要在C++文件中更新它.

26
00:02:14,650 --> 00:02:20,440
‫然后, 我可能会看到我们正在使用引用的日志消息, 让我们将其删除,

27
00:02:20,440 --> 00:02:22,690
‫并将其放入打印损坏中｡

28
00:02:22,690 --> 00:02:25,360
‫所以现在我们把损坏的东西打印出来｡

29
00:02:25,360 --> 00:02:33,490
‫Outlets会更新日志语句, 说明damage is this, 所以damage

30
00:02:33,490 --> 00:02:41,470
‫this damage, 在tick组件中, 我们可以打印damage, 传入damage变量,

31
00:02:41,470 --> 00:02:49,360
‫并在末尾添加分号, 我们可以暂时删除damage引用, 因为我们现在要做的是damage float｡

32
00:02:49,480 --> 00:02:51,040
‫它是在TTIC中创建的｡

33
00:02:51,070 --> 00:03:00,100
‫这里已经创建了用于此操作的存储器, 并勾选, 然后我们将其传递给此打印损坏函数｡

34
00:03:00,100 --> 00:03:06,670
‫但是因为参数是一个引用, 所以我们实际上并没有复制这个损坏｡

35
00:03:06,670 --> 00:03:13,330
‫我们取它的地址并将其存储在引用中, 这样当我们使用这个引用时,

36
00:03:13,330 --> 00:03:18,160
‫我们实际上是在访问原始的内存块｡

37
00:03:18,160 --> 00:03:21,970
‫因此, 没有复制必须发生这打印损坏｡

38
00:03:21,970 --> 00:03:25,270
‫现在让我们检查一下它是否真的在做我们期望它做的事情｡

39
00:03:25,270 --> 00:03:35,500
‫例如, 如果我将损坏值更改为5, 然后重新编译并单击播放, 然后查看输出日志｡

40
00:03:35,500 --> 00:03:38,590
‫的确, 得到的印相所受的伤害是五级｡

41
00:03:38,590 --> 00:03:42,910
‫但是因为我们有一个引用, 所以我们知道我们可以更新该值｡

42
00:03:42,910 --> 00:03:49,990
‫所以我能做的就是在这个函数中, 我能做的是, 损伤应该等于2.

43
00:03:50,230 --> 00:03:55,510
‫如果我不小心, 如果我以为我有自己的副本, 我可能会认为这是好的｡

44
00:03:55,510 --> 00:04:01,510
‫但实际上在tick部分, 我们所做的是改变原始变量｡

45
00:04:01,520 --> 00:04:09,640
‫如果我在这里放一个新的日志来检查原始的损坏变量, 我们在这里放一个百分比F并传递损坏, 让我们实时编码, 编译它,

46
00:04:09,640 --> 00:04:17,230
‫然后我们点击播放, 看看我们的输出日志｡

47
00:04:17,230 --> 00:04:22,990
‫你可以看到现在损坏和原始损坏都被修改了｡

48
00:04:22,990 --> 00:04:27,490
‫他们都被改成了二号, 这不太好｡

49
00:04:27,490 --> 00:04:33,130
‫你知道, 你可能会不小心造成很大的伤害, 如果你能原谅这个双关语的话,

50
00:04:33,130 --> 00:04:35,770
‫通过改变你不希望改变的变量｡

51
00:04:35,920 --> 00:04:41,380
‫这里又出现了一个我们在过去见过的常量关键字的用法｡

52
00:04:41,530 --> 00:04:52,570
‫如果我把const放在float引用的前面, 那么我在这里要说的是, 这应该是一个你不能改变的引用.

53
00:04:52,570 --> 00:04:56,440
‫你不能调用任何非接触功能, 你不能设置它｡

54
00:04:56,440 --> 00:05:00,430
‫您不能以任何方式更改此变量的内容｡

55
00:05:00,430 --> 00:05:04,420
‫你只能使用它, 你只能阅读它, 你只能看到里面有什么｡

56
00:05:04,420 --> 00:05:10,570
‫因此, 如果我们返回到CPP的抓取, 我们需要确保在参数中也放置了Const,

57
00:05:10,570 --> 00:05:17,230
‫然后我们可以继续进行编译, 您会看到我们得到一个构建失败, 错误消息是无法分配损坏,

58
00:05:17,230 --> 00:05:22,090
‫因为它是一个常量变量｡

59
00:05:22,090 --> 00:05:25,240
‫所以这给了我们所需要的保护｡

60
00:05:25,240 --> 00:05:32,950
‫所以一般来说, 如果我们试图传递一个变量, 以一种高效的方式, 我们不想复制一个变量,

61
00:05:32,950 --> 00:05:38,950
‫那么我们总是, 总是使用contact关键字, 以及使用一个引用,

62
00:05:38,950 --> 00:05:43,900
‫因为这可以防止我们意外地改变内容｡

63
00:05:44,200 --> 00:05:53,380
‫然而, 有时候你确实想用它来改变这个值, 比如,

64
00:05:53,380 --> 00:06:03,190
‫我们可能有一个布尔返回值, 我们可能想说有损坏, 但我们也可能, 就像我们过去在蓝图中做的那样,

65
00:06:03,190 --> 00:06:06,610
‫想有第二个返回值｡

66
00:06:06,610 --> 00:06:10,810
‫所以我们可能会问, 我们怎么会有任何损害, 损害是什么？

67
00:06:10,810 --> 00:06:19,240
‫在这种情况下, 使用一个简单的非常数引用, 一个对的浮点引用, 实际上是有意义的｡

68
00:06:19,620 --> 00:06:26,640
‫损伤, 通常我们会称之为out damage, 只是为了让它真正可见,

69
00:06:26,640 --> 00:06:29,330
‫这是一个out参数｡

70
00:06:29,340 --> 00:06:31,150
‫它不是一个传递信息的参数｡

71
00:06:31,170 --> 00:06:33,520
‫这是一个传递信息的参数｡

72
00:06:33,540 --> 00:06:38,400
‫现在, 它可能是C++的一个奇怪的怪癖, 它可能很难被发现｡

73
00:06:38,400 --> 00:06:44,460
‫但一般来说,

74
00:06:44,460 --> 00:06:50,890
‫如果你看到任何参数是一个引用, 但没有被标记为const, 那么你几乎可以假设有人打算把它作为一个out参数｡

75
00:06:50,910 --> 00:06:52,560
‫这就是我们现在看到的｡

76
00:06:52,560 --> 00:06:53,820
‫我们发现它已经损坏了｡

77
00:06:53,820 --> 00:07:01,440
‫如果我们要在CPP中实现它, 那么我们可以把你的抓取器类放在前面,

78
00:07:01,440 --> 00:07:05,950
‫我们可以把大括号放在这里｡

79
00:07:05,970 --> 00:07:12,390
‫我们将注释掉print damage中不满意的那一行, 因为我们正在尝试设置成本参考｡

80
00:07:12,720 --> 00:07:19,710
‫基本上我们可以在这里做的是, 我们可以做一些代码, 我们可以看看我们是否有一些损坏, 然后我们会打印出来, 是的,

81
00:07:19,710 --> 00:07:22,230
‫好的｡

82
00:07:22,230 --> 00:07:25,470
‫输出伤害等于5｡

83
00:07:25,470 --> 00:07:29,760
‫所以这就是已经造成的损害, 我们将返回｡

84
00:07:29,760 --> 00:07:36,570
‫是的, 因为我们已经造成了一些损害, 我们现在可以用它来控制损害,

85
00:07:36,570 --> 00:07:40,110
‫比如蜱虫组件｡

86
00:07:40,410 --> 00:07:46,080
‫这里我们可以不设置damage值为5, 而是得到damage值, 如果有损坏,

87
00:07:46,080 --> 00:07:54,090
‫就打印出来, 这样我们就可以说, 如果有损坏, 然后我们传入变量,

88
00:07:54,090 --> 00:07:56,700
‫我们想用这个变量填充｡

89
00:07:56,700 --> 00:08:05,040
‫比如说damage, 然后我们可以有语句的主体, 我们可以只调用print damage, 比如说,

90
00:08:05,040 --> 00:08:11,990
‫如果有任何要显示的损坏, 我们可以完全删除这个u log｡

91
00:08:12,000 --> 00:08:21,420
‫这就是我们使用非常数引用作为out参数的方法, 一种从函数中获取多个返回值的方法｡

92
00:08:21,420 --> 00:08:27,510
‫通常当我们这样做的时候, 当我们调用这个函数的时候, 我们会创建一个变量,

93
00:08:27,510 --> 00:08:29,820
‫但是我们不会给予它一个初始值｡

94
00:08:29,820 --> 00:08:37,050
‫在第39行, 我已经定义了浮点损伤, 我直接把它传递到下一行｡

95
00:08:37,050 --> 00:08:41,820
‫这是您使用out参数的另一个信号｡

96
00:08:42,150 --> 00:08:51,570
‫在我把它传递给函数之前我没有给它赋值, 这意味着我希望函数能为我赋值.

97
00:08:51,570 --> 00:08:55,500
‫所以这一点一开始很难发现, 而且可能会有点混乱｡

98
00:08:55,500 --> 00:08:58,260
‫但我希望你们记住这两条规则｡

99
00:08:58,260 --> 00:09:05,910
‫如果你看到一个变量被声明了, 但没有赋值, 并且立即被传递给了一个函数, 问问自己这是否是一个out参数｡

100
00:09:05,910 --> 00:09:15,600
‫另一个规则是如果你看到一个引用作为一个参数, 但它不是const, 那么这也可能暗示这是一个out参数｡

101
00:09:15,600 --> 00:09:21,840
‫当然, 如果变量或者参数被命名为out, 那就很明显,

102
00:09:21,840 --> 00:09:24,060
‫这个变量或者参数就是out参数.

103
00:09:24,300 --> 00:09:24,960
‫好东西｡

104
00:09:24,960 --> 00:09:28,890
‫我认为这为我们进行一次清扫做了很好的准备｡

105
00:09:28,890 --> 00:09:30,990
‫我们下节课再见｡