1
00:00:00,000 --> 00:00:06,030
>> [მუსიკის დაკვრა]

2
00:00:06,030 --> 00:00:08,390
>> DOUG LLOYD: პოინტერები, აქ ვართ.

3
00:00:08,390 --> 00:00:11,080
ეს არის ალბათ აპირებს
ყველაზე რთული თემა

4
00:00:11,080 --> 00:00:12,840
რომ ჩვენ ვსაუბრობთ CS50.

5
00:00:12,840 --> 00:00:15,060
და თუ თქვენ წაიკითხოთ
არაფერი პოინტერები

6
00:00:15,060 --> 00:00:19,080
სანამ შეიძლება იყოს ცოტა
დაშინებას აპირებს ამ ვიდეო.

7
00:00:19,080 --> 00:00:21,260
მართალია, მითითებას
გთხოვთ საშუალებას გაძლევთ უნარი

8
00:00:21,260 --> 00:00:23,740
ალბათ, ხრახნიანი up
საკმაოდ ცუდად, როდესაც თქვენ

9
00:00:23,740 --> 00:00:27,450
მუშაობის ცვლადები, და მონაცემები,
და იწვევს თქვენი პროგრამის მისაწოდებლად.

10
00:00:27,450 --> 00:00:30,490
მაგრამ ისინი რეალურად სასარგებლო
და ისინი საშუალებას მოგვცემს მართლაც დიდი გზა

11
00:00:30,490 --> 00:00:33,340
გაივლის მონაცემები უკან და
მეოთხე შორის ფუნქციები,

12
00:00:33,340 --> 00:00:35,490
რომ ჩვენ სხვაგვარად ვერ გააკეთებს.

13
00:00:35,490 --> 00:00:37,750
>> ასე რომ, რაც ჩვენ ნამდვილად
მინდა აქ არის მატარებელი

14
00:00:37,750 --> 00:00:41,060
თქვენ გაქვთ კარგი მაჩვენებელი დისციპლინის, ასე რომ
რომ თქვენ შეგიძლიათ გამოიყენოთ პოინტერები ეფექტურად

15
00:00:41,060 --> 00:00:43,850
იმისათვის, რომ თქვენი პროგრამა, რომელიც ბევრად უკეთესი.

16
00:00:43,850 --> 00:00:48,220
როგორც ვთქვი მითითებას გვაძლევს სხვადასხვა
გზა უნდა გაიაროს მონაცემები ფუნქციები.

17
00:00:48,220 --> 00:00:50,270
ახლა თუ გახსოვთ,
ადრე ვიდეო, როდესაც

18
00:00:50,270 --> 00:00:53,720
ჩვენ ვსაუბრობთ
ცვლადი ფარგლებს, აღვნიშნე,

19
00:00:53,720 --> 00:01:00,610
რომ ყველა მონაცემები, რომ ჩვენ შორის გაივლის
ფუნქციების C გავიდა ღირებულება.

20
00:01:00,610 --> 00:01:03,070
და მე შეიძლება არ გამოიყენება, რომ
ტერმინი,, რაც მე იმას ნიშნავდა,

21
00:01:03,070 --> 00:01:07,170
იყო, რომ ჩვენ გადიან ასლები მონაცემები.

22
00:01:07,170 --> 00:01:12,252
როდესაც ჩვენ გაიაროს ცვლადი ფუნქცია,
ჩვენ რეალურად არ გავლის ცვლადი

23
00:01:12,252 --> 00:01:13,210
ფუნქცია, არა?

24
00:01:13,210 --> 00:01:17,670
ჩვენ გავლით ასლი
რომ მონაცემები ფუნქცია.

25
00:01:17,670 --> 00:01:20,760
ფუნქცია აქვს რა იქნება
და ითვლის გარკვეული მნიშვნელობა,

26
00:01:20,760 --> 00:01:23,180
და იქნებ ჩვენ ვიყენებთ მნიშვნელობა
როდესაც იგი იძლევა უკან.

27
00:01:23,180 --> 00:01:26,700
>> იყო ერთი გამონაკლისი
ამ წესთან ღირებულება,

28
00:01:26,700 --> 00:01:31,210
და ჩვენ დავბრუნდებით რა, რომ
ცოტა მოგვიანებით ამ ვიდეო.

29
00:01:31,210 --> 00:01:34,880
თუ ვიყენებთ მითითებას ნაცვლად
გამოყენების ცვლადები,

30
00:01:34,880 --> 00:01:38,180
ან იმის მაგივრად, რომ ცვლადები
თავად ან ასლები ცვლადები,

31
00:01:38,180 --> 00:01:43,790
ახლა ჩვენ შეგვიძლია გაივლის ცვლადებს გარშემო
შორის ფუნქციების სხვადასხვა გზა.

32
00:01:43,790 --> 00:01:46,550
ეს იმას ნიშნავს, რომ თუ ჩვენ
ცვლილება ერთი ფუნქცია,

33
00:01:46,550 --> 00:01:49,827
რომ ცვლილება პრაქტიკულად
მოქმედებს სხვადასხვა ფუნქცია.

34
00:01:49,827 --> 00:01:52,160
ისევ და ისევ, ეს არის ის, რომ
ჩვენ არ შეგვეძლო ადრე,

35
00:01:52,160 --> 00:01:56,979
და თუ თქვენ ოდესმე ცდილობდა სვოპ
ღირებულება ორი ცვლადის ფუნქცია,

36
00:01:56,979 --> 00:01:59,270
თქვენ შენიშნა, ამ პრობლემის
სახის მცოცავი, არა?

37
00:01:59,270 --> 00:02:04,340
>> თუ ჩვენ გვინდა, რომ სვოპ X და Y, და ჩვენ
გადმოეცა ფუნქცია მოუწოდა swap,

38
00:02:04,340 --> 00:02:08,680
შიგნით ფუნქცია სვოპ
ცვლადები გავაკეთოთ გაცვლა ღირებულებებს.

39
00:02:08,680 --> 00:02:12,600
ერთი ხდება, ორი ხდება
ერთ-ერთი, მაგრამ ჩვენ არ რეალურად

40
00:02:12,600 --> 00:02:16,890
შეიცვალოს რამე ორიგინალური
ფუნქცია, აბონენტის.

41
00:02:16,890 --> 00:02:19,550
იმის გამო, რომ ჩვენ არ შეგვიძლია, ჩვენ მხოლოდ
მუშაობის ასლები მათ.

42
00:02:19,550 --> 00:02:24,760
პოინტერები, თუმცა, ჩვენ შეგვიძლია
რეალურად გაივლის X და Y ფუნქცია.

43
00:02:24,760 --> 00:02:26,960
ეს ფუნქცია შეგიძლიათ გააკეთოთ
რაღაც მათთან.

44
00:02:26,960 --> 00:02:29,250
და იმ ცვლადების ღირებულებების
შეიძლება რეალურად შეცვალოს.

45
00:02:29,250 --> 00:02:33,710
ასე რომ, საკმაოდ ცვლილება
ჩვენი მუშაობის უნარი მონაცემებით.

46
00:02:33,710 --> 00:02:36,100
>> სანამ ჩვენ ჩაყვინთვის შევიდა
მითითებას, მე ვფიქრობ, რომ ღირს

47
00:02:36,100 --> 00:02:38,580
აღების რამდენიმე წუთში
დაბრუნდეს საფუძვლებს აქ.

48
00:02:38,580 --> 00:02:41,000
და აქვს შევხედოთ, თუ როგორ
კომპიუტერის მეხსიერების სამუშაოები

49
00:02:41,000 --> 00:02:45,340
იმის გამო, რომ ამ ორ სუბიექტს ვაპირებთ
რეალურად იყოს საკმაოდ ურთიერთდაკავშირებულია.

50
00:02:45,340 --> 00:02:48,480
როგორც თქვენ ალბათ იცით,
თქვენი კომპიუტერის სისტემის

51
00:02:48,480 --> 00:02:51,310
თქვენ მყარ დისკზე ან
ალბათ მყარი დისკის,

52
00:02:51,310 --> 00:02:54,430
გარკვეული ფაილების შესანახი ადგილმდებარეობა.

53
00:02:54,430 --> 00:02:57,950
ეს, როგორც წესი, სადღაც
სამეზობლოში 250 გბ

54
00:02:57,950 --> 00:02:59,810
იქნებ რამდენიმე terabytes ახლა.

55
00:02:59,810 --> 00:03:02,270
და ეს არის, სადაც ყველა თქვენი
ფაილი საბოლოოდ ცხოვრობს,

56
00:03:02,270 --> 00:03:04,870
მაშინაც კი, როდესაც თქვენი კომპიუტერი დახურეს
off, შეგიძლიათ ჩართოთ ეს უკან

57
00:03:04,870 --> 00:03:09,190
და თქვენ იპოვით თქვენი ფაილი არსებობს
ერთხელ, როდესაც თქვენ გადატვირთეთ სისტემა.

58
00:03:09,190 --> 00:03:14,820
მაგრამ მაგნიტური დისკები, როგორიცაა მყარი დისკის,
ჰორიზონტალური ბურღვის, ან მყარი დისკის, SSD,

59
00:03:14,820 --> 00:03:16,050
არის მხოლოდ შენახვის სივრცეში.

60
00:03:16,050 --> 00:03:20,400
>> ჩვენ არ შეგვიძლია რეალურად არაფერი
მონაცემები, რომ არის ხისტი,

61
00:03:20,400 --> 00:03:22,080
ან მყარი დისკის.

62
00:03:22,080 --> 00:03:24,950
იმისათვის, რომ რეალურად შეცვალოს
მონაცემების ან გადატანა გარშემო,

63
00:03:24,950 --> 00:03:28,800
ჩვენ უნდა გადავიდეს ეს
RAM, ოპერატიული მეხსიერება.

64
00:03:28,800 --> 00:03:31,170
ახლა RAM, თქვენ გაქვთ ბევრი
ნაკლებად თქვენს კომპიუტერში.

65
00:03:31,170 --> 00:03:34,185
თქვენ შეიძლება ჰქონდეს სადღაც
სამეზობლოში 512 მბ

66
00:03:34,185 --> 00:03:38,850
თუ თქვენ გაქვთ ძველი კომპიუტერი,
იქნებ ორი, ოთხი, რვა, 16,

67
00:03:38,850 --> 00:03:41,820
შესაძლოა ცოტა
უფრო მეტიც, გბ ოპერატიული მეხსიერება.

