﻿1
00:00:04,410 --> 00:00:05,340
‫Cześć i witaj.

2
00:00:05,340 --> 00:00:10,290
‫Na tym wykładzie będziemy się uczyć o dziwnym zjawisku zwanym parametrem zewnętrznym.

3
00:00:10,290 --> 00:00:17,400
‫Jest to parametr, który zamiast przekazywać wartość w C++, mamy tendencję do przekazywania wartości z

4
00:00:17,400 --> 00:00:18,000
‫funkcji.

5
00:00:18,450 --> 00:00:23,340
‫Zobaczymy również coś, co nazywa się stałym odniesieniem i jak te dwie

6
00:00:23,340 --> 00:00:25,380
‫koncepcje są ze sobą powiązane.

7
00:00:25,740 --> 00:00:27,720
‫Zanurzmy się i wymyślmy to.

8
00:00:28,880 --> 00:00:29,150
‫Teraz.

9
00:00:29,150 --> 00:00:36,890
‫Prawdziwym miejscem, w którym błyszczą odwołania, są parametry funkcji, ponieważ za każdym razem,

10
00:00:36,890 --> 00:00:45,740
‫gdy tworzymy czas delta zmiennoprzecinkowego w naszym komponencie, robimy to, że pobieramy kopię tego oryginalnego

11
00:00:45,740 --> 00:00:49,520
‫zmiennoprzecinkowego i przekazujemy go do funkcjonować.

12
00:00:49,520 --> 00:00:55,760
‫Więc zamiast tego, możemy chcieć zrobić odniesienie do tego i przekazać to zamiast.

13
00:00:56,240 --> 00:01:02,660
‫Więc wyobraźmy sobie, że mamy stworzyć funkcję, aby ją pobrać, z których każda nazywa się uszkodzeniem wydruku.

14
00:01:03,140 --> 00:01:09,200
‫A jako argument tej funkcji chcemy przekazać uszkodzenie zmiennoprzecinkowe.

15
00:01:09,470 --> 00:01:14,720
‫To, jak powiedziałem, utworzy kopię tego, co przekazujemy i skopiuje to do tej zmiennej.

16
00:01:14,720 --> 00:01:18,740
‫Utwórz tę zmienną parametru wewnątrz funkcji uszkodzenia wydruku.

17
00:01:19,930 --> 00:01:24,370
‫I musimy mieć tutaj również wartość zwracaną void, aby ją uzupełnić, i średnik na końcu.

18
00:01:24,730 --> 00:01:28,590
‫Przejdźmy do C++ i kontynuujmy tę rozmowę.

19
00:01:28,600 --> 00:01:30,790
‫Stwórzmy tutaj uszkodzenia druku.

20
00:01:31,390 --> 00:01:39,250
‫Połóżmy przed sobą klasę, a zamiast średnika wstawmy kilka nawiasów klamrowych.

21
00:01:39,820 --> 00:01:48,280
‫Mamy więc kopię zmiennej parametru uszkodzenia i jest to bezpieczne, ponieważ gdybym miał wyrządzić szkodę równą

22
00:01:48,280 --> 00:01:53,950
‫pięciu, zmieniam tylko tę zmienną tutaj w ramach uszkodzeń wydruku.

23
00:01:53,950 --> 00:01:55,390
‫Mam własną kopię.

24
00:01:55,630 --> 00:01:57,910
‫Nie mogę tego zepsuć przez przypadek.

25
00:01:58,180 --> 00:02:01,400
‫A co, jeśli nie chcę robić kopii?

26
00:02:01,420 --> 00:02:04,330
‫Moją alternatywą byłoby skorzystanie z referencji.

27
00:02:04,630 --> 00:02:10,780
‫Więc co mogę tutaj zrobić, to umieścić odwołanie zmiennoprzecinkowe, które spowoduje uszkodzenie wydruku, i

28
00:02:10,780 --> 00:02:14,260
‫muszę to również zaktualizować w pliku C++.

29
00:02:14,740 --> 00:02:20,230
‫A potem mogę mieć ten komunikat w dzienniku, że używamy odniesienia, chodźmy i zdejmijmy to,

30
00:02:20,470 --> 00:02:22,540
‫a to w uszkodzeniu druku.

31
00:02:22,750 --> 00:02:29,200
‫Więc teraz bierzemy nasze obrażenia i drukujemy aktualizacje, oświadczenia dziennika mówią, że uszkodzenie to ten przypadek uszkodzenia, to

