1
00:00:04,340 --> 00:00:05,570
‫你好, 欢迎｡

2
00:00:05,570 --> 00:00:12,050
‫在这节课中, 我们将学习引用和指针的替代方法, 我们将看到它们为什么不同,

3
00:00:12,050 --> 00:00:14,810
‫为什么我们要使用它们｡

4
00:00:14,810 --> 00:00:16,370
‫让我们一起来看看｡

5
00:00:17,220 --> 00:00:23,200
‫因此, 除了指针, 还有一个非常相似的相关概念, 称为引用｡

6
00:00:23,220 --> 00:00:28,980
‫现在指针和引用本质上都只是一个内存地址｡

7
00:00:28,980 --> 00:00:37,200
‫它们都存储了一个引用, 指向可以找到另一个变量的位置, 在这一点上, 它们非常相似｡

8
00:00:37,230 --> 00:00:43,140
‫两者之间的区别基本上归结为他们是否可以重新分配｡

9
00:00:43,140 --> 00:00:48,650
‫基本上, 它们在第一次创建后是否可以指向不同的地址？

10
00:00:48,660 --> 00:00:51,570
‫在指针的情况下, 答案是肯定的｡

11
00:00:51,570 --> 00:00:57,660
‫只要类型正确, 您可以随时更改指针, 使其指向新的内存地址､

12
00:00:57,660 --> 00:00:59,910
‫新的参与者或新的组件｡

13
00:01:00,210 --> 00:01:09,450
‫另一方面, 一个引用只能在你第一次创建它指向另一个变量时设置一次, 然后就不能再改变了｡

14
00:01:09,450 --> 00:01:21,480
‫这是一个安全特性, 因为重定向变量可能会导致变量消失或将指针设置为空的问题｡

15
00:01:21,510 --> 00:01:28,020
‫空指针本质上是一个指向空的指针,

16
00:01:28,020 --> 00:01:37,410
‫试图用一个设置为空的指针做一些事情实际上会导致引擎崩溃, 这对引用来说不是一个理想的结果, 因为你必须在第一次创建引用时给它们一个值｡

17
00:01:37,560 --> 00:01:41,730
‫它们不能为空, 所以你不能得到这些空指针崩溃｡

18
00:01:41,940 --> 00:01:45,660
‫因此, 让我们开始了解一些相关的语法｡

19
00:01:45,660 --> 00:01:50,880
‫因此, 当您使用指针访问内容时, 必须使用一些特殊的语法｡

20
00:01:50,880 --> 00:01:55,890
‫你必须把这个星星放在指针前面,

21
00:01:55,890 --> 00:02:01,200
‫以确保你得到的是指针中的值, 而不是带引用的内存地址, 因为你从来不需要真正得到内存地址｡

22
00:02:01,200 --> 00:02:06,240
‫您可以直接使用该变量, 就好像它就是它所指向的变量一样｡

23
00:02:06,240 --> 00:02:08,460
‫您不必使用任何特殊语法｡

24
00:02:08,820 --> 00:02:15,390
‫现在是访问地址, 所以通过指针你可以自动获得地址｡

25
00:02:15,390 --> 00:02:18,750
‫当您将变数与指涉搭配使用时, 必须使用特殊语法｡

26
00:02:18,750 --> 00:02:26,670
‫要做到这一点, 你必须使用运算符的地址, 它将得到基本上与原始变量相同的地址｡

27
00:02:27,210 --> 00:02:30,720
‫然后用一个指针来改变地址｡

28
00:02:30,720 --> 00:02:35,850
‫我们已经看到, 您可以分配地址, 并使用运算符的地址来对引用执行此操作｡

29
00:02:35,850 --> 00:02:38,070
‫这是不允许的, 因此没有语法｡

30
00:02:38,070 --> 00:02:43,860
‫最后, 如果我们想改变我们指向的值, 而不是地址, 而是存储在该地址的实际值,

31
00:02:43,860 --> 00:02:46,200
‫该怎么办？

32
00:02:46,200 --> 00:02:50,740
‫对于指针, 你必须再次使用一些特殊的语法｡

33
00:02:50,740 --> 00:02:53,280
‫我们得把星星放上去, 然后分配一些东西｡

34
00:02:53,280 --> 00:03:03,270
‫所以你把演员指针赋值给星星指针, 因为你不能改变实际的地址, 所以你不需要任何额外的语法｡