68
00:03:41,820 --> 00:03:46,390
ასე რომ, ბევრად უფრო მცირე, მაგრამ ეს
სადაც ყველა არასტაბილურ მონაცემები არ არსებობს.

69
00:03:46,390 --> 00:03:48,270
სწორედ იქ, სადაც ჩვენ შეგვიძლია შეცვალოს.

70
00:03:48,270 --> 00:03:53,350
მაგრამ როდესაც ჩვენ რომ ჩვენი კომპიუტერის გამორთვა,
ყველა მონაცემების RAM განადგურებულია.

71
00:03:53,350 --> 00:03:57,150
>> ასე რომ, თუ რატომ უნდა ჰქონდეს მყარი დისკის
ამისთვის უფრო მუდმივი ის,

72
00:03:57,150 --> 00:03:59,720
ასე, რომ ეს exists-, რომ ის
იქნება ნამდვილად ცუდია, თუ ყოველ ჯერზე ჩვენ

73
00:03:59,720 --> 00:04:03,310
დღევანდელი ჩვენი კომპიუტერის გამორთვა, ყოველ
ფაილი ჩვენს სისტემა, განადგურდა.

74
00:04:03,310 --> 00:04:05,600
ასე რომ, ჩვენ მუშაობა შიგნით RAM.

75
00:04:05,600 --> 00:04:09,210
და ყოველ ჯერზე ჩვენ ვსაუბრობთ
მეხსიერება, საკმაოდ ბევრი, CS50,

76
00:04:09,210 --> 00:04:15,080
ჩვენ ვსაუბრობთ RAM, არ მყარ დისკზე.

77
00:04:15,080 --> 00:04:18,657
>> ასე რომ, როდესაც ჩვენ გადაადგილება რამ მეხსიერებაში,
იგი იღებს გარკვეულ სივრცეში.

78
00:04:18,657 --> 00:04:20,740
ყველა მონაცემთა ტიპები, რომ
ჩვენ ვმუშაობთ ერთად

79
00:04:20,740 --> 00:04:23,480
დასჭირდეს სხვადასხვა
რაოდენობით სივრცეში RAM.

80
00:04:23,480 --> 00:04:27,600
ასე რომ, ყოველ დროს, თქვენ შექმენით რიცხვი
ცვლადი, ოთხი ბაიტი მეხსიერება

81
00:04:27,600 --> 00:04:30,750
გათვალისწინებულია ამ RAM, ასე რომ თქვენ
შეუძლია მუშაობა, რომ რიცხვი.

82
00:04:30,750 --> 00:04:34,260
შეგიძლიათ განაცხადოს რიცხვი,
შეცვლის, მივანიჭოთ მას

83
00:04:34,260 --> 00:04:36,700
ღირებულება 10 incremented
ერთ-ერთი, და ასე შემდეგ.

84
00:04:36,700 --> 00:04:39,440
ყველა, რომ უნდა მოხდეს
RAM, და თქვენ ოთხი ბაიტი

85
00:04:39,440 --> 00:04:42,550
მუშაობა ყველა
მთელი რიცხვი, რომელიც შექმნა.

86
00:04:42,550 --> 00:04:45,410
>> ყოველ ხასიათი
შექმნა იღებს ერთი ბაიტი.

87
00:04:45,410 --> 00:04:48,160
ეს არის ის, თუ რამდენად დიდი სივრცე
საჭირო შესანახად ხასიათი.

88
00:04:48,160 --> 00:04:51,310
ყოველ float, ნამდვილი
ნომერი, იღებს ოთხი ბაიტი

89
00:04:51,310 --> 00:04:53,390
თუ ეს ორმაგი
ზუსტი მცურავი წერტილი

90
00:04:53,390 --> 00:04:56,510
ნომერი, რომელიც გაძლევთ საშუალებას
აქვს უფრო ზუსტი და მეტი ციფრები

91
00:04:56,510 --> 00:04:59,300
შემდეგ ათობითი წერტილი
დაკარგვის გარეშე სიზუსტით,

92
00:04:59,300 --> 00:05:01,820
რომელიც დასჭირდეს რვა ბაიტი მეხსიერება.

93
00:05:01,820 --> 00:05:06,730
დიდხანს longs, მართლაც დიდი რიცხვებით,
ასევე დასჭირდეს რვა ბაიტი მეხსიერება.

94
00:05:06,730 --> 00:05:09,000
რამდენი ბაიტი მეხსიერება
არ სიმები დასჭირდეს?

95
00:05:09,000 --> 00:05:12,990
ისე მოდით დააყენოს pin, რომ კითხვა
ახლა, მაგრამ ჩვენ დავბრუნდებით მას.

96
00:05:12,990 --> 00:05:17,350
>> ასე რომ თავში ეს იდეა მეხსიერება,
დიდი მასივი byte ზომის უჯრედები.

97
00:05:17,350 --> 00:05:20,871
ეს მართლაც ყველა ის არის, რომ ეს
უბრალოდ უზარმაზარი მასივი საკნები,

98
00:05:20,871 --> 00:05:23,370
ისევე, როგორც ნებისმიერი სხვა მასივი, რომ
თქვენ იცნობს და ვნახოთ,

99
00:05:23,370 --> 00:05:26,430
გარდა ყოველ ელემენტს არის ერთი ბაიტი კარს.

100
00:05:26,430 --> 00:05:30,030
და ისევე, როგორც მასივი,
ყველა ელემენტს აქვს მისამართზე.

101
00:05:30,030 --> 00:05:32,120
ყველა ელემენტს მასივი
აქვს ინდექსი, და ჩვენ

102
00:05:32,120 --> 00:05:36,302
შეგიძლიათ გამოიყენოთ ეს მაჩვენებელი უნდა გავაკეთოთ ე.წ.
წვდომის on მასივი.

103
00:05:36,302 --> 00:05:38,510
ჩვენ არ უნდა დაიწყოს
დასაწყისში მასივი,

104
00:05:38,510 --> 00:05:40,569
iterate მეშვეობით ყოველ
ერთ ელემენტს მისი,

105
00:05:40,569 --> 00:05:41,860
იპოვოს ის, რაც ჩვენ ვეძებთ.

106
00:05:41,860 --> 00:05:45,790
შეგვიძლია ვთქვათ, უბრალოდ, მინდა მისაღებად
15 ელემენტი ან 100 ელემენტს.

107
00:05:45,790 --> 00:05:49,930
და თქვენ შეგიძლიათ უბრალოდ გაივლის, რომ ნომერი
და მიიღეთ მნიშვნელობა თქვენ ეძებთ.

108
00:05:49,930 --> 00:05:54,460
>> ანალოგიურად ყველა ადგილმდებარეობა
მეხსიერება აქვს მისამართზე.

109
00:05:54,460 --> 00:05:57,320
ასე რომ, თქვენი მეხსიერება შეიძლება
ასე გამოიყურება.

110
00:05:57,320 --> 00:06:01,420
აქ არის ძალიან მცირე ბლოკი
მეხსიერება, ეს არის 20 ბაიტი მეხსიერება.

111
00:06:01,420 --> 00:06:04,060
პირველი 20 ბაიტი, რადგან ჩემი
მიმართავს იქ ბოლოში

112
00:06:04,060 --> 00:06:08,890
0, 1, 2, 3, და ასე
ყველა გზა მდე 19.

113
00:06:08,890 --> 00:06:13,190
და როცა ვაცხადებ, ცვლადები და
როცა დაიწყება მათთან მუშაობა,

114
00:06:13,190 --> 00:06:15,470
სისტემის შექმნას აპირებს
გათვალისწინებულია გარკვეული სივრცე ჩემთვის

115
00:06:15,470 --> 00:06:17,595
ამ მეხსიერების მუშაობა
ჩემი ცვლადები.

116
00:06:17,595 --> 00:06:21,610
ასე რომ, შეიძლება ითქვას, char c შეადგენს კაპიტალის
H. და რა მოხდება?

117
00:06:21,610 --> 00:06:23,880
ისე სისტემის აპირებს
გათვალისწინებულია ჩემთვის ერთი ბაიტი.

118
00:06:23,880 --> 00:06:27,870
ამ შემთხვევაში ეს აირჩია byte ნომერი
ოთხი, byte, მისამართზე ოთხი,

119
00:06:27,870 --> 00:06:31,310
და ის აპირებს შესანახად
წერილი კაპიტალის H არსებობს ჩემთვის.

120
00:06:31,310 --> 00:06:34,350
თუ მე ვთქვა int სიჩქარე
ლიმიტი შეადგენს 65, ეს

121
00:06:34,350 --> 00:06:36,806
აპირებს გათვალისწინებულია ოთხი
ბაიტი მეხსიერების ჩემთვის.

122
00:06:36,806 --> 00:06:39,180
და ის აპირებს მკურნალობა იმ
ოთხი ბაიტი, როგორც ერთი ერთეული

123
00:06:39,180 --> 00:06:41,305
რადგან ის, რაც ჩვენ ვმუშაობთ
ერთად არის მთელი რიცხვი აქ.

124
00:06:41,305 --> 00:06:44,350
და ის აპირებს შესანახად 65 იქ.

125
00:06:44,350 --> 00:06:47,000
>> ახლა უკვე მე სახის
გეუბნებოდით ცოტა ტყუილი,

126
00:06:47,000 --> 00:06:50,150
უფლება, რადგან ჩვენ ვიცით, რომ
კომპიუტერი მუშაობა ორობითი.

127
00:06:50,150 --> 00:06:53,100
მათ არ ესმით
აუცილებლად რა კაპიტალის H არის

128
00:06:53,100 --> 00:06:57,110
ან რა 65 ის არის, რომ მხოლოდ
მესმის, ორობითი, zeros და პირობა.

129
00:06:57,110 --> 00:06:59,000
ასე რომ, რეალურად, რა
ჩვენ შენახვის არსებობს

130
00:06:59,000 --> 00:07:03,450
არ არის წერილში H და ნომერი 65,
არამედ ორობითი წარმომადგენლობების

131
00:07:03,450 --> 00:07:06,980
შესახებ, რომლებიც გამოიყურება
ცოტა რაღაც მსგავსი.

132
00:07:06,980 --> 00:07:10,360
და, კერძოდ,
კონტექსტში მთელი ცვლადი,

133
00:07:10,360 --> 00:07:13,559
ის არ აპირებს, უბრალოდ შამფურზე ის შევიდა,
ის არ აპირებს მკურნალობა, როგორც ერთი ოთხი