32
00:02:29,470 --> 00:02:30,940
‫jest to uszkodzenie.

33
00:02:31,300 --> 00:02:40,060
‫A w naszym komponencie tikowym możemy zrobić uszkodzenie wydruku i przekazać zmienną uszkodzenia i umieścić średnik

34
00:02:40,060 --> 00:02:41,230
‫na końcu.

35
00:02:41,590 --> 00:02:48,670
‫I na razie możemy pozbyć się naszego odniesienia do obrażeń, ponieważ mamy teraz do czynienia z uszkodzonym pływakiem,

36
00:02:48,670 --> 00:02:51,010
‫który jest tworzony w technologii.

37
00:02:51,010 --> 00:03:00,100
‫Pamięć do tego została stworzona tutaj w Take, a następnie idziemy i przekazujemy ją do tej funkcji uszkodzenia druku.

38
00:03:00,100 --> 00:03:06,640
‫Ale ponieważ parametr jest odniesieniem, tak naprawdę nie kopiujemy tego uszkodzenia.

39
00:03:06,640 --> 00:03:13,300
‫Bierzemy jego adres i przechowujemy go w referencji, tak że kiedy używamy tego referencji

40
00:03:13,300 --> 00:03:18,130
‫w dół wiersza, faktycznie uzyskujemy dostęp do oryginalnego kawałka pamięci.

41
00:03:18,130 --> 00:03:21,930
‫Więc nie musiała się wydarzyć żadna kopia, aby wydrukować uszkodzenie.

42
00:03:21,940 --> 00:03:25,240
‫Sprawdźmy teraz, czy rzeczywiście robi to, czego byśmy od niego oczekiwali.

43
00:03:25,240 --> 00:03:34,000
‫Jeśli zmienię wartość obrażeń na przykład na pięć, a następnie ponownie skompiluję i wcisnę odtwarzanie, spójrz na

44
00:03:34,000 --> 00:03:38,410
‫dziennik wyjściowy i wydruk, że obrażenia wynoszą pięć.

45
00:03:38,560 --> 00:03:42,880
‫Ale ponieważ mamy odniesienie, wiemy, że możemy zaktualizować tę wartość.

46
00:03:42,880 --> 00:03:48,880
‫Więc co mogę zrobić, to powiedzieć, że w ramach tej funkcji mogę zrobić, hej, obrażenia powinny być

47
00:03:48,940 --> 00:03:49,750
‫równe dwóm.

48
00:03:50,320 --> 00:03:55,300
‫A gdybym nie był ostrożny, gdybym myślał, że mam własną kopię, mógłbym pomyśleć, że to w porządku.

49
00:03:55,630 --> 00:04:01,540
‫Ale w rzeczywistości w komponencie tikowym zmieniliśmy oryginalne zmienne A.

50
00:04:01,560 --> 00:04:09,580
‫Jeśli umieszczę mały login tutaj, aby sprawdzić tę oryginalną zmienną dotyczącą obrażeń, a następnie wstawimy procent F i

51
00:04:09,580 --> 00:04:15,670
‫przekażemy tutaj obrażenia, zacznijmy kod na żywo i skompilujmy to, a zaczniemy grać.

52
00:04:15,910 --> 00:04:21,850
‫Zajrzyj do naszego dziennika wyników, a zobaczysz, że teraz obrażenia i pierwotne obrażenia

53
00:04:21,850 --> 00:04:22,960
‫zostały zmodyfikowane.

54
00:04:22,960 --> 00:04:27,400
‫Oboje zostali zmienieni na numer dwa, co nie jest wspaniałe.

55
00:04:27,430 --> 00:04:33,100
‫Wiesz, możesz przypadkowo wyrządzić wiele szkód, jeśli wybaczysz grę słów, zmieniając zmienne,

56
00:04:33,100 --> 00:04:35,500
‫których nie spodziewałeś się zmienić.

57
00:04:36,010 --> 00:04:41,170
‫A oto kolejne zastosowanie tego słowa kluczowego const, które widzieliśmy w przeszłości.

58
00:04:41,620 --> 00:04:49,570
‫Jeśli umieszczę const przed moim odwołaniem zmiennoprzecinkowym, to mówię tutaj, że powinno to być

59
00:04:49,570 --> 00:04:52,510
‫odniesienie, którego nie można zmienić.