35
00:03:03,270 --> 00:03:07,230
‫我们可以去掉多余的语法, 只使用actor引用equals｡

36
00:03:07,230 --> 00:03:12,870
‫使用者表示您正在覆盖所指向位置中的值｡

37
00:03:12,870 --> 00:03:14,280
‫所以这些都是理论上的｡

38
00:03:14,280 --> 00:03:16,200
‫让我们来举一个实际的例子｡

39
00:03:16,200 --> 00:03:26,670
‫所以如果我们有一个浮动存储, 在游戏中对我们造成的伤害, 在这个存储中, 当前的伤害被设置为零｡

40
00:03:26,670 --> 00:03:28,350
‫没人伤害我们｡

41
00:03:28,380 --> 00:03:33,900
‫现在我们可能想创建一个对this的引用, 而不是复制, 我们可能想把它传递给一个函数,

42
00:03:33,900 --> 00:03:36,960
‫但实际上并没有改变它｡

43
00:03:36,960 --> 00:03:42,690
‫我们可以这样做, 就是有一个浮点数, 然后把&号放在浮点数后面｡

44
00:03:42,690 --> 00:03:45,390
‫和号表示这是对浮点数的引用｡

45
00:03:45,390 --> 00:03:49,470
‫它本身不是一个新的float, 不分配任何float内存｡

46
00:03:49,470 --> 00:03:51,360
‫它只分配一个指针内存｡

47
00:03:51,510 --> 00:03:56,940
‫我们可以把它叫做参考损伤, 我们可以把它设为等于损伤｡

48
00:03:56,940 --> 00:04:00,360
‫我们不需要地址或做任何类似的事情｡

49
00:04:00,360 --> 00:04:04,530
‫它会自动知道, 这是一个引用, 这是一个变量.

50
00:04:04,530 --> 00:04:08,760
‫所以你现在要做的就是建立一个对这个变量的引用.

51
00:04:08,760 --> 00:04:15,870
‫当然, 如果我们输入log, 我们可以把它当作普通的浮点数打印出来,

52
00:04:15,870 --> 00:04:24,540
‫我们可以输入damage冒号, 然后是percentage F, 这里我们可以只打印damage ref｡

53
00:04:24,540 --> 00:04:25,860
‫我们不需要任何特殊的语法｡

54
00:04:25,860 --> 00:04:28,470
‫我们可以像使用常规变量一样使用它｡

55
00:04:28,470 --> 00:04:34,020
‫让我们在编译后点击播放, 看看我们的输出日志, 果然, 损坏是零,

56
00:04:34,020 --> 00:04:37,680
‫这是我们设置的值｡

57
00:04:37,680 --> 00:04:42,720
‫但这并不一定能证明我没有复制原始变量｡

58
00:04:42,900 --> 00:04:47,040
‫让我们来挑战你, 试着改变这个值, 看看会发生什么｡

59
00:04:47,040 --> 00:04:54,720
‫所以使用参考值时, 要把参考值损坏后重新设置一个新的值然后把原来的值打印出来,

60
00:04:54,720 --> 00:04:59,910
‫这样原来的值在参考值旁边看看｡

61
00:04:59,910 --> 00:05:01,770
‫它们是相同的还是不同的？

62
00:05:01,770 --> 00:05:05,190
‫您只更改了引用, 但是否也更改了原始引用？

63
00:05:05,190 --> 00:05:08,760
‫因为这意味着它们是同一个变量｡

64
00:05:08,790 --> 00:05:10,830
‫暂停视频, 开始体验｡

65
00:05:13,910 --> 00:05:14,420
‫好吧, 我会的

66
00:05:14,420 --> 00:05:15,130
‫欢迎回来｡

67
00:05:15,140 --> 00:05:16,610
‫我们来给予吧｡

68
00:05:16,640 --> 00:05:22,310
‫现在要改变参考, 我们要做damage ref equals｡

69
00:05:22,310 --> 00:05:27,650
‫这次我会说我们造成了五个破坏, 注意我在这里没有使用任何特殊的语法｡

70
00:05:27,650 --> 00:05:34,760
‫它没有重指向引用, 因为我们已经声明了它, 并且在创建它的时候在第一行设置了它的引用｡

71
00:05:34,760 --> 00:05:36,290
‫我们不能再这样了｡