134
00:07:13,559 --> 00:07:15,350
byte ბლოკი აუცილებლად,
ის რეალურად აპირებს

135
00:07:15,350 --> 00:07:19,570
მისი მკურნალობა, როგორც ოთხი ერთი ბაიტი მოცულობით,
რომელიც შეიძლება ასე გამოიყურება.

136
00:07:19,570 --> 00:07:22,424
და მაშინაც კი, ეს არ არის
მთლიანად ჭეშმარიტი ან,

137
00:07:22,424 --> 00:07:24,840
იმის გამო, რომ რაღაც მოუწოდა
endianness, რომელიც ჩვენ არ

138
00:07:24,840 --> 00:07:26,965
ვაპირებ შეღწევას ახლა, მაგრამ
თუ თქვენ დაინტერესდა,

139
00:07:26,965 --> 00:07:29,030
შეგიძლიათ წაიკითხოთ up პატარა
და დიდი endianness.

140
00:07:29,030 --> 00:07:31,640
მაგრამ გულისთვის ამ არგუმენტის
გულისთვის ამ ვიდეო,

141
00:07:31,640 --> 00:07:34,860
მოდით უბრალოდ ვივარაუდოთ, რომ არის,
ის ფაქტი, თუ როგორ რიცხვი 65 იქნება

142
00:07:34,860 --> 00:07:36,970
იქნება წარმოდგენილი
მეხსიერების ყოველ სისტემის,

143
00:07:36,970 --> 00:07:38,850
მიუხედავად იმისა, რომ ეს მთლად ასე არ არის.

144
00:07:38,850 --> 00:07:41,700
>> მაგრამ მოდით რეალურად მხოლოდ მისაღებად
მოისპოს ყველა ორობითი მთლიანად,

145
00:07:41,700 --> 00:07:44,460
და მხოლოდ ვიფიქროთ, როგორც H
65, ეს ბევრად უფრო ადვილია,

146
00:07:44,460 --> 00:07:47,900
უნდა ვიფიქროთ, რომ, როგორც
რომ როგორც ადამიანის.

147
00:07:47,900 --> 00:07:51,420
ყველა უფლება, ასე რომ, როგორც ჩანს, შესაძლოა,
პატარა შემთხვევითი, რომ I've- ჩემი სისტემა

148
00:07:51,420 --> 00:07:55,130
არ მაძლევს bytes 5, 6, 7,
და 8 შესანახად რიცხვი.

149
00:07:55,130 --> 00:07:58,580
არ არსებობს მიზეზი, რომ, ძალიან, რომელიც
ჩვენ არ მოხვდება ახლა, მაგრამ საკმარისია

150
00:07:58,580 --> 00:08:00,496
იმის თქმა, რომ ის, რაც
კომპიუტერი აკეთებს აქ

151
00:08:00,496 --> 00:08:02,810
ალბათ კარგი ნაბიჯი მისი ნაწილი.

152
00:08:02,810 --> 00:08:06,020
იმისათვის, რომ არ მომეცი მეხსიერება, რომ
აუცილებლად თავში დაბრუნება.

153
00:08:06,020 --> 00:08:10,490
მიუხედავად იმისა, რომ ის აპირებს ამის გაკეთება ახლა
თუ მინდა, რომ კიდევ ერთი ტექსტი,

154
00:08:10,490 --> 00:08:13,080
მოუწოდა გვარი, და მე მინდა,
იმისათვის, რომ Lloyd არსებობს.

155
00:08:13,080 --> 00:08:18,360
მე ვაპირებ უნდა ჯდება ერთი
ხასიათი, ყოველ წერილს, რომ

156
00:08:18,360 --> 00:08:21,330
აპირებს მოითხოვოს ერთი
ხასიათი, ერთი ბაიტი მეხსიერება.

157
00:08:21,330 --> 00:08:26,230
ასე რომ, თუ მე ვერ დააყენა Lloyd ჩემი მასივი
მოსწონს ეს მე საკმაოდ კარგი წასვლა, არა?

158
00:08:26,230 --> 00:08:28,870
რა აკლია?

159
00:08:28,870 --> 00:08:31,840
>> გახსოვდეთ, რომ ყოველი სტრიქონი ჩვენ ვმუშაობთ
ერთად C მთავრდება წარმატებული ნულოვანი,

160
00:08:31,840 --> 00:08:33,339
და ჩვენ ვერ გამომრჩეს, რომ აქ, ან.

161
00:08:33,339 --> 00:08:36,090
ჩვენ უნდა გათვალისწინებულია ერთი ბაიტი
მეხსიერების გამართავს, რომ ასე რომ, ჩვენ

162
00:08:36,090 --> 00:08:39,130
იცით, როდესაც ჩვენი სიმებიანი დასრულდა.

163
00:08:39,130 --> 00:08:41,049
ასე რომ კიდევ ერთხელ ამ შეთანხმებას
გზა რამ

164
00:08:41,049 --> 00:08:42,799
როგორც ჩანს, მეხსიერების შეიძლება
იყოს ცოტა შემთხვევითი,

165
00:08:42,799 --> 00:08:44,870
მაგრამ ის რეალურად არის, თუ როგორ
ყველაზე სისტემები შექმნილია.

166
00:08:44,870 --> 00:08:48,330
იმისათვის, რომ ხაზის მათ up ჯერადი
ოთხი, იმის გამო, კიდევ ერთხელ

167
00:08:48,330 --> 00:08:50,080
რომ ჩვენ არ უნდა
შეღწევას ახლავე.

168
00:08:50,080 --> 00:08:53,060
მაგრამ ეს, ასე რომ საკმარისია ითქვას, რომ
მას შემდეგ, რაც ამ სამი ხაზი კოდი,

169
00:08:53,060 --> 00:08:54,810
ეს არის ის, რაც მეხსიერება შეიძლება გამოიყურებოდეს.

170
00:08:54,810 --> 00:08:58,930
თუ მე უნდა მეხსიერების ადგილებში
4, 8 და 12 გამართავს ჩემი მონაცემებით,

171
00:08:58,930 --> 00:09:01,100
ეს არის ის, რაც ჩემს მეხსიერებაში შეიძლება გამოიყურებოდეს.

172
00:09:01,100 --> 00:09:04,062
>> და მხოლოდ განსაკუთრებით
pedantic აქ, როდესაც

173
00:09:04,062 --> 00:09:06,020
ჩვენ ვსაუბრობთ მეხსიერება
მისამართები ჩვენ, როგორც წესი,

174
00:09:06,020 --> 00:09:08,390
ასე გამოყენებით თექვსმეტობითი notations.

175
00:09:08,390 --> 00:09:12,030
რატომ არ გადაიყვანოთ ყველა ამ
საწყისი ათობითი თექვსმეტობითი ნოტაცია

176
00:09:12,030 --> 00:09:15,010
მხოლოდ იმიტომ, რომ, ზოგადად,
როგორ ჩვენ ეხება მეხსიერება.

177
00:09:15,010 --> 00:09:17,880
ასე რომ, ნაცვლად იმისა, რომ 0-დან
19, რაც გვაქვს არის ნულოვანი

178
00:09:17,880 --> 00:09:20,340
x ნულოვანი მეშვეობით ნულოვანი x1 სამი.

179
00:09:20,340 --> 00:09:23,790
ეს არის 20 ბაიტი, მეხსიერება, რომ ჩვენ
არ და ჩვენ შევხედავთ ამ სურათის

180
00:09:23,790 --> 00:09:25,540
უფლება აქ.

181
00:09:25,540 --> 00:09:29,310
>> ასე რომ, ყველა, რომ მიმდინარეობს განაცხადა, მოდით
დახევას დაშორებით მეხსიერების მეორე

182
00:09:29,310 --> 00:09:30,490
და უკან მითითებას.

183
00:09:30,490 --> 00:09:32,420
აქ არის ყველაზე მნიშვნელოვანი
რამ უნდა გვახსოვდეს

184
00:09:32,420 --> 00:09:34,070
როგორც ჩვენ დაიწყოს მუშაობა მითითებას.

185
00:09:34,070 --> 00:09:36,314
მაჩვენებელი არაფერია
მეტი, ვიდრე მისამართზე.

186
00:09:36,314 --> 00:09:38,230
მე ვიტყვი კიდევ ერთხელ იმიტომ,
ის, რომ მნიშვნელოვანია,

187
00:09:38,230 --> 00:09:42,730
მომცეთ არაფერია
მეტი, ვიდრე მისამართზე.

188
00:09:42,730 --> 00:09:47,760
პოინტერები მისამართების ადგილას
მეხსიერებაში, სადაც ცვლადები ცხოვრობს.

189
00:09:47,760 --> 00:09:52,590
იცის, რომ ეს ხდება იმედია
ცოტა უფრო ადვილია მათთან მუშაობა.

190
00:09:52,590 --> 00:09:54,550
კიდევ ერთი რამ მინდა
უნდა გავაკეთოთ, არის ის, რომ სახის

191
00:09:54,550 --> 00:09:58,510
დიაგრამების ვიზუალურად წარმოადგენს რა არის
ხდება სხვადასხვა ხაზების კოდი.

192
00:09:58,510 --> 00:10:00,660
და ჩვენ ყველაფერს გავაკეთებთ ამ ორი
ჯერ მითითებას,

193
00:10:00,660 --> 00:10:03,354
და როცა ჩვენ ვსაუბრობთ დინამიური
მეხსიერების გამოყოფის ისევე.

194
00:10:03,354 --> 00:10:06,020
იმის გამო, რომ მე ვფიქრობ, რომ ეს დიაგრამა
შეიძლება იყოს განსაკუთრებით სასარგებლო.

195
00:10:06,020 --> 00:10:09,540
>> ასე რომ, თუ მე ვიტყვი, მაგალითად, int k
ჩემი კოდი, რა ხდება?

196
00:10:09,540 --> 00:10:12,524
ისე, რა, ძირითადად, ხდება
მე მიღების მეხსიერების გათვალისწინებულია ჩემთვის,

197
00:10:12,524 --> 00:10:14,690
მაგრამ მე კი არ მინდა
ვიფიქროთ, რომ, როგორც, რომ, მე

198
00:10:14,690 --> 00:10:16,300
გვსურს ვიფიქროთ, რომ, როგორც ყუთში.

199
00:10:16,300 --> 00:10:20,090
მაქვს ყუთი, და ეს
ფერადი მწვანე იმიტომ, რომ მე

200
00:10:20,090 --> 00:10:21,750
შეგიძლიათ დააყენა რიცხვებით მწვანე ყუთები.