60
00:04:52,510 --> 00:04:56,290
‫Nie możesz wywołać na nim żadnych funkcji bezkontaktowych, nie możesz tego ustawić.

61
00:04:56,500 --> 00:05:00,370
‫Nie możesz w żaden sposób zmienić zawartości tej zmiennej.

62
00:05:00,370 --> 00:05:04,360
‫Możesz go tylko używać, możesz go tylko czytać, możesz tylko zobaczyć to, co tam jest.

63
00:05:04,450 --> 00:05:10,540
‫Więc jeśli wrócimy do I chwyć kopię, musimy upewnić się, że umieściliśmy tutaj również Const

64
00:05:10,540 --> 00:05:17,170
‫w parametrach i możemy kontynuować kompilację i widzisz, że otrzymujemy niepowodzenie kompilacji, a błąd mówi, że uszkodzenia

65
00:05:17,170 --> 00:05:21,850
‫nie można przypisane do niego, ponieważ jest to zmienna stała.

66
00:05:22,270 --> 00:05:25,000
‫Daje nam to ochronę, której potrzebujemy.

67
00:05:25,390 --> 00:05:32,890
‫Więc ogólnie rzecz biorąc, jeśli próbujemy przekazać zmienną w sposób efektywny, bez konieczności pobierania

68
00:05:32,890 --> 00:05:38,770
‫kopii, zawsze będziemy używać słowa kluczowego contact, a także referencji, ponieważ

69
00:05:39,010 --> 00:05:43,630
‫uniemożliwia to nam przypadkowo zmieniając tę zawartość.

70
00:05:44,290 --> 00:05:50,350
‫Teraz jednak czasami chcesz go użyć do zmiany tej wartości.

71
00:05:50,680 --> 00:05:58,750
‫I to, co możemy mieć jako przykład, możemy mieć zwracaną wartość logiczną i możemy chcieć powiedzieć, że ma

72
00:05:58,750 --> 00:06:06,580
‫obrażenia, ale możemy również, jak to zrobiliśmy w Blueprint w przeszłości, chcieć mieć drugą wartość zwracaną.

73
00:06:06,580 --> 00:06:10,640
‫Możemy więc powiedzieć, czy mamy jakieś uszkodzenia i co to za uszkodzenie?

74
00:06:10,780 --> 00:06:19,060
‫Cóż, w tym przypadku sensowne jest użycie prostego odwołania bezkontaktowego, odwołania zmiennoprzecinkowego.

75
00:06:19,530 --> 00:06:26,580
‫Obrażenia i zazwyczaj nazywamy to obrażeniami tylko po to, aby naprawdę było widoczne, że jest

76
00:06:26,580 --> 00:06:29,280
‫to tak zwany parametr out.

77
00:06:29,310 --> 00:06:31,110
‫To nie jest parametr do przekazywania rzeczy.

78
00:06:31,140 --> 00:06:33,360
‫Jest to parametr do rozdawania rzeczy.

79
00:06:33,630 --> 00:06:38,190
‫Teraz może to być trochę dziwne dziwactwo C++ i może być trudne do zauważenia.

80
00:06:38,490 --> 00:06:44,250
‫Ale ogólnie rzecz biorąc, jeśli widzisz jakiekolwiek parametry, które są odniesieniem, ale nie

81
00:06:44,520 --> 00:06:50,700
‫są oznaczone jako kontakt, możesz prawie założyć, że ktoś zamierzał użyć tego jako parametru wyjściowego.

82
00:06:51,090 --> 00:06:52,530
‫Więc to właśnie mamy tutaj.

83
00:06:52,530 --> 00:06:53,750
‫Mamy obrażenia.

84
00:06:53,760 --> 00:07:01,380
‫A gdybyśmy mieli zaimplementować to w CPP, to możemy umieścić tutaj klasę na początku,

85
00:07:01,380 --> 00:07:05,700
‫a tutaj możemy umieścić nasze nawiasy klamrowe.

86
00:07:06,120 --> 00:07:10,620
‫Zamierzamy skomentować uszkodzenia odcisków linii, z których nie jest zadowolony, ponieważ próbujemy

87
00:07:10,620 --> 00:07:12,170
‫ustawić odniesienie do kontaktu.