72
00:05:36,290 --> 00:05:39,080
‫现在我们可以设置值了｡

73
00:05:39,410 --> 00:05:46,010
‫所以我现在能做的是我们已经得到了损坏, 裁判在日志中｡

74
00:05:46,040 --> 00:05:56,810
‫让我们把damage和percent f放到同一个字符串上, 然后把damage也传递到这里｡

75
00:05:57,560 --> 00:06:00,710
‫然后我们会编译并查看｡

76
00:06:00,740 --> 00:06:08,540
‫让我们点击播放, 进入输出日志, 果然, 它打印出了damage ref和damage as,

77
00:06:08,540 --> 00:06:12,350
‫两者都有新的值, 我们已经设置为5｡

78
00:06:12,350 --> 00:06:18,710
‫所以本质上, 我们这里有两个变量指向同一个内存块｡

79
00:06:18,710 --> 00:06:22,370
‫你几乎可以说它们是同一个变量, 只是名字不同｡

80
00:06:22,370 --> 00:06:28,610
‫它的好处是不需要拷贝, 就像指针一样, 但它还有更多的好处,

81
00:06:28,610 --> 00:06:30,740
‫因为它更容易使用｡

82
00:06:30,740 --> 00:06:33,680
‫我们不需要所有额外的语法, 而且使用起来也更安全｡

83
00:06:33,680 --> 00:06:39,320
‫因此, 只要我们不需要重新指向任何东西, 使用引用通常是更可取的｡

84
00:06:39,320 --> 00:06:44,840
‫现在, 让我们快速回顾一下我们在这里使用的一些符号, 因为它们可能会让人有点困惑｡

85
00:06:44,840 --> 00:06:47,240
‫它们在C++中被广泛使用｡

86
00:06:47,240 --> 00:06:52,520
‫所以, &符号和星星, 让我们看看它们在上下文中的含义｡

87
00:06:52,790 --> 00:07:00,020
‫当我们在表达式中使用它们的时候, 这里有一些代码示例｡

88
00:07:00,020 --> 00:07:03,620
‫你可能会在变量前看到星星｡

89
00:07:03,620 --> 00:07:06,410
‫您可能会在变量前面看到&符号｡

90
00:07:06,410 --> 00:07:07,610
‫这是什么意思呢？

91
00:07:08,240 --> 00:07:16,190
‫有了星星, 把它放在变量之前的语法意味着我们现在得到的是演员指针的内容,

92
00:07:16,190 --> 00:07:20,990
‫还有&｡

93
00:07:20,990 --> 00:07:28,910
‫如果你把&号放在变量前面或者变量引用前面, 它就表示它正在获取变量的地址｡

94
00:07:28,910 --> 00:07:32,720
‫它获取参与者的地址或引用所指向的地址｡

95
00:07:32,720 --> 00:07:41,420
‫现在当我们声明我们在变量的类型中使用它时, 星号和&符号的含义几乎相反｡

96
00:07:41,420 --> 00:07:52,550
‫星星表示这是一个指向新参与者的指针, 而&符号表示这是一个指向新参与者的引用｡

97
00:07:52,550 --> 00:07:57,140
‫记住,

98
00:07:57,140 --> 00:08:03,500
‫这是一组完全不同的含义, 无论是在表达式中的变量中使用, 还是在声明变量的类型中使用.

99
00:08:03,500 --> 00:08:08,000
‫现在, 我不想详细讨论它, 但雪上加霜的是,

100
00:08:08,000 --> 00:08:14,240
‫在其他上下文中, 这些符号实际上可以有其他的含义, 而“&”符号可以有一点明智的含义, 正如我们已经看到的,

101
00:08:14,240 --> 00:08:17,960
‫星星可以和U log中的字符串一起使用｡

102
00:08:17,960 --> 00:08:26,600
‫所以这不一定是这两个符号的全部含义, 但是它们几乎是指针和引用的所有重要含义｡

103
00:08:26,630 --> 00:08:27,320
‫好东西｡

104
00:08:27,320 --> 00:08:32,480
‫因此, 我们已经了解了指针､ 引用､ 它们之间的关系､ 它们之间的区别,

105
00:08:32,480 --> 00:08:34,490
‫以及我们为什么要使用它们｡

106
00:08:34,490 --> 00:08:36,140
‫我们下节课再见｡