201
00:10:21,750 --> 00:10:23,666
თუ ეს იყო ხასიათი მე
შეიძლება ჰქონდეს ცისფერ ყუთში.

202
00:10:23,666 --> 00:10:27,290
მაგრამ მე ყოველთვის ვამბობ, თუ მე შექმნის
ყუთი, რომელიც შეიძლება გამართავს რიცხვებით

203
00:10:27,290 --> 00:10:28,950
რომ ყუთი მწვანეა.

204
00:10:28,950 --> 00:10:33,020
მე და მარკერით
და ვწერ k მხარეს იგი.

205
00:10:33,020 --> 00:10:37,590
ასე რომ, მე ყუთში მოუწოდა k,
რომელშიც მე ვერ დააყენა რიცხვებით.

206
00:10:37,590 --> 00:10:41,070
ასე რომ, როდესაც ვამბობ, რომ int k, რომ
რა ხდება, ჩემი უფროსი.

207
00:10:41,070 --> 00:10:43,140
თუ მე ვიტყვი, k ტოლია ხუთ, რა ვარ მე?

208
00:10:43,140 --> 00:10:45,110
ისე, მე აყენებს ხუთ
ყუთში, მარჯვნივ.

209
00:10:45,110 --> 00:10:48,670
ეს არის საკმაოდ მარტივია, თუ
ვამბობ, რომ int k, შექმნა ყუთში მოუწოდა k.

210
00:10:48,670 --> 00:10:52,040
თუ მე ვიტყვი, k შეადგენს 5,
ბოლო ხუთი ყუთში.

211
00:10:52,040 --> 00:10:53,865
იმედია, რომ ეს არ არის ძალიან ბევრი ნახტომი.

212
00:10:53,865 --> 00:10:55,990
აქ, სადაც რამ წავიდეთ
ცოტა საინტერესო, თუმცა.

213
00:10:55,990 --> 00:11:02,590
თუ მე ვიტყვი, int * pk, კარგად კი, თუ მე არ
ვიცით, რა ეს აუცილებლად არ ნიშნავს,

214
00:11:02,590 --> 00:11:06,150
ეს აშკარად რაღაც
უნდა გავაკეთოთ რიცხვი.

215
00:11:06,150 --> 00:11:08,211
ასე რომ, მე ვაპირებ ფერი
ეს ყუთი მწვანე-ish,

216
00:11:08,211 --> 00:11:10,210
მე ვიცი, რომ რაღაც
უნდა გავაკეთოთ რიცხვი,

217
00:11:10,210 --> 00:11:13,400
მაგრამ ეს არ არის მთელი რიცხვი თავისთავად,
იმიტომ, რომ ეს int ვარსკვლავი.

218
00:11:13,400 --> 00:11:15,390
არსებობს რაღაც ოდნავ
განსხვავებული შესახებ.

219
00:11:15,390 --> 00:11:17,620
ასე რომ მთელი ის ჩართული,
მაგრამ წინააღმდეგ შემთხვევაში ეს

220
00:11:17,620 --> 00:11:19,830
არ განსხვავდება
ის, რაც ჩვენ ვსაუბრობთ.

221
00:11:19,830 --> 00:11:24,240
ეს ყუთი, მისი მივიღე ეტიკეტების,
ის ტარება იარლიყი pk,

222
00:11:24,240 --> 00:11:27,280
და ეს შეუძლია ჰოლდინგი
int ვარსკვლავი, რასაც ესენი არიან.

223
00:11:27,280 --> 00:11:29,894
მათ აქვთ რაღაც უნდა გააკეთოს
მთელი რიცხვები, ნათლად.

224
00:11:29,894 --> 00:11:31,060
აი ბოლო ხაზი თუმცა.

225
00:11:31,060 --> 00:11:37,650
თუ მე ვიტყვი PK = & k, Whoa,
რა მოხდა, არა?

226
00:11:37,650 --> 00:11:41,820
ასე რომ, ეს შემთხვევითი ნომერი, ერთი შეხედვით შემთხვევითი
ნომერი, იღებს დააგდეს შევიდა ყუთი იქ.

227
00:11:41,820 --> 00:11:44,930
ყველა, რომ არის, არის pk
იღებს მისამართი k.

228
00:11:44,930 --> 00:11:52,867
ასე რომ, მე sticking სადაც k ცხოვრობს მეხსიერება,
მისი მისამართი, მისამართი, მისი ბაიტი.

229
00:11:52,867 --> 00:11:55,200
ყველა ვაკეთებ მე ვამბობ,
რომ ღირებულება არის ის, რაც მე ვაპირებ

230
00:11:55,200 --> 00:11:59,430
იმისათვის, რომ შიგნით ჩემი ყუთში მოუწოდა pk.

231
00:11:59,430 --> 00:12:02,080
და რადგან ეს ყველაფერი
პოინტერები, და რადგან ეძებს

232
00:12:02,080 --> 00:12:04,955
სიმებიანი როგორიცაა ნულოვანი x
რვა ნულოვანი გ შვიდი ოთხი რვა

233
00:12:04,955 --> 00:12:07,790
ორი ნულოვანი, ალბათ,
არ არის ძალიან მნიშვნელოვანი.

234
00:12:07,790 --> 00:12:12,390
როდესაც ჩვენ, როგორც წესი, ვიზუალურად მითითებას,
ჩვენ რეალურად ამის გაკეთება, როგორც მითითებას.

235
00:12:12,390 --> 00:12:17,000
Pk გვაძლევს ინფორმაცია
ჩვენ უნდა მოვძებნოთ k მეხსიერებაში.

236
00:12:17,000 --> 00:12:19,120
ასე რომ, ძირითადად pk აქვს ისარი იგი.

237
00:12:19,120 --> 00:12:21,670
და თუ ჩვენ ფეხით ხანგრძლივობა
ისრის, წარმოიდგინეთ,

238
00:12:21,670 --> 00:12:25,280
ეს რაღაც შეგიძლიათ სიარული, თუ ჩვენ
ფეხით გასწვრივ სიგრძეზე arrow,

239
00:12:25,280 --> 00:12:29,490
ძალიან წვერი რომ ისარი, ჩვენ
ნახავთ განთავსების მეხსიერება

240
00:12:29,490 --> 00:12:31,390
სადაც K ცხოვრობს.

241
00:12:31,390 --> 00:12:34,360
და, ეს ძალიან მნიშვნელოვანია
იმიტომ, რომ ერთხელ ჩვენ ვიცით, სადაც k ცხოვრობს,

242
00:12:34,360 --> 00:12:37,870
ჩვენ შეგვიძლია დავიწყოთ მუშაობა მონაცემები
შიგნით რომ მეხსიერებაში.

243
00:12:37,870 --> 00:12:40,780
მიუხედავად იმისა, რომ ჩვენ ვიღებთ teeny
ცოტა ადრე საკუთარ თავს ახლა.

244
00:12:40,780 --> 00:12:42,240
>> რა არის მაჩვენებელი?

245
00:12:42,240 --> 00:12:45,590
მაჩვენებელი არის მონაცემთა ნივთი, რომლის
მნიშვნელობა მეხსიერების მისამართზე.

246
00:12:45,590 --> 00:12:49,740
ეს იყო, რომ ნულოვანი x რვა ნულოვანი პერსონალი
ხდება, რომ იყო მეხსიერებაში მისამართზე.

247
00:12:49,740 --> 00:12:52,060
ეს იყო განთავსების მეხსიერებაში.

248
00:12:52,060 --> 00:12:55,080
და ტიპის მაჩვენებელი
აღწერს

249
00:12:55,080 --> 00:12:56,930
მონაცემთა თქვენ იპოვით
რომ მეხსიერების მისამართი.

250
00:12:56,930 --> 00:12:58,810
ასე რომ არსებობს int ვარსკვლავი ნაწილი უფლება.

251
00:12:58,810 --> 00:13:03,690
თუ მე დაიცვას, რომ ისარი,
აპირებს გამოიწვიოს ჩემთვის ადგილმდებარეობა.

252
00:13:03,690 --> 00:13:06,980
და რომ ადგილმდებარეობა, რაც მე
ნახავთ იქ ჩემი მაგალითად,

253
00:13:06,980 --> 00:13:08,240
არის მწვანე ფერის ყუთში.

254
00:13:08,240 --> 00:13:12,650
ეს არის რიცხვი, რომ ის, რაც მე
ნახავთ, თუ მე ამ მისამართზე.

255
00:13:12,650 --> 00:13:14,830
მონაცემები ტიპის
მაჩვენებელი აღწერს, თუ რა

256
00:13:14,830 --> 00:13:17,936
თქვენ ნახავთ, რომ მეხსიერების მისამართზე.

257
00:13:17,936 --> 00:13:19,560
ასე რომ აქ მართლაც მაგარი რამ, თუმცა.

258
00:13:19,560 --> 00:13:25,090
პოინტერები საშუალებას გვაძლევს გაივლის
ცვლადები შორის ფუნქციები.

259
00:13:25,090 --> 00:13:28,520
და რეალურად გაივლის ცვლადები
და არ გაივლის ასლები მათ.

260
00:13:28,520 --> 00:13:32,879
იმიტომ, რომ თუ ჩვენ ზუსტად ვიცით, სად
მეხსიერების მოძიების ცვლადი,

261
00:13:32,879 --> 00:13:35,670
ჩვენ არ უნდა მიიღოს ასლი
ის, რომ ჩვენ შეგვიძლია წავიდეთ, რომ ადგილმდებარეობა

262
00:13:35,670 --> 00:13:37,844
და მუშაობა, რომ ცვლადი.

263
00:13:37,844 --> 00:13:40,260
ასე რომ, არსებითად მითითებას სახის
საქართველოს კომპიუტერულ გარემო

264
00:13:40,260 --> 00:13:42,360
ბევრი უფრო რეალურ სამყაროში, მარჯვნივ.

265
00:13:42,360 --> 00:13:44,640
>> ასე რომ, აქ ანალოგია.

266
00:13:44,640 --> 00:13:48,080
ვთქვათ, რომ მე მაქვს ლეპტოპი,
უფლება, და ეს სრული აღნიშნავს.

267
00:13:48,080 --> 00:13:50,230
და მე მინდა თქვენ უნდა განაახლოს იგი.

268
00:13:50,230 --> 00:13:53,960
თქვენ ხართ ფუნქცია, რომელიც
განახლებები აღნიშნავს, მარჯვნივ.