88
00:07:12,780 --> 00:07:19,680
‫I zasadniczo to, co moglibyśmy tutaj zrobić, to zrobić jakiś kod, moglibyśmy zobaczyć, czy mamy jakieś uszkodzenia,

89
00:07:19,680 --> 00:07:22,170
‫a następnie wydrukowalibyśmy, tak, w porządku.

90
00:07:22,200 --> 00:07:25,430
‫Nasze obrażenia wynoszą pięć.

91
00:07:25,440 --> 00:07:29,610
‫Więc to są szkody, które zostały wyrządzone i możemy wrócić.

92
00:07:29,760 --> 00:07:36,480
‫To prawda, ponieważ zarobiliśmy trochę obrażeń i możemy to teraz wykorzystać w miejscach takich

93
00:07:36,510 --> 00:07:39,870
‫jak komponenty TEC, aby uzyskać obrażenia.

94
00:07:40,470 --> 00:07:46,020
‫Więc zamiast ustawiać obrażenia na pięć, możemy uzyskać obrażenia i wydrukować je, jeśli

95
00:07:46,020 --> 00:07:53,790
‫są jakieś uszkodzenia, więc możemy powiedzieć coś w tym stylu, jeśli ma obrażenia, a następnie przekazujemy zmienną,

96
00:07:53,790 --> 00:07:56,490
‫którą chcemy zapełnić obrażeniami .

97
00:07:56,760 --> 00:08:04,980
‫Na przykład uszkodzenie, a potem możemy mieć treść naszego oświadczenia i możemy tylko nazwać uszkodzenie wydruku, na przykład,

98
00:08:04,980 --> 00:08:11,700
‫jeśli są jakieś uszkodzenia do wyświetlenia i możemy je usunąć, logujemy się całkowicie.

99
00:08:12,150 --> 00:08:19,320
‫W ten sposób używamy referencji bezkontaktowych jako parametrów wyjściowych, sposób na uzyskanie wielu wartości

100
00:08:19,320 --> 00:08:21,240
‫zwracanych z funkcji.

101
00:08:21,540 --> 00:08:27,450
‫I zazwyczaj, kiedy to robimy, kiedy wywołujemy tę funkcję, tworzymy zmienną, ale nie

102
00:08:27,450 --> 00:08:29,640
‫nadajemy jej wartości początkowej.

103
00:08:29,940 --> 00:08:34,260
‫Więc w linii 39, mam zdefiniowane obrażenia typu float.

104
00:08:34,560 --> 00:08:36,990
‫Podaję go od razu w następnym wierszu.

105
00:08:36,990 --> 00:08:41,590
‫I to jest kolejny znak ostrzegawczy, że używasz parametru out.

106
00:08:42,120 --> 00:08:48,390
‫Nie podałem żadnej wartości tuż przed przekazaniem jej do funkcji, oznacza to, że oczekuję, że

107
00:08:48,390 --> 00:08:51,390
‫ta funkcja wprowadzi tę wartość za mnie.

108
00:08:51,690 --> 00:08:55,350
‫Na początku może to być trudne do zauważenia i może być trochę mylące.

109
00:08:55,560 --> 00:08:58,200
‫Ale to są dwie zasady, o których chciałbym abyś pamiętał.

110
00:08:58,200 --> 00:09:04,290
‫Jeśli zobaczysz zadeklarowaną zmienną, której nie podano wartości i która została natychmiast przekazana do funkcji, zadaj sobie pytanie, czy

111
00:09:04,380 --> 00:09:05,880
‫jest to parametr out.

112
00:09:05,880 --> 00:09:12,390
‫Druga reguła to taka, że jeśli widzisz odwołanie jako parametr, ale nie jest ono treścią, może to

113
00:09:12,390 --> 00:09:15,420
‫również wskazywać, że jest to parametr wyjściowy.

114
00:09:15,720 --> 00:09:21,780
‫I oczywiście, jeśli zmienna lub parametr jest nazwana jakoś, to jest to martwa wskazówka, że ta

115
00:09:21,780 --> 00:09:23,940
‫rzecz ma być parametrem out.

116
00:09:24,360 --> 00:09:24,890
‫Świetna sprawa.

117
00:09:24,900 --> 00:09:28,850
‫Myślę, że to bardzo ładnie przygotowało nas do tego, że możemy przeprowadzić zamiatanie.

118
00:09:28,860 --> 00:09:30,750
‫Do zobaczenia na następnym wykładzie.