269
00:13:53,960 --> 00:13:56,390
ამ გზით ჩვენ უკვე
სამუშაო ჯერჯერობით, რა

270
00:13:56,390 --> 00:14:02,370
ხდება თქვენ მიიღებს ჩემი ნოუთბუქი,
თქვენ გადადით ასლი მაღაზია,

271
00:14:02,370 --> 00:14:06,410
თქვენ მიიღოს Xerox ასლი
ყველა გვერდზე ნოუთბუქი.

272
00:14:06,410 --> 00:14:09,790
თქვენ დავტოვებთ ჩემი ნოუთბუქი უკან
ჩემს მაგიდასთან, როდესაც თქვენ გაკეთდეს,

273
00:14:09,790 --> 00:14:14,600
თქვენ წავიდეთ და გადაკვეთა რამ ჩემს
ნოუთბუქის რომ მოძველებულია ან არასწორი,

274
00:14:14,600 --> 00:14:19,280
და მაშინ თქვენ გაივლის დაბრუნება
მე დასტის Xerox გვერდები

275
00:14:19,280 --> 00:14:22,850
რომ არის რეპლიკა ჩემი ნოუთბუქი
ცვლილებები, რომ თქვენ გააკეთა ეს.

276
00:14:22,850 --> 00:14:27,040
და იმ ეტაპზე, ეს იყო ჩემთვის, როგორც
მოუწოდებდა ფუნქცია, როგორც აბონენტის,

277
00:14:27,040 --> 00:14:30,582
გადაწყვიტოს, მიიღოს თქვენი შენიშვნები და
მათ ინტეგრაციას ისევ ჩემი ნოუთბუქი.

278
00:14:30,582 --> 00:14:32,540
ასე რომ, არსებობს ბევრი ნაბიჯები
ჩართული აქ, მარჯვნივ.

279
00:14:32,540 --> 00:14:34,850
ისევე, როგორც არ იქნება უკეთესი
თუ მე უბრალოდ ამბობენ, hey, შეგიძლიათ

280
00:14:34,850 --> 00:14:38,370
ჩემ ნოუთბუქი
მე, გადასცემს თქვენ ჩემი ნოუთბუქი,

281
00:14:38,370 --> 00:14:40,440
და შენ რამ და
ფაქტიურად გადაკვეთა მათ

282
00:14:40,440 --> 00:14:42,810
განახლება და ჩემი შენიშვნები ნოუთბუქი.

283
00:14:42,810 --> 00:14:45,140
და მაშინ მაძლევს ჩემი ნოუთბუქი უკან.

284
00:14:45,140 --> 00:14:47,320
ეს არის ერთგვარი რა
პოინტერები საშუალებას გვაძლევს გავაკეთოთ,

285
00:14:47,320 --> 00:14:51,320
ისინი ამ გარემოში ბევრი
უფრო მოსწონს თუ როგორ ფუნქციონირებს რეალურად.

286
00:14:51,320 --> 00:14:54,640
>> ყველა უფლება ისე, რომ ის, რაც
კურსორი, მოდით ვისაუბროთ

287
00:14:54,640 --> 00:14:58,040
იმაზე, თუ როგორ პოინტერები მუშაობა C, და
როგორ შეგვიძლია დაიწყოს მათთან მუშაობა.

288
00:14:58,040 --> 00:15:02,550
ასე რომ, არსებობს ძალიან მარტივი მაჩვენებელი
დო მოუწოდა null მაჩვენებელი.

289
00:15:02,550 --> 00:15:04,830
Null მაჩვენებელი რაოდენობა არაფერია.

290
00:15:04,830 --> 00:15:08,310
ეს, ალბათ, როგორც ჩანს, ეს არის
ფაქტობრივად, არ არის ძალიან სასარგებლო რამ,

291
00:15:08,310 --> 00:15:10,500
მაგრამ, როგორც ვნახავთ,
ცოტა მოგვიანებით, ის ფაქტი,

292
00:15:10,500 --> 00:15:15,410
რომ ეს null მაჩვენებელი არსებობს
რეალურად მოდის მოსახერხებელია.

293
00:15:15,410 --> 00:15:19,090
და როდესაც თქვენ შექმნით მაჩვენებელი, და
თქვენ არ მისი ღირებულება immediately-

294
00:15:19,090 --> 00:15:21,060
მაგალითად შექმნის
მისი ღირებულება დაუყოვნებლივ

295
00:15:21,060 --> 00:15:25,401
იქნება რამდენიმე სლაიდები უკან
სადაც მე ვთქვი pk ტოლია & k,

296
00:15:25,401 --> 00:15:28,740
pk იღებს k მისამართი, რადგან
ჩვენ დავინახავთ, რას ნიშნავს,

297
00:15:28,740 --> 00:15:32,990
ჩვენ დავინახავთ, თუ როგორ კოდი, რომელიც shortly-
თუ ჩვენ არ მისი ღირებულება, რომ რაღაც

298
00:15:32,990 --> 00:15:35,380
მნიშვნელოვანი დაუყოვნებლივ,
თქვენ ყოველთვის უნდა

299
00:15:35,380 --> 00:15:37,480
მითითებული თქვენი მომცეთ აღვნიშნო, რომ null.

300
00:15:37,480 --> 00:15:40,260
თქვენ უნდა მითითებული ეს აღვნიშნო, რომ არაფერი.

301
00:15:40,260 --> 00:15:43,614
>> ეს არის ძალიან განსხვავებული, ვიდრე
უბრალოდ ტოვებს მნიშვნელობა, რადგან ეს არის

302
00:15:43,614 --> 00:15:45,530
და შემდეგ გამოცხადების
მაჩვენებელი და მხოლოდ ვთქვათ,

303
00:15:45,530 --> 00:15:48,042
ეს null იმიტომ, რომ იშვიათად მართალია.

304
00:15:48,042 --> 00:15:50,000
ასე, რომ თქვენ ყოველთვის უნდა მითითებული
ღირებულება მომცეთ

305
00:15:50,000 --> 00:15:55,690
, null, თუ არ მისი ღირებულება
რაღაც მნიშვნელოვანი დაუყოვნებლივ.

306
00:15:55,690 --> 00:15:59,090
თქვენ შეგიძლიათ შეამოწმოთ თუ არა მაჩვენებელი ღირებულების
არის null გამოყენებით თანასწორობის ოპერატორს

307
00:15:59,090 --> 00:16:05,450
(==), ისევე, როგორც თქვენ შედარების ნებისმიერი რიცხვი
ღირებულებები ან ხასიათი ღირებულებების გამოყენებით (==)

308
00:16:05,450 --> 00:16:06,320
ისევე.

309
00:16:06,320 --> 00:16:10,994
ეს არის განსაკუთრებული სახის მუდმივი
მნიშვნელობა, რომელიც შეგიძლიათ გამოიყენოთ, რათა გამოსცადოს.

310
00:16:10,994 --> 00:16:13,160
ასე რომ, ძალიან მარტივი
მაჩვენებელი, null მაჩვენებელი.

311
00:16:13,160 --> 00:16:15,320
კიდევ ერთი გზა, რათა შეიქმნას
კურსორი არის ამონაწერი

312
00:16:15,320 --> 00:16:18,240
მისამართი ცვლადი
თქვენ უკვე შექმნილია,

313
00:16:18,240 --> 00:16:22,330
და თქვენ ამ გამოყენებით და
ოპერატორი მისამართი მოპოვება.

314
00:16:22,330 --> 00:16:26,720
რომელ ჩვენ უკვე მინახავს ადრე
პირველი სქემა მაგალითი მე აჩვენა.

315
00:16:26,720 --> 00:16:31,450
ასე რომ, თუ x არის ცვლადი, რომელიც ჩვენ
უკვე შეიქმნა ტიპის რიცხვი,

316
00:16:31,450 --> 00:16:35,110
მაშინ და x არის მაჩვენებელი რიცხვი.

317
00:16:35,110 --> 00:16:39,810
& x არის- მახსოვს, და აპირებს ამონაწერი
მისამართი რამ უფლება.

318
00:16:39,810 --> 00:16:45,350
მას შემდეგ, რაც კურსორი არის უბრალოდ მისამართი,
მეტი და x არის მომცეთ მთელი რიცხვი

319
00:16:45,350 --> 00:16:48,560
რომლის ღირებულება არის სადაც მეხსიერება x ცხოვრება.

320
00:16:48,560 --> 00:16:50,460
ეს x მისამართი.

321
00:16:50,460 --> 00:16:53,296
ასე რომ, და x არის მისამართი x.

322
00:16:53,296 --> 00:16:55,670
მოდით ეს ერთი ნაბიჯია
შემდგომი დაკავშირება და რაღაც

323
00:16:55,670 --> 00:16:58,380
მე გააკეთა მინიშნება, რომ წინასწარი ვიდეო.

324
00:16:58,380 --> 00:17:06,730
თუ arr მასივი ორადგილიანი, მაშინ
და arr კვადრატული ფრჩხილი i მომცეთ

325
00:17:06,730 --> 00:17:08,109
ორმაგი.

326
00:17:08,109 --> 00:17:08,970
OK.

327
00:17:08,970 --> 00:17:12,160
სია თურქეთიდან კვადრატული ფრჩხილი i, თუ
arr მასივი ორადგილიანი,

328
00:17:12,160 --> 00:17:19,069
მაშინ სია თურქეთიდან კვადრატული ფრჩხილი ი
i-th ელემენტია, რომ მასივი,

329
00:17:19,069 --> 00:17:29,270
და & სია თურქეთიდან კვადრატული ფრჩხილი i არის სადაც
მეხსიერების i-ე ელემენტს arr არსებობს.

330
00:17:29,270 --> 00:17:31,790
>> ასე რომ, რა მნიშვნელობა აქ?

331
00:17:31,790 --> 00:17:34,570
კოლექტორები სახელი, გულისხმობს
ამ მთელი რამ,

332
00:17:34,570 --> 00:17:39,290
ის არის, რომ მასივი სახელი
რეალურად თავად მაჩვენებელი.

333
00:17:39,290 --> 00:17:41,170
თქვენ უკვე მუშაობს
პოინტერები ყველა ერთად

334
00:17:41,170 --> 00:17:45,290
ყოველ ჯერზე, რომ თქვენ გამოყენებული მასივი.

335
00:17:45,290 --> 00:17:49,090
დამახსოვრება მაგალითზე
ცვლადი ფარგლებში,

336
00:17:49,090 --> 00:17:53,420
ახლოს დასასრულს ვიდეო წარმოგიდგენთ
მაგალითად, სადაც ჩვენ გვაქვს ფუნქცია

337
00:17:53,420 --> 00:17:56,890
მოუწოდა კომპლექტი int და
ფუნქცია მოუწოდა კომპლექტი მასივი.

338
00:17:56,890 --> 00:18:00,490
და თქვენი გამოწვევა, რათა დადგინდეს,
თუ არა, ან რა

339
00:18:00,490 --> 00:18:03,220
ფასეულობები, რომელიც ჩვენ იბეჭდება
ბოლოს ფუნქცია,

340
00:18:03,220 --> 00:18:05,960
ბოლოს ძირითადი პროგრამა.

341
00:18:05,960 --> 00:18:08,740
>> თუ გავიხსენებთ, რომ, მაგალითად,
ან თუ ვნახე ვიდეო,

342
00:18:08,740 --> 00:18:13,080
თქვენ იცით, რომ როდესაც თქვენ-ზარი
კომპლექტი int ეფექტურად არაფერს აკეთებს.

343
00:18:13,080 --> 00:18:16,390
მაგრამ ზარის შექმნას მასივი აკეთებს.

344
00:18:16,390 --> 00:18:19,280
და მე ერთგვარი დიდწილად მეტი რატომ
რომ იყო შემთხვევა იმ დროს.

345
00:18:19,280 --> 00:18:22,363
მე უბრალოდ ვთქვი, რომ ეს მასივი, ეს
სპეციალური, თქვენ იცით, არ არსებობს მიზეზი.

346
00:18:22,363 --> 00:18:25,020
ამის მიზეზი ის არის, რომ მასივი მიერ
სახელი მართლაც მხოლოდ მაჩვენებელი,

347
00:18:25,020 --> 00:18:28,740
და არსებობს ამ სპეციალური
კვადრატული ფრჩხილი სინტაქსი, რომ

348
00:18:28,740 --> 00:18:30,510
რათა რამ ბევრი გავალამაზოთ მუშაობა.

349
00:18:30,510 --> 00:18:34,410
და ისინი იდეა
მაჩვენებელი ბევრი ნაკლებად დაშინებას,

350
00:18:34,410 --> 00:18:36,800
და ამიტომაც ისინი ერთგვარი
წარმოდგენილი, რომ გზა.

351
00:18:36,800 --> 00:18:38,600
მაგრამ ნამდვილად კოლექტორები მხოლოდ მითითებას.

352
00:18:38,600 --> 00:18:41,580
და ამიტომაც, როდესაც ჩვენ
ცვლილება მასივი,

353
00:18:41,580 --> 00:18:44,880
როდესაც ჩვენ გავიდა მასივი, როგორც პარამეტრი
ფუნქცია ან როგორც არგუმენტი

354
00:18:44,880 --> 00:18:50,110
ფუნქცია, შინაარსი მასივი
რეალურად შეიცვალა, როგორც Callee

355
00:18:50,110 --> 00:18:51,160
და აბონენტის.

356
00:18:51,160 --> 00:18:55,846
რომელიც ყველა სხვა სახის
ცვლადი ჩვენ ვნახეთ არ იყო საქმე.

357
00:18:55,846 --> 00:18:58,970
ასე რომ, უბრალოდ რაღაც შენარჩუნება
იბადება, როდესაც თქვენ მუშაობა მითითებას,

358
00:18:58,970 --> 00:19:01,610
ის არის, რომ სახელი და გვარი
მასივი, ფაქტობრივად, მომცეთ

359
00:19:01,610 --> 00:19:04,750
პირველი ელემენტი, რომელიც მასივი.

360
00:19:04,750 --> 00:19:08,930
>> OK ასე რომ, ახლა ჩვენ ყველა ამ
ფაქტები, მოდით შენარჩუნებას აპირებს, მარჯვნივ.

361
00:19:08,930 --> 00:19:11,370
რატომ აინტერესებს
სადაც რაღაც ცხოვრობს.

362
00:19:11,370 --> 00:19:14,120
ისე როგორც მე ვთქვი, რომ ეს არის საკმაოდ
სასარგებლო იცოდეს, სადაც რაღაც ცხოვრობს

363
00:19:14,120 --> 00:19:17,240
ასე რომ თქვენ შეგიძლიათ იქ და შეცვლის.

364
00:19:17,240 --> 00:19:19,390
მუშაობა და რეალურად
აქვს ის, რომ თქვენ

365
00:19:19,390 --> 00:19:23,710
მინდა ამის გაკეთება, რომ ცვლადი ძალაში,
და არ შევა რამდენიმე ასლი.

366
00:19:23,710 --> 00:19:26,150
ეს ეწოდება dereferencing.

367
00:19:26,150 --> 00:19:28,690
ჩვენ წასვლა მინიშნება და
შევცვალოთ ღირებულება არსებობს.

368
00:19:28,690 --> 00:19:32,660
ასე რომ, თუ ჩვენ გვაქვს მაჩვენებელი და ეს ე.წ.
კომპიუტერი, და ეს მიუთითებს, რომ ხასიათი,

369
00:19:32,660 --> 00:19:40,610
მაშინ შეგვიძლია ვთქვათ * კომპიუტერი და * pc არის
სახელი, რაც ჩვენ იპოვით, თუ ჩვენ

370
00:19:40,610 --> 00:19:42,910
მითითებულ მისამართზე pc.

371
00:19:42,910 --> 00:19:47,860
ის, რასაც ჩვენ იპოვით არსებობს ხასიათი და
* pc არის, თუ როგორ ეხება მონაცემები, რომ

372
00:19:47,860 --> 00:19:48,880
ადგილმდებარეობა.

373
00:19:48,880 --> 00:19:54,150
ასე რომ, ჩვენ შეიძლება ითქვას, რაღაც
* pc = D ან რამე მაგდაგვარს,

374
00:19:54,150 --> 00:19:59,280
და ეს ნიშნავს, რომ რაც არ უნდა
იყო მეხსიერების მისამართი pc,

375
00:19:59,280 --> 00:20:07,040
რასაც გმირი იყო ადრე
იქ, ახლა D, თუ ვამბობთ * pc = D.

376
00:20:07,040 --> 00:20:10,090
>> ასე რომ, აქ ჩვენ კვლავ ერთად
რაღაც უცნაური C პერსონალი, მარჯვნივ.

377
00:20:10,090 --> 00:20:14,560
ასე რომ, ჩვენ ვნახეთ * ადრე, როგორც
როგორღაც ნაწილი მონაცემები ტიპის,

378
00:20:14,560 --> 00:20:17,160
და ახლა ის გამოიყენება
ოდნავ სხვა კონტექსტში

379
00:20:17,160 --> 00:20:19,605
წვდომის მონაცემები ადგილმდებარეობა.

380
00:20:19,605 --> 00:20:22,480
მე ვიცი, რომ ეს ცოტა გაუგებარია და
რომ რეალურად ნაწილი მთელი ეს

381
00:20:22,480 --> 00:20:25,740
, რატომ მითითებას აქვს ამ მითოლოგია
მათ გარშემო, როგორც იმდენად რთული,

382
00:20:25,740 --> 00:20:28,250
სახის syntax პრობლემა, პატიოსნად.

383
00:20:28,250 --> 00:20:31,810
მაგრამ * გამოიყენება როგორც კონტექსტში,
როგორც ნაწილი ტიპის სახელი,

384
00:20:31,810 --> 00:20:34,100
და ვნახავთ ცოტა
შემდეგ რაღაც, ძალიან.

385
00:20:34,100 --> 00:20:36,490
და ახლა არის
dereference ოპერატორი.

386
00:20:36,490 --> 00:20:38,760
ასე რომ, ის მიდის მინიშნება,
ის იღებს მონაცემებს

387
00:20:38,760 --> 00:20:43,000
ადგილმდებარეობის მაჩვენებელი, და
გაძლევთ საშუალებას მანიპულირება სურვილისამებრ.

388
00:20:43,000 --> 00:20:45,900
>> ახლა ეს ძალიან ჰგავს
გამოჩენის თქვენი მეზობელი, მარჯვნივ.

389
00:20:45,900 --> 00:20:48,710
თუ თქვენ არ იცით
მეზობელი ცხოვრობს, თქვენ

390
00:20:48,710 --> 00:20:50,730
არ დაკიდებული თქვენი მეზობელი.

391
00:20:50,730 --> 00:20:53,510
თქვენ იცით, რომ თქვენ არ უნდა
ვიცი, სადაც ისინი ცხოვრობენ,

392
00:20:53,510 --> 00:20:56,870
მაგრამ ეს არ ნიშნავს, რომ
ძალით, რომელსაც, რომ ცოდნა

393
00:20:56,870 --> 00:20:59,170
თქვენ ინტერაქციაში მათ.

394
00:20:59,170 --> 00:21:01,920
თუ გსურთ ურთიერთქმედება მათ,
თქვენ უნდა წავიდეს საკუთარი სახლი,

395
00:21:01,920 --> 00:21:03,760
თქვენ უნდა წავიდეს, სადაც ისინი ცხოვრობენ.

396
00:21:03,760 --> 00:21:07,440
და კიდევ თქვენ, რომ,
მაშინ თქვენ შეგიძლიათ ურთიერთქმედება

397
00:21:07,440 --> 00:21:09,420
მათ ისევე, როგორც თქვენ მინდა.

398
00:21:09,420 --> 00:21:12,730
და ანალოგიურად ცვლადები,
თქვენ უნდა წასვლა მათი მისამართი

399
00:21:12,730 --> 00:21:15,320
თუ გსურთ ურთიერთქმედება მათ,
თქვენ არ შეგიძლიათ უბრალოდ ვიცი მისამართზე.

400
00:21:15,320 --> 00:21:21,495
და ისე წასვლა მისამართი
გამოყენება *, dereference ოპერატორი.

401
00:21:21,495 --> 00:21:23,620
როგორ ფიქრობთ, რა ხდება
თუ ჩვენ ვცდილობთ და dereference

402
00:21:23,620 --> 00:21:25,260
მაჩვენებელი, რომლის ღირებულება არის null?

403
00:21:25,260 --> 00:21:28,470
შეგახსენებთ, რომ null
მაჩვენებელი მიუთითებს, რომ არაფერი.

404
00:21:28,470 --> 00:21:34,110
ასე რომ, თუ თქვენ ცდილობენ და dereference
არაფერი ან გადადით მისამართზე არაფერი,

405
00:21:34,110 --> 00:21:36,800
როგორ ფიქრობთ რა ხდება?

406
00:21:36,800 --> 00:21:39,630
ისე, თუ მიხვდა, სეგმენტაცია
ბრალია, ნეტავ იყოს სწორი.

407
00:21:39,630 --> 00:21:41,390
თუ თქვენ ცდილობენ და dereference
null მაჩვენებელი,

408
00:21:41,390 --> 00:21:43,140
თქვენ განიცდიან სეგმენტაცია
ბრალია. მაგრამ დაველოდოთ,

409
00:21:43,140 --> 00:21:45,820
არ მინდა, გითხრათ, რომ
თუ თქვენ არ აპირებს

410
00:21:45,820 --> 00:21:49,220
მითითებული თქვენი ღირებულება თქვენი
მომცეთ რაიმე მნიშვნელოვანი,

411
00:21:49,220 --> 00:21:51,000
თქვენ უნდა მითითებული null?

412
00:21:51,000 --> 00:21:55,290
მე და რეალურად სეგმენტაცია
ბრალი არის ერთგვარი კარგი საქციელი.

413
00:21:55,290 --> 00:21:58,680
>> ოდესმე განაცხადა ცვლადი და
არ არის დანიშნული, მისი ღირებულება მაშინვე?

414
00:21:58,680 --> 00:22:02,680
ასე, რომ თქვენ, უბრალოდ, ვამბობთ int x; თქვენ არ
რეალურად მივანიჭოთ მას არაფერი

415
00:22:02,680 --> 00:22:05,340
და შემდეგ მოგვიანებით თქვენი კოდი,
თქვენ ამობეჭდოთ ღირებულება x,

416
00:22:05,340 --> 00:22:07,650
რომელსაც ჯერ კიდევ არ არის
ენიჭება მას არაფერი.

417
00:22:07,650 --> 00:22:10,370
ხშირად თქვენ მიიღებთ
ნულოვანი, მაგრამ ზოგჯერ

418
00:22:10,370 --> 00:22:15,000
შესაძლოა, შემთხვევითი ნომერი, და
თქვენ არ ვიცი, სადაც იგი მოვიდა.

419
00:22:15,000 --> 00:22:16,750
ანალოგიურად შეუძლია რამ
მოხდება მითითებას.

420
00:22:16,750 --> 00:22:20,110
როდესაც თქვენ გამოაცხადოს მაჩვენებელი
int * pk მაგალითად,

421
00:22:20,110 --> 00:22:23,490
და თქვენ არ მივანიჭოთ მას მნიშვნელობა,
თქვენ ოთხი ბაიტი მეხსიერება.

422
00:22:23,490 --> 00:22:25,950
როგორიც არ უნდა იყოს ოთხი ბაიტი
მეხსიერების სისტემას შეუძლია

423
00:22:25,950 --> 00:22:28,970
ნახავთ, რომ აქვს რამდენიმე მნიშვნელოვანი ღირებულება.

424
00:22:28,970 --> 00:22:31,760
და არ შეიძლება ყოფილიყო
რაღაც უკვე არსებობს, რომ

425
00:22:31,760 --> 00:22:34,190
აღარ არის საჭირო სხვა
ფუნქცია, ასე რომ თქვენ უბრალოდ უნდა

426
00:22:34,190 --> 00:22:35,900
რასაც მონაცემები იყო.

427
00:22:35,900 --> 00:22:40,570
>> რა მოხდება, თუ თქვენ სცადა ამის გაკეთება dereference
ზოგიერთი მისამართზე, რომელიც თქვენ don't- იყო

428
00:22:40,570 --> 00:22:43,410
უკვე bytes და ინფორმაციის
არსებობს, რომ ახლა თქვენს მაჩვენებელი.

429
00:22:43,410 --> 00:22:47,470
თუ თქვენ ცდილობენ და dereference რომ მომცეთ,
თქვენ შეიძლება ძვირფასი გარკვეული მეხსიერება

430
00:22:47,470 --> 00:22:49,390
რომ არ აპირებს
სასადილო ერთად ეს ყველაფერი.

431
00:22:49,390 --> 00:22:51,639
და რეალურად თქვენ ვერ გააკეთებს
მართლაც რაღაც დამანგრეველი,

432
00:22:51,639 --> 00:22:54,880
ისევე როგორც დაარღვიოს სხვა პროგრამა,
ან შესვენება სხვა ფუნქცია,

433
00:22:54,880 --> 00:22:58,289
ან რაიმე მუქარის, რომ
თქვენ არ აპირებენ ამის ყველა.

434
00:22:58,289 --> 00:23:00,080
და ისე, რომ, თუ რატომ არის
რეალურად კარგი იდეა

435
00:23:00,080 --> 00:23:04,030
მითითებული თქვენი მითითებას null თუ
არ მითითებული მათ რაღაც მნიშვნელოვანი.

436
00:23:04,030 --> 00:23:06,760
ეს, ალბათ, უკეთ
დღის ბოლოს თქვენი პროგრამა

437
00:23:06,760 --> 00:23:09,840
ავარიის შემდეგ ეს უნდა გააკეთოს
ის, რომ ხრახნები

438
00:23:09,840 --> 00:23:12,400
კიდევ ერთი პროგრამა ან სხვა ფუნქცია.

439
00:23:12,400 --> 00:23:15,207
ეს საქციელი ალბათ კი
ნაკლებად იდეალური, ვიდრე უბრალოდ crashing.

440
00:23:15,207 --> 00:23:17,040
და ისე, რომ, თუ რატომ არის
რეალურად კარგი ჩვევა

441
00:23:17,040 --> 00:23:20,920
შეღწევას შექმნას თქვენი პოინტერები
, null, თუ არ შეიქმნა მათ

442
00:23:20,920 --> 00:23:24,540
სრულფასოვანი მნიშვნელობა
დაუყოვნებლივ, მნიშვნელობა, რომ თქვენ იცით,

443
00:23:24,540 --> 00:23:27,260
და რომ თქვენ შეგიძლიათ უსაფრთხოდ dereference.

444
00:23:27,260 --> 00:23:32,240
>> მოდით ახლა და შევხედოთ
საყოველთაო სინტაქსი სიტუაცია.

445
00:23:32,240 --> 00:23:37,400
თუ მე ვიტყვი, int * p ;, რა მე უბრალოდ გაკეთდეს?

446
00:23:37,400 --> 00:23:38,530
რა მე ვაკეთებ ამ.

447
00:23:38,530 --> 00:23:43,290
მე ვიცი, ღირებულება p არის მისამართი
იმიტომ, რომ ყველა მითითებები მხოლოდ

448
00:23:43,290 --> 00:23:44,660
მისამართები.

449
00:23:44,660 --> 00:23:47,750
შემიძლია dereference p
გამოყენებით * ოპერატორი.

450
00:23:47,750 --> 00:23:51,250
ამ კონტექსტში აქ, ძალიან
დაბრუნება გავიხსენოთ * ნაწილია ტიპის.

451
00:23:51,250 --> 00:23:53,510
Int * მონაცემები ტიპის.

452
00:23:53,510 --> 00:23:56,150
მაგრამ მე შემიძლია dereference
p გამოყენებით * ოპერატორი,

453
00:23:56,150 --> 00:24:01,897
და თუ მე ამის გაკეთება, თუ მე რომ მისამართი,
რა იქნება მე რომ მისამართი?

454
00:24:01,897 --> 00:24:02,855
მე ნახავთ რიცხვი.

455
00:24:02,855 --> 00:24:05,910
ასე int * p ძირითადად
ამბობდა, p არის მისამართი.

456
00:24:05,910 --> 00:24:09,500
შემიძლია dereference p და თუ
მე, მე ნახავთ რიცხვი

457
00:24:09,500 --> 00:24:11,920
რომ მეხსიერებაში.

458
00:24:11,920 --> 00:24:14,260
>> OK, ასე ვთქვი, იქ იყო კიდევ ერთი
შემაშფოთებელი რამ ვარსკვლავს

459
00:24:14,260 --> 00:24:17,060
და აქ, სადაც, რომ
შემაშფოთებელი რამ ვარსკვლავს.

460
00:24:17,060 --> 00:24:21,640
ოდესმე ცდილობდა განაცხადოს
მრავალი ცვლადი იგივე ტიპის

461
00:24:21,640 --> 00:24:24,409
იმავე ხაზი კოდი?

462
00:24:24,409 --> 00:24:27,700
ასე რომ, მეორე, ვიტყვი, რომ ხაზი,
კოდი მე რეალურად იქ მწვანე

463
00:24:27,700 --> 00:24:29,366
იქ არ არის და ეს უბრალოდ ამბობს int x, y, z ;.

464
00:24:29,366 --> 00:24:31,634

465
00:24:31,634 --> 00:24:34,550
რა, რომ ყველაფერს გააკეთებს, ფაქტობრივად შექმნა
სამი მთელი ცვლადები თქვენთვის,

466
00:24:34,550 --> 00:24:36,930
ერთი მოუწოდა x, ერთი ე.წ.
y, და ერთი მოუწოდა z.

467
00:24:36,930 --> 00:24:41,510
ეს არის გზა ამის გარეშე
რომელსაც გაყოფილი გადატანა სამი ხაზი.

468
00:24:41,510 --> 00:24:43,890
>> აი, სადაც ვარსკვლავები მისაღებად
შემაშფოთებელი ერთხელ, თუმცა,

469
00:24:43,890 --> 00:24:49,200
იმის გამო, რომ * ფაქტიურად ნაწილი
ორივე ტიპის სახელი და ნაწილი

470
00:24:49,200 --> 00:24:50,320
ერთი ცვლადის სახელი.

471
00:24:50,320 --> 00:24:56,430
ასე რომ, თუ მე ვიტყვი, int * px, py, PZ, რაც მე
რეალურად კიდევ არის მომცეთ მთელი რიცხვი

472
00:24:56,430 --> 00:25:01,650
მოუწოდა px და ორი რიცხვებით, py და PZ.

473
00:25:01,650 --> 00:25:04,950
და ეს, ალბათ, არ არის რა
ჩვენ გვინდა, რომ ეს არ არის კარგი.

474
00:25:04,950 --> 00:25:09,290
>> ასე რომ, თუ მინდა, რომ შევქმნათ მრავალი პოინტერები
იგივე ხაზი, ერთი და იმავე ტიპის,

475
00:25:09,290 --> 00:25:12,140
და ვარსკვლავები, რაც მე რეალურად უნდა
უნდა ვთქვა int * pa, * pb * pc.

476
00:25:12,140 --> 00:25:17,330

477
00:25:17,330 --> 00:25:20,300
ახლა რომელმაც მხოლოდ ის განაცხადა, რომ
და ახლა თქვენ გეტყოდით,

478
00:25:20,300 --> 00:25:22,170
თქვენ, ალბათ, არასოდეს ამის გაკეთება.

479
00:25:22,170 --> 00:25:25,170
და ეს, ალბათ, კარგია პატიოსნად,
იმიტომ, რომ თქვენ შეიძლება უნებლიედ

480
00:25:25,170 --> 00:25:26,544
გამომრჩეს ვარსკვლავი, რაღაც მსგავსი.

481
00:25:26,544 --> 00:25:29,290
ეს, ალბათ, საუკეთესო შესაძლოა განაცხადოს
მითითებას ინდივიდუალური ხაზები,

482
00:25:29,290 --> 00:25:31,373
მაგრამ ეს მხოლოდ კიდევ ერთი
იმ უსიამოვნოს სინტაქსი

483
00:25:31,373 --> 00:25:35,310
რამ ვარსკვლავები, რომ
პოინტერები ასე რთული მუშაობა.

484
00:25:35,310 --> 00:25:39,480
იმის გამო, რომ ეს მხოლოდ ამ სინტაქსური
სასადილო თქვენ უნდა ვიმუშაოთ მეშვეობით.

485
00:25:39,480 --> 00:25:41,600
ერთად პრაქტიკა, ეს იმას
მართლაც გახდეს მეორე ბუნების.

486
00:25:41,600 --> 00:25:45,410
მე მაინც, რათა შეცდომები, ეს ჯერ კიდევ
მას შემდეგ, რაც პროგრამირების 10 წლის განმავლობაში,

487
00:25:45,410 --> 00:25:49,630
ასე არ უნდა დაარღვიოს თუ რამე მოხდება
თქვენ, ეს არის საკმაოდ გავრცელებული პატიოსნად.

488
00:25:49,630 --> 00:25:52,850
ეს მართლაც სახის
ხარვეზი სინტაქსის.

489
00:25:52,850 --> 00:25:54,900
>> OK ამიტომ ასეთი პირობა დადო
, რომ ჩვენ დავუბრუნდეთ

490
00:25:54,900 --> 00:25:59,370
კონცეფცია, თუ როგორ დიდი სიმებიანი.

491
00:25:59,370 --> 00:26:02,750
ისე, თუ მე ვუთხარი, რომ
სიმებიანი, ჩვენ მართლაც სახის

492
00:26:02,750 --> 00:26:04,140
უკვე ცრუობს თქვენ მთელი დრო.

493
00:26:04,140 --> 00:26:06,181
არ არსებობს მონაცემები ტიპის მოუწოდა
სიმებიანი და სინამდვილეში მე

494
00:26:06,181 --> 00:26:09,730
აღნიშნული ამ ჩვენი ერთ-ერთი
ადრეული ვიდეო მონაცემთა ტიპები,

495
00:26:09,730 --> 00:26:13,820
რომ სიმებიანი მონაცემები ტიპის რომ
შეიქმნა თქვენთვის cs50.h.

496
00:26:13,820 --> 00:26:17,050
თქვენ უნდა შეიცავდეს
CS50.h, რათა გამოიყენოს იგი.

497
00:26:17,050 --> 00:26:19,250
>> ისე string მართლაც მხოლოდ
იგივე რაღაც

498
00:26:19,250 --> 00:26:23,600
მოუწოდა char *, რომელიც
მომცეთ ხასიათი.

499
00:26:23,600 --> 00:26:26,010
ისე მითითებას, გავიხსენოთ,
არის მხოლოდ მიმართავს.

500
00:26:26,010 --> 00:26:28,780
ასე რომ, რა არის ზომა
ბაიტი სიმებიანი?

501
00:26:28,780 --> 00:26:29,796
ისე ეს ოთხი ან რვა.

502
00:26:29,796 --> 00:26:32,170
და მიზეზი მე ვიტყვი, ოთხი ან
რვა იმიტომ, რომ ეს რეალურად

503
00:26:32,170 --> 00:26:36,730
დამოკიდებულია სისტემა, თუ თქვენ იყენებთ
CS50 ide, char * არის ზომა char

504
00:26:36,730 --> 00:26:39,340
* რვა, ეს არის 64-bit სისტემა.

505
00:26:39,340 --> 00:26:43,850
ყველა მისამართი მეხსიერებაში არის 64 ბიტი ხანგრძლივი.

506
00:26:43,850 --> 00:26:48,270
თუ თქვენ იყენებთ CS50 ელექტრო მოწყობილობების
ან ნებისმიერი 32-bit მანქანა,

507
00:26:48,270 --> 00:26:51,640
და თქვენ მოვისმინე, რომ ტერმინი 32-bit
მანქანა, რა არის 32-bit მანქანა?

508
00:26:51,640 --> 00:26:56,090
ისე ეს მხოლოდ იმას ნიშნავს, რომ ყოველ
მისამართი მეხსიერებაში არის 32 ბიტი ხანგრძლივი.

509
00:26:56,090 --> 00:26:59,140
ასე რომ, 32 ბიტი არის ოთხი ბაიტი.

510
00:26:59,140 --> 00:27:02,710
ასე რომ, char * არის ოთხი ან რვა
bytes დამოკიდებულია თქვენს სისტემაში.

511
00:27:02,710 --> 00:27:06,100
და მართლაც ნებისმიერი მონაცემთა ტიპები,
და მომცეთ რაიმე მონაცემები

512
00:27:06,100 --> 00:27:12,030
ტიპის, მას შემდეგ, რაც ყველა მითითებები მხოლოდ
მისამართები, ოთხი ან რვა ბაიტს.

513
00:27:12,030 --> 00:27:14,030
მოდით დავუბრუნდეთ ამ
გრაფიკაზე და მოდით დავასკვნათ

514
00:27:14,030 --> 00:27:18,130
ეს ვიდეო ცოტა სწავლება აქ.

515
00:27:18,130 --> 00:27:21,600
ასე რომ აქ სქემა ჩვენ შეჩერდით ერთად
თავიდანვე ვიდეო.

516
00:27:21,600 --> 00:27:23,110
ასე რომ, რა ხდება ახლა, თუ მე ვიტყვი, * pk = 35?

517
00:27:23,110 --> 00:27:26,370

518
00:27:26,370 --> 00:27:30,530
ასე რომ, რას ნიშნავს, როცა ამბობენ, * pk = 35?

519
00:27:30,530 --> 00:27:32,420
მიიღეთ მეორე.

520
00:27:32,420 --> 00:27:34,990
* pk.

521
00:27:34,990 --> 00:27:39,890
ამ კონტექსტში აქ, * არის
dereference ოპერატორი.

522
00:27:39,890 --> 00:27:42,110
ასე რომ, როდესაც dereference
ოპერატორი გამოიყენება,

523
00:27:42,110 --> 00:27:48,520
ჩვენ წასვლა მისამართი აღნიშნა, რომ
მიერ pk და შევცვლით იმას, რაც ჩვენ.

524
00:27:48,520 --> 00:27:55,270
ასე * pk = 35 ეფექტურად
ჯერ ეს სურათი.

525
00:27:55,270 --> 00:27:58,110
ასე რომ, ძირითადად სინტაქსურად
იდენტურია, რომელმაც განაცხადა, k = 35.

526
00:27:58,110 --> 00:28:00,740

527
00:28:00,740 --> 00:28:01,930
>> კიდევ ერთი.

528
00:28:01,930 --> 00:28:05,510
თუ მე ვიტყვი, int მ, შევქმნა
ახალი ცვლადში მ.

529
00:28:05,510 --> 00:28:08,260
ახალი ყუთი, მწვანე ყუთი იმიტომ,
ის აპირებს გამართავს მთელი,

530
00:28:08,260 --> 00:28:09,840
და ეს შეაფასა, მ.

531
00:28:09,840 --> 00:28:14,960
თუ მე ვიტყვი, m = 4, მე ბოლო
მთელი შევიდა, რომ ყუთში.

532
00:28:14,960 --> 00:28:20,290
თუ ვთქვათ PK = & m, როგორ
ეს სქემა ცვლილება?

533
00:28:20,290 --> 00:28:28,760
PK = & m, თქვენ გავიხსენოთ, თუ რა
და ოპერატორი აკეთებს და ჰქვია?

534
00:28:28,760 --> 00:28:34,430
გახსოვდეთ, რომ & ზოგიერთი ცვლადის სახელი
არის მისამართი ცვლადის სახელი.

535
00:28:34,430 --> 00:28:38,740
ასე რომ, რასაც ჩვენ ვამბობთ, არის
pk იღებს მისამართი მ.

536
00:28:38,740 --> 00:28:42,010
ასე რომ, ეფექტურად, თუ რა ხდება
სქემა არის, რომ პკ აღარ რაოდენობა

537
00:28:42,010 --> 00:28:46,420
ხვ, მაგრამ რაოდენობა მ.

538
00:28:46,420 --> 00:28:48,470
>> ისევ მითითებას ძალიან
სახიფათო მუშაობა

539
00:28:48,470 --> 00:28:50,620
და ისინი ბევრი
პრაქტიკა, არამედ იმიტომ, რომ

540
00:28:50,620 --> 00:28:54,150
მათი უნარი საშუალებას გაძლევთ
გაივლის მონაცემები ფუნქციები

541
00:28:54,150 --> 00:28:56,945
და რეალურად იმ
ცვლილებები ძალაში,

542
00:28:56,945 --> 00:28:58,820
მიღების თქვენი უფროსი გარშემო
მართლაც მნიშვნელოვანია.

543
00:28:58,820 --> 00:29:02,590
ეს, ალბათ, ყველაზე რთული
თემის განვიხილავთ CS50,

544
00:29:02,590 --> 00:29:05,910
მაგრამ ღირებულება, რომ თქვენ
მიიღონ გამოყენებით პოინტერები

545
00:29:05,910 --> 00:29:09,200
აჭარბებს გართულებები
რომ მოდის სწავლის მათ.

546
00:29:09,200 --> 00:29:12,690
ასე რომ, გისურვებთ საუკეთესო
გისურვებთ სწავლის შესახებ მითითებას.

547
00:29:12,690 --> 00:29:15,760
მე Doug Lloyd, ეს არის CS50.

548
00:29:15,760 --> 00:29:17,447