1
00:00:00,000 --> 00:00:01,000
[Powered by Google Translate] [ნაწილი 6] [უფრო კომფორტული]

2
00:00:01,000 --> 00:00:04,000
[Rob Bowden] [ჰარვარდის უნივერსიტეტის]

3
00:00:04,000 --> 00:00:09,000
[ეს არის CS50.] [CS50.TV]

4
00:00:09,000 --> 00:00:11,000
>> ჩვენ შეგვიძლია უხელმძღვანელებს ჩვენი მონაკვეთის კითხვები.

5
00:00:11,000 --> 00:00:17,000
მე გაგზავნილი URL for სივრცის წინაშე.

6
00:00:17,000 --> 00:00:22,000
დასაწყისში მონაკვეთზე კითხვები ამბობენ-

7
00:00:22,000 --> 00:00:26,000
აშკარად არ ვარ მთლიანად unsick-არის ძალიან ადვილი კითხვა

8
00:00:26,000 --> 00:00:28,000
მხოლოდ იმას, რაც valgrind?

9
00:00:28,000 --> 00:00:30,000
რას valgrind გავაკეთო?

10
00:00:30,000 --> 00:00:34,000
ვინმე მინდა ვთქვა, რა valgrind აკეთებს?

11
00:00:34,000 --> 00:00:36,000
[სტუდენტური] ჩეკები მეხსიერების გაჟონვის.

12
00:00:36,000 --> 00:00:41,000
Yeah, valgrind არის ზოგადად მეხსიერების შემოწმება.

13
00:00:41,000 --> 00:00:44,000
ეს, საბოლოო ჯამში, გიჩვენებთ თუ თქვენ გაქვთ რაიმე მეხსიერების ტბები,

14
00:00:44,000 --> 00:00:49,000
რაც ძირითადად, რაც ჩვენ იყენებთ მას, რადგან თუ გსურთ

15
00:00:49,000 --> 00:00:54,000
კარგად პრობლემა კომპლექტი ან, თუ გნებავთ

16
00:00:54,000 --> 00:00:59,000
კიდევ დიდი საბჭო, უნდა გქონდეს არ მეხსიერების გაჟონვის განაწილებაზე,

17
00:00:59,000 --> 00:01:01,000
და იმ შემთხვევაში, თუ მეხსიერების გაჟონვის რომ ვერ პოულობთ,

18
00:01:01,000 --> 00:01:04,000
ასევე გახსოვდეთ, რომ ნებისმიერ დროს გახსნა ფაილი

19
00:01:04,000 --> 00:01:07,000
და თუ არ ვხურავთ მას, რომ მეხსიერების გაჟონვის.

20
00:01:07,000 --> 00:01:10,000
>> ბევრი ადამიანი ეძებს ზოგიერთი კვანძის, რომ ისინი არ ათავისუფლებს

21
00:01:10,000 --> 00:01:15,000
როცა ნამდვილად, არ დახუროთ ლექსიკონი წელს ძალიან პირველი ნაბიჯი.

22
00:01:15,000 --> 00:01:19,000
იგი ასევე გიჩვენებთ თუ თქვენ გაქვთ რაიმე არასწორი ნათქვამია ან წერს,

23
00:01:19,000 --> 00:01:22,000
რაც იმას ნიშნავს, თუ თქვენ ცდილობენ და მითითებული ღირებულება

24
00:01:22,000 --> 00:01:26,000
რომ მიღმა ბოლოს ბევრი და ეს არ მოხდება, რათა seg ბრალია

25
00:01:26,000 --> 00:01:30,000
მაგრამ valgrind იჭერს მას, როგორც არ უნდა იყოს რეალურად წერა იქ,

26
00:01:30,000 --> 00:01:33,000
და ასე რომ თქვენ აუცილებლად უნდა არ გვაქვს იმ შემორჩენია.

27
00:01:33,000 --> 00:01:38,000
როგორ იყენებთ valgrind?

28
00:01:38,000 --> 00:01:42,000
როგორ იყენებთ valgrind?

29
00:01:42,000 --> 00:01:45,000
>> ეს ზოგადად საკითხი

30
00:01:45,000 --> 00:01:49,000
სახის გაუშვით და შევხედოთ გამომუშავება.

31
00:01:49,000 --> 00:01:51,000
გამომავალი არის აბსოლუტური ბევრი ჯერ.

32
00:01:51,000 --> 00:01:54,000
არსებობს ასევე გართობა შეცდომები აქ თუ გაქვთ საშინლად არასწორი რამ

33
00:01:54,000 --> 00:01:59,000
ხდება მარყუჟის, მაშინ იგი საბოლოოდ ამბობენ, "გზა ძალიან ბევრი შეცდომები.

34
00:01:59,000 --> 00:02:03,000
მე ვაპირებ შეწყვიტოს დათვლის ახლა. "

35
00:02:03,000 --> 00:02:08,000
ეს ძირითადად ტექსტური გამომავალი რომ თქვენ გაქვთ გარჩევის.

36
00:02:08,000 --> 00:02:13,000
საბოლოო ჯამში, იგი გეტყვით ნებისმიერი მეხსიერების გაჟონვის რომ თქვენ გაქვთ,

37
00:02:13,000 --> 00:02:16,000
რამდენი ბლოკები, რომელიც შეიძლება იყოს სასარგებლო, რადგან

38
00:02:16,000 --> 00:02:20,000
თუ ერთი ბლოკი unfreed, მაშინ ეს ჩვეულებრივ ადვილია იპოვოს

39
00:02:20,000 --> 00:02:23,000
ვიდრე 1,000 ბლოკები unfreed.

40
00:02:23,000 --> 00:02:26,000
1,000 ბლოკები unfreed ალბათ იმას ნიშნავს, თქვენ არ ათავისუფლებს

41
00:02:26,000 --> 00:02:30,000
თქვენი უკავშირდება სიები სათანადოდ ან რამე.

42
00:02:30,000 --> 00:02:32,000
რომ valgrind.

43
00:02:32,000 --> 00:02:35,000
>> ახლა ჩვენ გვაქვს ჩვენი მონაკვეთის კითხვები,

44
00:02:35,000 --> 00:02:38,000
რომელიც თქვენ არ უნდა ჩამოტვირთოთ.

45
00:02:38,000 --> 00:02:41,000
დააკლიკეთ ჩემი სახელი და გაიყვანოს ისინი სივრცეში.

46
00:02:41,000 --> 00:02:44,000
ახლა დააჭირეთ ჩემთვის.

47
00:02:44,000 --> 00:02:46,000
ცვლილებათა 1 იქნება დასტის, რომელიც ვაკეთებთ პირველი.

48
00:02:46,000 --> 00:02:55,000
ცვლილებათა 2 იქნება რიგში, და ცვლილებათა 3 იქნება საგნით უკავშირდება სიაში.

49
00:02:55,000 --> 00:02:58,000
დაწყებული off ჩვენს Stack.

50
00:02:58,000 --> 00:03:02,000
როგორც ამბობს აქ, დასტის არის ერთ ერთი ყველაზე ძირითადი,

51
00:03:02,000 --> 00:03:07,000
ფუნდამენტური მონაცემები სტრუქტურების კომპიუტერული მეცნიერებების.

52
00:03:07,000 --> 00:03:11,000
ძალიან prototypical მაგალითია

53
00:03:11,000 --> 00:03:13,000
Stack of ქაღალდის წელს სასადილოს.

54
00:03:13,000 --> 00:03:16,000
ეს ძირითადად როდესაც თქვენ მიმდინარეობს გააცნო დასტის,

55
00:03:16,000 --> 00:03:20,000
ვინმე აპირებს ამბობენ, "ო, როგორიცაა Stack of უჯრები".

56
00:03:20,000 --> 00:03:22,000
თქვენ დააწყობს ქაღალდის up.

57
00:03:22,000 --> 00:03:24,000
მაშინ, როდესაც მიდიხარ დახევის უჯრა,

58
00:03:24,000 --> 00:03:31,000
პირველი უჯრა რომ მიღების გამოყვანილია არის ბოლო, რომელიც განთავსდება Stack.

59
00:03:31,000 --> 00:03:34,000
დასტის ასევე მსგავსი ნათქვამია აქ-

60
00:03:34,000 --> 00:03:37,000
ჩვენ გვაქვს სეგმენტი მეხსიერების მოუწოდა Stack.

61
00:03:37,000 --> 00:03:40,000
და რატომ არის ეს მოუწოდა დასტის?

62
00:03:40,000 --> 00:03:42,000
>> რადგან მოსწონს დასტის მონაცემები სტრუქტურის,

63
00:03:42,000 --> 00:03:46,000
ეს უბიძგებს და pops დასტის ფარგლებში on დასტის,

64
00:03:46,000 --> 00:03:53,000
აქ დასტის ფარგლებში არიან როგორც კონკრეტული Call of ფუნქცია.

65
00:03:53,000 --> 00:03:57,000
მსგავსად დასტის, თქვენ ყოველთვის უნდა დაბრუნდეს

66
00:03:57,000 --> 00:04:03,000
საწყისი ფუნქციის ზარის ადრე შეგიძლიათ მიიღოთ ქვემოთ შევიდა ქვედა დასტის ფარგლებში კიდევ ერთხელ.

67
00:04:03,000 --> 00:04:08,000
შეგიძლიათ არ აქვს მთავარ ზარის foo ზარის ბარი და ბარი დაბრუნება მთავარი პირდაპირ.

68
00:04:08,000 --> 00:04:14,000
ის ყოველთვის მივიღე დაიცვას სწორი დასტის უბიძგებს და popping.

69
00:04:14,000 --> 00:04:18,000
ორი ოპერაციები, როგორიც მე ვთქვი, არის ბიძგი და საესტრადო.

70
00:04:18,000 --> 00:04:20,000
ეს ის საყოველთაო თვალსაზრისით.

71
00:04:20,000 --> 00:04:26,000
თქვენ უნდა იცოდეთ, ბიძგი და საესტრადო თვალსაზრისით stacks არ აქვს მნიშვნელობა რა.

72
00:04:26,000 --> 00:04:28,000
ჩვენ დავინახავთ, რიგები არის სახის სხვადასხვა.

73
00:04:28,000 --> 00:04:32,000
ეს ნამდვილად არ აქვს უნივერსალური ტერმინი, მაგრამ ბიძგი და საესტრადო ვართ უნივერსალური ამისთვის stacks.

74
00:04:32,000 --> 00:04:34,000
Push უბრალოდ ჩაიცვი Stack.

75
00:04:34,000 --> 00:04:37,000
Pop არის გამეხადა Stack.

76
00:04:37,000 --> 00:04:43,000
და ვხედავთ აქ ჩვენ გვაქვს ჩვენი typedef struct დასტის,

77
00:04:43,000 --> 00:04:46,000
ამიტომ ჩვენ გვაქვს char ** სტრიქონები.

78
00:04:46,000 --> 00:04:51,000
ნუ ეშინია ნებისმიერი **.

79
00:04:51,000 --> 00:04:54,000
ეს აპირებს დასრულდება მდე მიმდინარეობს მასივი სტრიქონები

80
00:04:54,000 --> 00:04:58,000
ან მასივი მითითებას გმირები, სადაც

81
00:04:58,000 --> 00:05:00,000
მითითებას გმირები ტენდენცია იყოს სიმები.

82
00:05:00,000 --> 00:05:05,000
იგი არ უნდა იყოს სიმები, მაგრამ აქ, ისინი იქნება სტრიქონები.

83
00:05:05,000 --> 00:05:08,000
>> ჩვენ გვყავს მასივი სტრიქონები.

84
00:05:08,000 --> 00:05:14,000
ჩვენ გვყავს ზომა, რომელიც წარმოადგენს რამდენი ელემენტები ამჟამად დასტის,

85
00:05:14,000 --> 00:05:19,000
და მაშინ ჩვენ გვაქვს პოტენციალი, რომელიც რამდენი ელემენტები შეიძლება იყოს Stack.

86
00:05:19,000 --> 00:05:22,000
მოცულობა უნდა დაიწყოს off როგორც რაღაც მეტია 1,

87
00:05:22,000 --> 00:05:27,000
მაგრამ ზომა იწყებს off როგორც 0.

88
00:05:27,000 --> 00:05:36,000
არის, არის ძირითადად სამი სხვადასხვა გზით შეგიძლიათ წარმოიდგინოთ, რომ დასტის.

89
00:05:36,000 --> 00:05:39,000
ისე, არსებობს ალბათ მეტი, მაგრამ ორი ძირითადი გზები

90
00:05:39,000 --> 00:05:43,000
შეგიძლიათ განახორციელოს მისი გამოყენება მასივი, ან შეგიძლიათ განახორციელოს მისი გამოყენება დაკავშირებულია სიაში.

91
00:05:43,000 --> 00:05:48,000
უკავშირებს სიები სახის ტრივიალური რათა stacks საწყისი.

92
00:05:48,000 --> 00:05:51,000
ძალიან ადვილია, რათა დასტის გამოყენებით დაკავშირებული სიები

93
00:05:51,000 --> 00:05:55,000
ამიტომ, ჩვენ ვაპირებთ, რათა დასტის გამოყენებით მასივები,

94
00:05:55,000 --> 00:05:59,000
და შემდეგ გამოყენებით მასივები, არის კიდევ ორი ​​გზა შეგიძლიათ დაფიქრდით.

95
00:05:59,000 --> 00:06:01,000
მანამდე, როდესაც ვთქვი, ჩვენ გვაქვს შესაძლებლობა დასტის,

96
00:06:01,000 --> 00:06:04,000
ამიტომ ჩვენ შეგვიძლია ჯდება ელემენტს on Stack.

97
00:06:04,000 --> 00:06:09,000
>> ერთი გზა ეს შეიძლება მოხდეს არის, როგორც კი თქვენ მოხვდა 10 ელემენტებს, მაშინ თქვენ გაკეთდეს.

98
00:06:09,000 --> 00:06:13,000
მოგეხსენებათ, რომ არსებობს ზედა შეკრული of 10 რამ მსოფლიოში

99
00:06:13,000 --> 00:06:16,000
რომ თქვენ არასოდეს არ აღემატება 10 რამ თქვენს დასტის,

100
00:06:16,000 --> 00:06:20,000
ამ შემთხვევაში თქვენ შეგიძლიათ ზედა შეკრული on ზომა თქვენი დასტის.

101
00:06:20,000 --> 00:06:23,000
ან თქვენ შეიძლება თქვენი დასტის იყოს unbounded,

102
00:06:23,000 --> 00:06:27,000
მაგრამ თუ თქვენ აკეთებთ მასივი, რაც ნიშნავს, რომ თითოეული დროს თქვენ მოხვდა 10 ელემენტები,

103
00:06:27,000 --> 00:06:29,000
მაშინ თქვენ აპირებს აქვს ზრდა დან 20 ელემენტებს, და როდესაც თქვენ მოხვდა 20 ელემენტები,

104
00:06:29,000 --> 00:06:33,000
თქვენ აპირებს იზრდება თქვენი მასივი 30 ელემენტები ან 40 ელემენტებს.

105
00:06:33,000 --> 00:06:37,000
თქვენ აპირებთ უნდა გაიზარდოს მოცულობა, რაც ჩვენ ვაპირებთ აქ.

106
00:06:37,000 --> 00:06:40,000
თითოეული დრო მივაღწევთ მაქსიმალური ზომა ჩვენი დასტის,

107
00:06:40,000 --> 00:06:46,000
როდესაც ჩვენ დააყენებს რაღაც შემდეგ, ჩვენ ვაპირებთ უნდა გაიზარდოს მოცულობა.

108
00:06:46,000 --> 00:06:50,000
აქ, ჩვენ არ ბიძგი გამოცხადდა bool ბიძგი (char * ქ).

109
00:06:50,000 --> 00:06:54,000
ჩარ * ქ არის სიმებიანი რომ ჩვენ უბიძგებს გადატანა დასტის,

110
00:06:54,000 --> 00:06:58,000
და bool უბრალოდ ამბობს თუ არა ჩვენ მოვახერხეთ ან ჩაიშალა.

111
00:06:58,000 --> 00:07:00,000
>> როგორ შეიძლება ვერ შევძლებთ?

112
00:07:00,000 --> 00:07:04,000
რა არის მხოლოდ გარემოება, რომ შეგიძლიათ წარმოიდგინოთ, რომ

113
00:07:04,000 --> 00:07:07,000
აქ ჩვენ უნდა დაბრუნდეს ყალბი?

114
00:07:07,000 --> 00:07:09,000
Yeah.

115
00:07:09,000 --> 00:07:12,000
[სტუდენტური] თუ ეს სრული და ჩვენ გამოყენებით ესაზღვრება განხორციელება.

116
00:07:12,000 --> 00:07:17,000
ჰო, ისე, როგორ უნდა განსაზღვროს-პასუხობს

117
00:07:17,000 --> 00:07:23,000
თუ სრული და ჩვენ გამოყენებით ესაზღვრება განხორციელება.

118
00:07:23,000 --> 00:07:26,000
მაშინ ჩვენ აუცილებლად დაბრუნდებიან ყალბი.

119
00:07:26,000 --> 00:07:31,000
როგორც კი მოხვდა 10 რამ მასივი, ჩვენ ვერ ჯდება 11, ასე რომ ჩვენ დაბრუნების ცრუ.

120
00:07:31,000 --> 00:07:32,000
რა, თუ იგი unbounded? Yeah.

121
00:07:32,000 --> 00:07:38,000
თუ ვერ გაფართოებას მასივი რატომღაც.

122
00:07:38,000 --> 00:07:43,000
ჰო, ასე რომ მეხსიერება არის შეზღუდული რესურსი,

123
00:07:43,000 --> 00:07:51,000
და საბოლოოდ, თუ ჩვენ შევინარჩუნოთ უბიძგებს რამ გადატანა დასტის უსასრულოდ,

124
00:07:51,000 --> 00:07:54,000
ჩვენ ვაპირებთ შევეცადოთ და გამოყოფს უფრო დიდი მასივი, რათა შეწყობოდა

125
00:07:54,000 --> 00:07:59,000
უფრო დიდი ტევადობის და malloc ან რასაც ჩვენ გამოყენებით დაბრუნებას აპირებს ყალბი.

126
00:07:59,000 --> 00:08:02,000
ისე, malloc დაბრუნდება null.

127
00:08:02,000 --> 00:08:05,000
>> გახსოვდეთ, ყოველი დრო ოდესმე მოვუწოდებთ malloc, თქვენ უნდა შემოწმების თუ იგი

128
00:08:05,000 --> 00:08:12,000
დააბრუნებს null ანდა რომ არის სისწორის გამოქვითვას.

129
00:08:12,000 --> 00:08:17,000
მას შემდეგ, რაც ჩვენ გვინდა unbounded დასტის,

130
00:08:17,000 --> 00:08:21,000
მხოლოდ შემთხვევაში, ჩვენ ვაპირებთ იყოს დაბრუნების ცრუ არის, თუ ჩვენ ვცდილობთ

131
00:08:21,000 --> 00:08:26,000
გაზრდის შესაძლებლობები და malloc ან რასაც დააბრუნებს false.

132
00:08:26,000 --> 00:08:30,000
მაშინ pop იღებს არანაირი არგუმენტი,

133
00:08:30,000 --> 00:08:37,000
და ის დააბრუნებს string რომ არის ზევით Stack.

134
00:08:37,000 --> 00:08:41,000
როგორი იყო ბოლოს აიძულა on დასტის არის ის, რაც პოპ ბრუნდება,

135
00:08:41,000 --> 00:08:44,000
და მას ასევე შლის მას Stack.

136
00:08:44,000 --> 00:08:50,000
და შენიშნავს, რომ ის დააბრუნებს null თუ არაფერი Stack.

137
00:08:50,000 --> 00:08:53,000
ყოველთვის შესაძლებელია, რომ დასტის არის ცარიელი.

138
00:08:53,000 --> 00:08:55,000
ჯავაში, თუ თქვენ გამოიყენება, რომ, ან სხვა ენებზე,

139
00:08:55,000 --> 00:09:01,000
ცდილობს პოპ საწყისი ცარიელი დასტის შეიძლება გამოიწვიოს გამონაკლისის ან რამე.

140
00:09:01,000 --> 00:09:09,000
>> მაგრამ C, null არის სახის ბევრი შემთხვევებში, თუ როგორ გაუმკლავდეს ამ პრობლემებს.

141
00:09:09,000 --> 00:09:13,000
დავბრუნდეთ null არის, თუ როგორ ვაპირებთ ნიშნავდეს, რომ დასტის ცარიელი იყო.

142
00:09:13,000 --> 00:09:16,000
ჩვენ გათვალისწინებული კოდი, რომელიც შეამოწმოთ თქვენი დასტის ფუნქციების,

143
00:09:16,000 --> 00:09:19,000
განახორციელოს დააყენებს და საესტრადო.

144
00:09:19,000 --> 00:09:23,000
ეს არ იქნება ბევრი კოდი.

145
00:09:23,000 --> 00:09:40,000
მე-ფაქტობრივად, სანამ ჩვენ გავაკეთოთ, მინიშნება, მინიშნება-

146
00:09:40,000 --> 00:09:44,000
თუ თქვენ არ მინახავს ეს, malloc არ არის ერთადერთი ფუნქცია

147
00:09:44,000 --> 00:09:47,000
რომ გამოყოფს მეხსიერების შესახებ ბევრი თქვენთვის.

148
00:09:47,000 --> 00:09:51,000
არსებობს ოჯახი alloc ფუნქციები.

149
00:09:51,000 --> 00:09:53,000
პირველი არის malloc, რომელიც თქვენ გამოიყენება.

150
00:09:53,000 --> 00:09:56,000
მაშინ არსებობს calloc, რომელიც იგივე როგორც malloc,

151
00:09:56,000 --> 00:09:59,000
მაგრამ ეს ნულის ყველაფერს თქვენთვის.

152
00:09:59,000 --> 00:10:04,000
თუ თქვენ ოდესმე სურდა მითითებული ყველაფერი null შემდეგ mallocing რაღაც

153
00:10:04,000 --> 00:10:06,000
თქვენ უნდა მხოლოდ გამოყენებული calloc პირველ რიგში ნაცვლად წერა

154
00:10:06,000 --> 00:10:09,000
ამისთვის loop ნულის მთელი ბლოკი მეხსიერება.

155
00:10:09,000 --> 00:10:15,000
>> Realloc ჰგავს malloc და აქვს ბევრი განსაკუთრებულ შემთხვევებში,

156
00:10:15,000 --> 00:10:19,000
მაგრამ ძირითადად რა realloc არ არის

157
00:10:19,000 --> 00:10:24,000
სჭირდება მაჩვენებელი, უკვე გამოიყო.

158
00:10:24,000 --> 00:10:27,000
Realloc ფუნქცია გსურთ გადამხდელი ყურადღებას აქ.

159
00:10:27,000 --> 00:10:31,000
იგი იღებს მაჩვენებელი, უკვე დაბრუნდა malloc.

160
00:10:31,000 --> 00:10:35,000
ვთქვათ თქვენ მოითხოვოს malloc მაჩვენებელი საქართველოში 10 ბაიტი.

161
00:10:35,000 --> 00:10:38,000
შემდეგ ხვდები, თქვენ სურდა 20 ბაიტი,

162
00:10:38,000 --> 00:10:42,000
ასე რომ თქვენ მოვუწოდებთ realloc რომ მომცეთ გამოიტანე 20 ბაიტი,

163
00:10:42,000 --> 00:10:47,000
და realloc ავტომატურად კოპირება მეტი ყველაფერი თქვენთვის.

164
00:10:47,000 --> 00:10:51,000
თუ თქვენ უბრალოდ მოუწოდა malloc კვლავ, ისევე როგორც მე ბლოკი 10 ბაიტი.

165
00:10:51,000 --> 00:10:53,000
ახლა მჭირდება ბლოკი 20 ბაიტი,

166
00:10:53,000 --> 00:10:58,000
ასე რომ, თუ მე malloc 20 ბაიტი, მაშინ მე ხელით კოპირება მეტი 10 bytes from პირველი რაც

167
00:10:58,000 --> 00:11:01,000
მეორე რამ და შემდეგ თავისუფალი პირველი რაც.

168
00:11:01,000 --> 00:11:04,000
Realloc იქნება გაუმკლავდეს, რომ თქვენთვის.

169
00:11:04,000 --> 00:11:11,000
>> გაითვალისწინეთ ხელმოწერა იქნება ბათილად *,

170
00:11:11,000 --> 00:11:15,000
რომელიც მხოლოდ დაბრუნების მომცეთ ბლოკი მეხსიერება,

171
00:11:15,000 --> 00:11:17,000
მაშინ ბათილად * ptr.

172
00:11:17,000 --> 00:11:22,000
შეგიძლიათ წარმოიდგინოთ, რომ ბათილად * როგორც generic მაჩვენებელი.

173
00:11:22,000 --> 00:11:27,000
ზოგადად, თქვენ არასდროს გაუმკლავდეთ ბათილად *,

174
00:11:27,000 --> 00:11:30,000
მაგრამ malloc ბრუნდება ბათილად * და შემდეგ უბრალოდ გამოიყენება მოსწონს

175
00:11:30,000 --> 00:11:34,000
ეს რეალურად იქნება char *.

176
00:11:34,000 --> 00:11:37,000
წინა ბათილად * რომ იყო დაბრუნდა მიერ malloc

177
00:11:37,000 --> 00:11:41,000
არის აპირებს გადაეცემა realloc და შემდეგ ზომა

178
00:11:41,000 --> 00:11:49,000
არის ახალი ბაიტების რაოდენობას გსურთ გამოყოფას, ამიტომ თქვენი ახალ ამპლუაში.

179
00:11:49,000 --> 00:11:57,000
მე მივცემ თქვენ რამდენიმე წუთი, და ამის გაკეთება ჩვენს სივრცეში.

180
00:11:57,000 --> 00:12:02,000
დაწყება ცვლილებათა 1.

181
00:12:16,000 --> 00:12:21,000
მე შეჩერება შემდეგ იმედია შესახებ საკმარისი დრო განახორციელოს ბიძგი,

182
00:12:21,000 --> 00:12:24,000
და მაშინ მე მივცემ თქვენ კიდევ ერთი შესვენება გავაკეთოთ Pop.

183
00:12:24,000 --> 00:12:27,000
მაგრამ ეს ნამდვილად არ არის, რომ ბევრი რამ კოდი ყველა.

184
00:12:27,000 --> 00:12:35,000
საუკეთესო კოდი ალბათ გაფართოების პერსონალის, გაფართოების შესაძლებლობებით.

185
00:12:35,000 --> 00:12:39,000
Okay, არ ზეწოლა უნდა გაკეთდეს მთლიანად,

186
00:12:39,000 --> 00:12:47,000
მაგრამ რადგან თქვენ თავს თქვენ სწორ გზას ადგას, რომ კარგია.

187
00:12:47,000 --> 00:12:53,000
>> ვინმეს აქვს რაიმე კოდი ისინი თავს კომფორტულად ჩემთან გამწევ up?

188
00:12:53,000 --> 00:12:59,000
ჰო, მე, მაგრამ ჯერ არავის აქვს რაიმე კოდი შემიძლია დახევის up?

189
00:12:59,000 --> 00:13:05,000
Okay, შეგიძლიათ დაიწყოს, გადაარჩენს, რაც არ არის?

190
00:13:05,000 --> 00:13:09,000
მე ყოველთვის დაგვავიწყდეს, რომ ნაბიჯი.

191
00:13:09,000 --> 00:13:15,000
Okay, ეძებს ბიძგი,

192
00:13:15,000 --> 00:13:18,000
გსურთ ასახსნელად თქვენი კოდი?

193
00:13:18,000 --> 00:13:24,000
[სტუდენტური] უპირველეს ყოვლისა, მე გაიზარდა ზომა.

194
00:13:24,000 --> 00:13:28,000
ვფიქრობ იქნებ მე უნდა ჰქონდეს, რომ-ყოველ შემთხვევაში, მე გაიზარდა ზომა,

195
00:13:28,000 --> 00:13:31,000
და მე ვერ ვხედავ თუ ნაკლები ტევადობის.

196
00:13:31,000 --> 00:13:36,000
და თუ ნაკლები სიმძლავრის, მე დაამატოთ მასივს, რომ ჩვენ უკვე გვაქვს.

197
00:13:36,000 --> 00:13:42,000
და თუ ეს ასე არ არის, მე გამრავლების მოცულობა მიერ 2,

198
00:13:42,000 --> 00:13:50,000
და მე reallocate სიმები მასივი რაღაც შედარებით მეტი ტევადობის ზომა არის.

199
00:13:50,000 --> 00:13:55,000
და შემდეგ, თუ ეს ვერ მოხერხდა, მე გეტყვით მომხმარებლის და დაბრუნების ცრუ,

200
00:13:55,000 --> 00:14:04,000
და თუ ეს ჯარიმა, მაშინ მე ზუსტად სიმებიანი ახალ ადგილზე.

201
00:14:04,000 --> 00:14:07,000
>> [Rob ბ] ასევე შეამჩნევთ, რომ ჩვენ გამოიყენება ლამაზი bitwise ოპერატორის აქ

202
00:14:07,000 --> 00:14:09,000
უნდა გავამრავლოთ მიერ 2.

203
00:14:09,000 --> 00:14:11,000
გახსოვდეთ, მარცხენა Shift ყოველთვის იქნება გამრავლებული 2.

204
00:14:11,000 --> 00:14:15,000
მარჯვენა Shift იყოფა 2 რადგან გახსოვთ, რომ ეს იმას ნიშნავს,

205
00:14:15,000 --> 00:14:18,000
დაყოფის მიერ 2 როგორც მთელი რიცხვი იყოფა 2.

206
00:14:18,000 --> 00:14:20,000
ეს შეიძლება truncate 1 აქ ან იქ.

207
00:14:20,000 --> 00:14:26,000
მაგრამ ცვლა მიერ დატოვებული 1 ყოველთვის იქნება გამრავლებული 2,

208
00:14:26,000 --> 00:14:32,000
თუ თქვენ overflow ფარგლებში მთელი რიცხვი, და შემდეგ ეს არ იქნება.

209
00:14:32,000 --> 00:14:34,000
მხარეს კომენტარი.

210
00:14:34,000 --> 00:14:39,000
მე მიყვარს do-ეს არ შეიცვლება კოდირების ნებისმიერი ფორმით,

211
00:14:39,000 --> 00:14:48,000
მაგრამ მე მინდა, რომ რამე მოსწონს ეს.

212
00:14:48,000 --> 00:14:51,000
ეს ფაქტიურად ხდება, რათა ის ოდნავ აღარ.

213
00:15:04,000 --> 00:15:08,000
იქნებ ეს არ არის სრულყოფილი შემთხვევაში რათა ნახოთ ამ,

214
00:15:08,000 --> 00:15:14,000
მაგრამ მე მიყვარს სეგმენტი იგი ამ ბლოკებს-

215
00:15:14,000 --> 00:15:17,000
okay, თუ ეს თუ მოხდება, მაშინ მე ვაპირებ, რომ რამე,

216
00:15:17,000 --> 00:15:19,000
და შემდეგ ფუნქცია კეთდება.

217
00:15:19,000 --> 00:15:22,000
მე არ გვჭირდება მაშინ გადახვევა ჩემი თვალით ყველა გზა ქვემოთ ფუნქცია

218
00:15:22,000 --> 00:15:25,000
უნდა ვნახოთ, რა მოხდება მას შემდეგ, რაც სხვას.

219
00:15:25,000 --> 00:15:27,000
ეს თუ ეს თუ მოხდება, მაშინ მე უბრალოდ დააბრუნოს.

220
00:15:27,000 --> 00:15:30,000
მას ასევე ლამაზი დასძინა სასარგებლოდ ყველაფერს მიღმა ამ

221
00:15:30,000 --> 00:15:33,000
არის გადაინაცვლებს დაუტოვებიათ ერთხელ.

222
00:15:33,000 --> 00:15:40,000
მე აღარ უნდა თუ ოდესმე ახლოს ridiculously ხანგრძლივი ხაზები,

223
00:15:40,000 --> 00:15:45,000
მაშინ ის 4 ბაიტი შეუძლია დაეხმაროს, და ასევე უფრო მარცხენა რაღაც არის,

224
00:15:45,000 --> 00:15:48,000
ნაკლებია გადაატვირთული გრძნობთ თუ like-okay, მე უნდა გვახსოვდეს

225
00:15:48,000 --> 00:15:53,000
მე ამჟამად ხოლო loop შიგნით სხვას შიგნით ამისთვის loop.

226
00:15:53,000 --> 00:15:58,000
ნებისმიერ ადგილას შეგიძლიათ ამის გაკეთება დაბრუნების დაუყოვნებლივ, I ტიპის მოსწონს.

227
00:15:58,000 --> 00:16:05,000
ეს სრულიად არჩევით და მოსალოდნელი არ არის არანაირად.

228
00:16:05,000 --> 00:16:12,000
>> [სტუდენტური] უნდა იყოს ზომა - ში ვერ მდგომარეობა?

229
00:16:12,000 --> 00:16:19,000
Fail მდგომარეობა აქ ჩვენ ვერ realloc, ისე კი.

230
00:16:19,000 --> 00:16:22,000
შეამჩნევთ, თუ როგორ წელს ვერ მდგომარეობა, სავარაუდოდ,

231
00:16:22,000 --> 00:16:26,000
თუ ჩვენ თავისუფალი პერსონალის შემდეგ, ჩვენ ყოველთვის აპირებს ვერ

232
00:16:26,000 --> 00:16:29,000
არ აქვს მნიშვნელობა რამდენჯერ ვცდილობთ დააყენებს რაღაც.

233
00:16:29,000 --> 00:16:32,000
თუ ჩვენ შევინარჩუნოთ უბიძგებს, ჩვენ გააგრძელეთ დამატება ზომა,

234
00:16:32,000 --> 00:16:36,000
მიუხედავად იმისა, რომ ჩვენ არ აყენებს არაფერს გადატანა Stack.

235
00:16:36,000 --> 00:16:39,000
ჩვეულებრივ ჩვენ არ იყოს ზომა სანამ

236
00:16:39,000 --> 00:16:43,000
შემდეგ ჩვენ წარმატებით Put It On Stack.

237
00:16:43,000 --> 00:16:50,000
ჩვენ გვინდა ამის გაკეთება, ვთქვათ, არც აქ და აქ.

238
00:16:50,000 --> 00:16:56,000
და შემდეგ ნაცვლად ამბობდა s.size ≤ ტევადობა, ეს ნაკლები მოცულობა,

239
00:16:56,000 --> 00:17:01,000
მხოლოდ იმიტომ, რომ გადავედით სადაც ყველაფერი იყო.

240
00:17:01,000 --> 00:17:07,000
>> და მახსოვს, ერთადერთი ადგილი, რომ ჩვენ შეიძლება დაბრუნდეს ყალბი

241
00:17:07,000 --> 00:17:14,000
აქ არის, სადაც realloc დაბრუნდა null,

242
00:17:14,000 --> 00:17:19,000
და თუ მოხდება უნდა გვახსოვდეს სტანდარტული შეცდომა,

243
00:17:19,000 --> 00:17:22,000
იქნებ თქვენ შეიძლება განიხილონ ამ შემთხვევაში, სადაც გსურთ ბეჭდვა სტანდარტული შეცდომა,

244
00:17:22,000 --> 00:17:26,000
ასე fprintf stderr ნაცვლად მხოლოდ ბეჭდვას პირდაპირ სტანდარტულ out.

245
00:17:26,000 --> 00:17:31,000
ისევ და ისევ, ეს არ არის მოლოდინი, მაგრამ თუ ეს შეცდომა,

246
00:17:31,000 --> 00:17:41,000
აკრიფოთ printf, მაშინ დაგვჭირდება რათა ის ბეჭდვა სტანდარტული შეცდომა ნაცვლად სტანდარტული გარეთ.

247
00:17:41,000 --> 00:17:44,000
>> ვინმეს აქვს არაფერი აღვნიშნო? დიახ.

248
00:17:44,000 --> 00:17:47,000
[სტუდენტური] შეგიძლიათ წასვლა მეტი [inaudible]?

249
00:17:47,000 --> 00:17:55,000
[Rob ბ] დიახ, ფაქტობრივი binariness, ან უბრალოდ რა არის?

250
00:17:55,000 --> 00:17:57,000
[სტუდენტური] ასე, რომ თქვენ გავამრავლოთ ის მიერ 2?

251
00:17:57,000 --> 00:17:59,000
[Rob ბ] ჰო, ძირითადად.

252
00:17:59,000 --> 00:18:11,000
In ორობითი მიწის, ჩვენ ყოველთვის გვაქვს ჩვენი ნაკრები თანრიგისაგან.

253
00:18:11,000 --> 00:18:22,000
გადავიდა ეს მიერ დატოვებული 1 ძირითადად ჩანართები აქ მარჯვენა მხარეს.

254
00:18:22,000 --> 00:18:25,000
თავში ამ, უბრალოდ დამახსოვრების, რომ ყველაფერი ორობითი

255
00:18:25,000 --> 00:18:28,000
არის ძალა 2, ასე რომ ეს წარმოადგენს 2 ​​დან 0,

256
00:18:28,000 --> 00:18:30,000
ამ 2 დან 1, ამ 2 დან 2.

257
00:18:30,000 --> 00:18:33,000
By ჩასმა 0 მარჯვენა მხარეს არის, ჩვენ უბრალოდ გადაიტანოს ყველაფერი დასრულდა.

258
00:18:33,000 --> 00:18:38,000
რა გამოყენებული იქნება 2 დან 0 არის 2 დან 1, არის 2 დან 2.

259
00:18:38,000 --> 00:18:41,000
მარჯვენა მხარეს, რომ ჩვენ ჩასმული

260
00:18:41,000 --> 00:18:44,000
აუცილებლად იქნება 0,

261
00:18:44,000 --> 00:18:46,000
რაც გრძნობა.

262
00:18:46,000 --> 00:18:49,000
თუ თქვენ ოდესმე გავამრავლოთ ნომერი მიერ 2, ეს არ აპირებს დასრულდება მდე უცნაური,

263
00:18:49,000 --> 00:18:54,000
ასე 2 დან 0 ადგილი უნდა იყოს 0,

264
00:18:54,000 --> 00:18:59,000
და ეს არის ის, რაც მე ნახევარი გააფრთხილა შესახებ ადრე არის თუ მოხდება გადაეტანა

265
00:18:59,000 --> 00:19:01,000
მიღმა რაოდენობის ბიტი წელს მთელი რიცხვი,

266
00:19:01,000 --> 00:19:04,000
მაშინ ეს 1 აპირებს დასრულდება მდე მიმდინარეობს off.

267
00:19:04,000 --> 00:19:10,000
სწორედ მხოლოდ შეშფოთება თუ მოხდება უნდა საქმე მართლაც დიდი შესაძლებლობები.

268
00:19:10,000 --> 00:19:15,000
მაგრამ იმ ეტაპზე, მაშინ თქვენ საქმე მასივი მილიარდობით რამ,

269
00:19:15,000 --> 00:19:25,000
რაც შეიძლება არ ჯდება მეხსიერებაში მაინც.

270
00:19:25,000 --> 00:19:31,000
>> ახლა ჩვენ შეგვიძლია მოხვედრა pop, რაც კი ადვილია.

271
00:19:31,000 --> 00:19:36,000
თქვენ ეს მოსწონთ თუ ემართება პოპ მთელი bunch,

272
00:19:36,000 --> 00:19:38,000
და ახლა თქვენ ნახევარ მოცულობა ერთხელ.

273
00:19:38,000 --> 00:19:42,000
თქვენ შეიძლება realloc to shrink ოდენობით მეხსიერება გაქვთ,

274
00:19:42,000 --> 00:19:47,000
მაგრამ თქვენ არ უნდა ფიქრი, რომ, ასე მხოლოდ realloc შემთხვევაში იქნება

275
00:19:47,000 --> 00:19:50,000
მზარდი მეხსიერება, არასდროს არ მცირდება მეხსიერება,

276
00:19:50,000 --> 00:19:59,000
რომელიც აპირებს პოპ სუპერ მარტივია.

277
00:19:59,000 --> 00:20:02,000
არის რიგები, რომლებიც იქნება, როგორიც stacks,

278
00:20:02,000 --> 00:20:06,000
მაგრამ იმისათვის, რომ თქვენ მიიღოს ნივთების არის საპირისპიროა.

279
00:20:06,000 --> 00:20:10,000
Prototypical მაგალითი მდგომ არის ხაზი,

280
00:20:10,000 --> 00:20:12,000
ამიტომ ვფიქრობ, თუ იყო ინგლისური, მე იტყოდა

281
00:20:12,000 --> 00:20:17,000
prototypical მაგალითი მდგომ არის რიგიდან.

282
00:20:17,000 --> 00:20:22,000
ასე მოსწონს ხაზი, თუ თქვენ პირველი ადამიანი ხაზი,

283
00:20:22,000 --> 00:20:24,000
თქვენ მოველით, რომ იყოს პირველი პირი მიცემულია ხაზი.

284
00:20:24,000 --> 00:20:31,000
თუ თქვენ ბოლო პირი ხაზი, თქვენ იქნება ბოლო პირი ემსახურებოდა.

285
00:20:31,000 --> 00:20:35,000
ჩვენ მოვუწოდებთ, რომ FIFO ნიმუში, ხოლო დასტის იყო LIFO ნიმუში.

286
00:20:35,000 --> 00:20:40,000
ეს სიტყვები საკმაოდ უნივერსალური.

287
00:20:40,000 --> 00:20:46,000
>> Like stacks და განსხვავებით მასივები, რიგები, როგორც წესი, არ დაუშვას, რომ ელემენტები შუა.

288
00:20:46,000 --> 00:20:50,000
აქ, დასტის, ჩვენ გვაქვს ბიძგი და საესტრადო.

289
00:20:50,000 --> 00:20:54,000
აქ, ჩვენ არ უნდა მოუწოდა მათ enqueue და dequeue.

290
00:20:54,000 --> 00:20:58,000
ისიც გავიგე, მათ მოუწოდა ცვლა და unshift.

291
00:20:58,000 --> 00:21:02,000
მე მოვისმინე ამბობენ ბიძგი და საესტრადო ასევე ვრცელდება რიგები.

292
00:21:02,000 --> 00:21:05,000
მე მოვისმინე ჩადეთ, ამოიღოთ

293
00:21:05,000 --> 00:21:11,000
ასე დააყენებს და საესტრადო, თუ ვსაუბრობთ stacks, თქვენ დააჭერთ და popping.

294
00:21:11,000 --> 00:21:16,000
თუ თქვენ საუბრობთ რიგები, შეგიძლიათ აირჩიოთ სიტყვა, რომლის გამოყენებაც გსურთ

295
00:21:16,000 --> 00:21:23,000
ამისთვის Insertion და მოცილება, და არ არსებობს კონსენსუსი, თუ რას უნდა მოეთხოვოს.

296
00:21:23,000 --> 00:21:27,000
მაგრამ აქ, ჩვენ გვაქვს enqueue და dequeue.

297
00:21:27,000 --> 00:21:37,000
ახლა, struct გამოიყურება თითქმის იდენტურია დასტის struct.

298
00:21:37,000 --> 00:21:40,000
მაგრამ ჩვენ უნდა ტრეკზე ხელმძღვანელი.

299
00:21:40,000 --> 00:21:44,000
ვფიქრობ ნათქვამია ქვემოთ აქ, მაგრამ რატომ გვჭირდება ხელმძღვანელი?

300
00:21:53,000 --> 00:21:57,000
პროტოტიპები ძირითადად იდენტურია დააყენებს და საესტრადო.

301
00:21:57,000 --> 00:21:59,000
შეგიძლიათ წარმოიდგინოთ, რომ მას, როგორც ბიძგი და საესტრადო.

302
00:21:59,000 --> 00:22:08,000
ერთადერთი განსხვავება არის Pop ბრუნდება-ის ნაცვლად ბოლო, ის დაბრუნების პირველი.

303
00:22:08,000 --> 00:22:12,000
2, 1, 3, 4, ან რაღაც.

304
00:22:12,000 --> 00:22:14,000
და აქ დაწყება.

305
00:22:14,000 --> 00:22:17,000
ჩვენი მდგომ სრულიად სრული, ასე რომ ოთხი ელემენტები მასში.

306
00:22:17,000 --> 00:22:21,000
ბოლოს ჩვენი მდგომ არის გაკეთებული 2,

307
00:22:21,000 --> 00:22:24,000
და ახლა ჩვენ წასვლა ჩადეთ რაღაც.

308
00:22:24,000 --> 00:22:29,000
>> როდესაც ჩვენ გვინდა ჩადეთ რომ რაღაც, რაც ჩვენ გააკეთა დასტის ვერსია

309
00:22:29,000 --> 00:22:36,000
ჩვენ გაგრძელდეს ჩვენი ბლოკი მეხსიერება.

310
00:22:36,000 --> 00:22:40,000
რა არის პრობლემა?

311
00:22:40,000 --> 00:22:45,000
[სტუდენტური] თქვენ გადატანა 2.

312
00:22:45,000 --> 00:22:51,000
რა ვთქვი დაახლოებით ბოლოს მდგომ,

313
00:22:51,000 --> 00:22:57,000
ეს არ აქვს აზრი, რომ ჩვენ იწყება 1,

314
00:22:57,000 --> 00:23:01,000
მაშინ ჩვენ გვინდა dequeue 1, მაშინ dequeue 3, მაშინ dequeue 4,

315
00:23:01,000 --> 00:23:05,000
მაშინ dequeue 2, მაშინ dequeue ეს ერთი.

316
00:23:05,000 --> 00:23:08,000
ჩვენ არ შეგვიძლია გამოვიყენოთ realloc ახლა,

317
00:23:08,000 --> 00:23:11,000
ან სულ მცირე, თქვენ უნდა გამოიყენოთ realloc სხვაგვარად.

318
00:23:11,000 --> 00:23:15,000
მაგრამ როგორც ჩანს არ უნდა მოხდეს გამოიყენოთ realloc.

319
00:23:15,000 --> 00:23:18,000
აპირებთ ხელით კოპირება თქვენს მეხსიერებაში.

320
00:23:18,000 --> 00:23:21,000
>> არსებობს ორი ფუნქციები კოპირება მეხსიერება.

321
00:23:21,000 --> 00:23:25,000
არსებობს memcopy და memmove.

322
00:23:25,000 --> 00:23:29,000
მე გაკეთებული კითხულობს კაცი გვერდებზე, თუ რომელი ერთი თქვენ აპირებს გინდათ გამოიყენოთ.

323
00:23:29,000 --> 00:23:35,000
Okay, memcopy, განსხვავება არის

324
00:23:35,000 --> 00:23:38,000
რომ memcopy და memmove, ერთი სახელურები შემთხვევაში სწორად

325
00:23:38,000 --> 00:23:41,000
აქ თქვენ კოპირება შევიდა რეგიონში, რომ მოხდება გადახურვა რეგიონში

326
00:23:41,000 --> 00:23:46,000
თქვენ კოპირება საწყისი.

327
00:23:46,000 --> 00:23:50,000
Memcopy არ ამუშავებს მას. Memmove აკეთებს.

328
00:23:50,000 --> 00:23:59,000
შეგიძლიათ წარმოიდგინოთ, რომ პრობლემა, როგორც-

329
00:23:59,000 --> 00:24:09,000
ვთქვათ მინდა კოპირება ამ ბიჭს,

330
00:24:09,000 --> 00:24:13,000
ამ ოთხი ამ ბიჭს მეტი.

331
00:24:13,000 --> 00:24:16,000
და ბოლოს, რა მასივი უნდა გამოიყურებოდეს

332
00:24:16,000 --> 00:24:26,000
შემდეგ ასლი არის 2, 1, 2, 1, 3, 4, და შემდეგ რაღაცები დასასრულს.

333
00:24:26,000 --> 00:24:29,000
მაგრამ ეს დამოკიდებული იმისათვის, რომელშიც ჩვენ რეალურად კოპირება,

334
00:24:29,000 --> 00:24:32,000
რადგან, თუ არ ჩავთვლით იმ ფაქტს, რომ რეგიონში ჩვენ გადაწერა შევიდა

335
00:24:32,000 --> 00:24:35,000
ემთხვევა ერთი ჩვენ კოპირება საწყისი,

336
00:24:35,000 --> 00:24:46,000
მაშინ ჩვენ შეიძლება გავაკეთოთ მოსწონს დაწყება აქ, კოპირება 2 შევიდა ადგილი გვინდა წასვლა,

337
00:24:46,000 --> 00:24:52,000
მაშინ გადატანა ჩვენი პოინტერები ნაბიჯია.

338
00:24:52,000 --> 00:24:56,000
>> ახლა ჩვენ ვაპირებთ იყოს აქ და აქ, და ახლა ჩვენ გვინდა კოპირება

339
00:24:56,000 --> 00:25:04,000
ამ ბიჭს მეტი ამ ბიჭს და გადატანა ჩვენი პოინტერები ნაბიჯია.

340
00:25:04,000 --> 00:25:07,000
ის, რასაც ჩვენ ვაპირებთ დასრულდება up მიღების არის 2, 1, 2, 1, 2, 1

341
00:25:07,000 --> 00:25:10,000
ნაცვლად შესაბამისი 2, 1, 2, 1, 3, 4 რადგან

342
00:25:10,000 --> 00:25:15,000
2, 1 overrode ორიგინალური 3, 4.

343
00:25:15,000 --> 00:25:19,000
Memmove სახელურები რომ სწორად.

344
00:25:19,000 --> 00:25:23,000
ამ შემთხვევაში, ძირითადად უბრალოდ ვიყენებთ memmove

345
00:25:23,000 --> 00:25:26,000
იმიტომ, რომ ეს ემსახურება ეს სწორად.

346
00:25:26,000 --> 00:25:29,000
ეს ზოგადად არ განახორციელებს რაიმე სახის უარესი.

347
00:25:29,000 --> 00:25:32,000
იდეა არის ის ნაცვლად დასაწყისიდან და გადაწერა ამ გზით

348
00:25:32,000 --> 00:25:35,000
როგორც ჩვენ უბრალოდ გააკეთეს აქ, იგი იწყება ბოლოს და ასლი,

349
00:25:35,000 --> 00:25:38,000
და ამ შემთხვევაში, შეგიძლიათ არასდროს პრობლემა.

350
00:25:38,000 --> 00:25:40,000
არ არსებობს შესრულების დაკარგა.

351
00:25:40,000 --> 00:25:47,000
ყოველთვის გამოიყენეთ memmove. არასოდეს ფიქრი memcopy.

352
00:25:47,000 --> 00:25:51,000
და ეს სადაც თქვენ აპირებთ უნდა ცალკე memmove

353
00:25:51,000 --> 00:26:01,000
გახვეული-გარშემო ნაწილი თქვენი რიგიდან.

354
00:26:01,000 --> 00:26:04,000
არარის შეშფოთება თუ ბოლომდე არ გაკეთებულა.

355
00:26:04,000 --> 00:26:10,000
ეს არის უფრო რთული, ვიდრე დასტის, ბიძგი, და საესტრადო.

356
00:26:10,000 --> 00:26:15,000
>> ვინმეს აქვს რაიმე კოდი შეგვეძლო მუშაობა?

357
00:26:15,000 --> 00:26:21,000
მაშინაც კი, თუ მთლიანად არასრული?

358
00:26:21,000 --> 00:26:23,000
[სტუდენტური] ჰო მთლიანად არასრული, თუმცა.

359
00:26:23,000 --> 00:26:27,000
სრულიად არასრული კარგად არის, სანამ ჩვენ, შეგიძლიათ შეინახოთ შეტანილი?

360
00:26:27,000 --> 00:26:32,000
მე დაგვავიწყდეს, რომ თითოეული დრო.

361
00:26:32,000 --> 00:26:39,000
Okay, იგნორირება, რა მოხდება მაშინ, როდესაც ჩვენ გვჭირდება ზომის შეცვლა რამ.

362
00:26:39,000 --> 00:26:42,000
მთლიანად იგნორირება Resize.

363
00:26:42,000 --> 00:26:49,000
ახსენით ეს კოდი.

364
00:26:49,000 --> 00:26:54,000
მე შემოწმების პირველ რიგში, თუ ზომა ნაკლებია, ვიდრე ასლი, პირველ რიგში,

365
00:26:54,000 --> 00:27:01,000
და შემდეგ ამის შემდეგ, მე ჩადეთ-მე უფროსი + ზომა,

366
00:27:01,000 --> 00:27:05,000
მე და დარწმუნდით, რომ იგი დასრულდება გარშემო რანგში მასივი,

367
00:27:05,000 --> 00:27:08,000
მე და ჩადეთ ახალი სიმებიანი იმ თანამდებობაზე.

368
00:27:08,000 --> 00:27:12,000
მერე გაზრდის ზომა და დაუბრუნოს ჭეშმარიტი.

369
00:27:12,000 --> 00:27:22,000
>> [Rob ბ] ეს არის ნამდვილად ერთი იმ შემთხვევებში, როდესაც თქვენ აპირებთ უნდა გამოყენებით mod.

370
00:27:22,000 --> 00:27:25,000
ნებისმიერი სახის შემთხვევაში, როდესაც თქვენ არ შესაფუთი გარშემო, თუ ფიქრობთ, შესაფუთი გარშემო,

371
00:27:25,000 --> 00:27:29,000
დაუყოვნებლივ აზრის უნდა იყოს mod.

372
00:27:29,000 --> 00:27:36,000
როგორც სწრაფი ოპტიმიზაცია / გააკეთოთ თქვენი კოდი ერთ ხაზს მოკლეა,

373
00:27:36,000 --> 00:27:42,000
თქვენ შეამჩნევთ, რომ ხაზი დაუყოვნებლივ შემდეგ ამ ერთი

374
00:27:42,000 --> 00:27:53,000
უბრალოდ ზომა + +, ასე რომ თქვენ შერწყმა, რომ ამ ხაზზე, ზომა + +.

375
00:27:53,000 --> 00:27:58,000
ახლა ქვევით აქ, ჩვენ გვაქვს საქმე

376
00:27:58,000 --> 00:28:01,000
სადაც ჩვენ არ გვაქვს საკმარისი მეხსიერება,

377
00:28:01,000 --> 00:28:05,000
ასე რომ, ჩვენ გავაძლიერებთ ჩვენს მიერ მოცულობა 2.

378
00:28:05,000 --> 00:28:09,000
ვფიქრობ, თქვენ შეიძლება იგივე პრობლემა აქ, მაგრამ შეგვიძლია იგნორირება ეს არის,

379
00:28:09,000 --> 00:28:13,000
აქ თუ ვერ მოხერხდა გაზრდის თქვენს მოცულობა,

380
00:28:13,000 --> 00:28:18,000
მაშინ ვაპირებთ გვინდა შეამცირებს თქვენს მიერ მოცულობა 2 ერთხელ.

381
00:28:18,000 --> 00:28:24,000
კიდევ ერთი მოკლე შენიშვნა არის, ისევე, როგორც თქვენ შეგიძლიათ + =,

382
00:28:24,000 --> 00:28:30,000
ასევე შეგიძლიათ გააკეთებს << =.

383
00:28:30,000 --> 00:28:43,000
თითქმის ყველაფერი შეიძლება წავიდეს ადრე შეადგენს, + =, | =, = &, << =.

384
00:28:43,000 --> 00:28:52,000
ჩარ * ახალი არის ჩვენი ახალი ბლოკი მეხსიერება.

385
00:28:52,000 --> 00:28:55,000
ოჰ, მეტი აქ.

386
00:28:55,000 --> 00:29:02,000
>> რას ფიქრობს ხალხი შესახებ გაცნობის ჩვენი ახალი ბლოკი მეხსიერება?

387
00:29:02,000 --> 00:29:06,000
[სტუდენტური] უნდა იყოს char **.

388
00:29:06,000 --> 00:29:12,000
ფიქრი თავში ჩვენი struct აქ,

389
00:29:12,000 --> 00:29:14,000
სიმები არის ის, რაც ჩვენ reallocating.

390
00:29:14,000 --> 00:29:21,000
ვაკეთებთ მთელი ახალი დინამიური შენახვისა და ელემენტების რიგში.

391
00:29:21,000 --> 00:29:25,000
ის, რასაც ჩვენ ვაპირებთ იყოს მინიჭების თქვენს სიმები არის ის, რაც ჩვენ mallocing ახლავე,

392
00:29:25,000 --> 00:29:30,000
და ა.შ. ახალი იქნება char **.

393
00:29:30,000 --> 00:29:34,000
ეს იქნება მასივი სტრიქონები.

394
00:29:34,000 --> 00:29:38,000
მაშინ, რა არის საქმე, რომელსაც ჩვენ ვაპირებთ დაბრუნებას ყალბი?

395
00:29:38,000 --> 00:29:41,000
[სტუდენტური] უნდა ვიყოთ აკეთებს char *?

396
00:29:41,000 --> 00:29:44,000
[Rob ბ] დიახ, კარგი ზარი.

397
00:29:44,000 --> 00:29:46,000
[სტუდენტური] რა იყო ეს?

398
00:29:46,000 --> 00:29:49,000
[Rob ბ] ჩვენ გვინდოდა ჯანმრთელობის სფეროში გაგვეკეთებინა ზომა char * იმიტომ, რომ ჩვენ აღარ-

399
00:29:49,000 --> 00:29:53,000
ეს რეალურად იქნება ძალიან დიდი პრობლემა, რადგან sizeof (char) იქნება 1.

400
00:29:53,000 --> 00:29:55,000
Sizeof char * იქნება 4,

401
00:29:55,000 --> 00:29:58,000
ასე ბევრი დრო, როდესაც თქვენ საქმე ints,

402
00:29:58,000 --> 00:30:01,000
თქვენ ტენდენცია მიიღოს away მასთან რადგან ზომა int და ზომის int *

403
00:30:01,000 --> 00:30:04,000
on 32-bit სისტემა იქნება იგივე.

404
00:30:04,000 --> 00:30:09,000
მაგრამ აქ, sizeof (char) და sizeof (char *) ახლა იქნება იგივე.

405
00:30:09,000 --> 00:30:15,000
>> რა არის გარემოება, სადაც ჩვენ დაბრუნების ყალბი?

406
00:30:15,000 --> 00:30:17,000
[სტუდენტური] ახალი არის null.

407
00:30:17,000 --> 00:30:23,000
ჰო, თუ ახალი არის null, ვბრუნდებით ყალბი,

408
00:30:23,000 --> 00:30:34,000
და მე ვაპირებ ჩააგდოს ქვემოთ აქ-

409
00:30:34,000 --> 00:30:37,000
[სტუდენტური] [inaudible]

410
00:30:37,000 --> 00:30:39,000
[Rob ბ] ჰო, ეს არის ჯარიმა.

411
00:30:39,000 --> 00:30:46,000
თქვენ შეიძლება არც გააკეთონ 2 ჯერ ტევადობა ან მოცულობა Shift 1 და შემდეგ მხოლოდ მითითებული მისი დანგრევა აქ ან რასაც.

412
00:30:46,000 --> 00:30:52,000
ჩვენ გავაკეთებთ, როგორც ჩვენ გვქონდა ეს.

413
00:30:52,000 --> 00:30:56,000
მოცულობა >> = 1.

414
00:30:56,000 --> 00:31:08,000
და თქვენ არასოდეს გვექნება ფიქრი დაკარგვის 1 ადგილს

415
00:31:08,000 --> 00:31:12,000
იმიტომ, რომ თქვენ დაუტოვებიათ გადავიდა მიერ 1, ასე რომ 1 ადგილი აუცილებლად 0,

416
00:31:12,000 --> 00:31:16,000
ამიტომ უფლებას თავიანთ მიერ 1, თქვენ მაინც იქნება ჯარიმა.

417
00:31:16,000 --> 00:31:19,000
[სტუდენტური] თქვენ უნდა გავაკეთოთ, რომ ადრე დაბრუნების?

418
00:31:19,000 --> 00:31:29,000
[Rob ბ] დიახ, ეს ხდის აბსოლუტურად აზრი არ აქვს.

419
00:31:29,000 --> 00:31:36,000
>> ახლა ვივარაუდოთ ჩვენ ვაპირებთ დასრულდება მდე დაბრუნების ჭეშმარიტი ბოლომდე.

420
00:31:36,000 --> 00:31:39,000
გზა ჩვენ ვაპირებთ ამ memmoves,

421
00:31:39,000 --> 00:31:45,000
ჩვენ უნდა ფრთხილად თუ როგორ გავაკეთოთ ისინი.

422
00:31:45,000 --> 00:31:50,000
ვინმეს გაქვთ რაიმე შემოთავაზება თუ როგორ გავაკეთოთ ისინი?

423
00:32:17,000 --> 00:32:21,000
აი ჩვენი დაწყება.

424
00:32:21,000 --> 00:32:28,000
აუცილებლად, ჩვენ გვინდა, რომ დაიწყოს დასაწყისში კვლავ

425
00:32:28,000 --> 00:32:35,000
და ასლი რამ იქიდან, 1, 3, 4, 2.

426
00:32:35,000 --> 00:32:41,000
როგორ გავაკეთოთ ეს?

427
00:32:41,000 --> 00:32:52,000
პირველ რიგში, მე უნდა შევხედოთ მამაკაცს გვერდი memmove ერთხელ.

428
00:32:52,000 --> 00:32:57,000
Memmove, ბრძანებით არგუმენტები ყოველთვის მნიშვნელოვანია.

429
00:32:57,000 --> 00:33:01,000
გვსურს, ჩვენი დანიშნულების პირველი წყარო მეორე, მესამე ზომა.

430
00:33:01,000 --> 00:33:06,000
არსებობს უამრავი ფუნქციები, რომელიც შეცვალოს წყარო და დანიშნულების.

431
00:33:06,000 --> 00:33:11,000
დანიშნულების წყარო აპირებს იყოს თანმიმდევრული გარკვეულწილად.

432
00:33:17,000 --> 00:33:21,000
ნაბიჯი, რა არის ეს დაბრუნების?

433
00:33:21,000 --> 00:33:27,000
ის დააბრუნებს მომცეთ დანიშნულების, სხვადსხვა მიზეზის გამო დაგვჭირდება, რომ.

434
00:33:27,000 --> 00:33:32,000
შემიძლია ნახატის წაიკითხავს, ​​მაგრამ გვინდა ვიაროთ ჩვენი დანიშნულების.

435
00:33:32,000 --> 00:33:35,000
>> რა არის ჩვენი დანიშნულების იქნება?

436
00:33:35,000 --> 00:33:37,000
[სტუდენტური] ახალი.

437
00:33:37,000 --> 00:33:39,000
[Rob ბ] დიახ, და სადაც ჩვენ კოპირება საწყისი?

438
00:33:39,000 --> 00:33:43,000
პირველი, რაც ჩვენ გადაწერა ეს 1, 3, 4.

439
00:33:43,000 --> 00:33:50,000
რა არის ეს-1, 3, 4.

440
00:33:50,000 --> 00:33:55,000
რა არის მისამართი ამ 1?

441
00:33:55,000 --> 00:33:58,000
რა არის მისამართი, რომელიც 1?

442
00:33:58,000 --> 00:34:01,000
[სტუდენტური] [inaudible]

443
00:34:01,000 --> 00:34:03,000
[Rob ბ] უფროსი + მისამართი პირველი ელემენტს.

444
00:34:03,000 --> 00:34:05,000
როგორ მივიღებთ პირველ ელემენტს მასივი?

445
00:34:05,000 --> 00:34:10,000
[სტუდენტური] რიგიდან.

446
00:34:10,000 --> 00:34:15,000
[Rob ბ] დიახ, q.strings.

447
00:34:15,000 --> 00:34:20,000
გახსოვდეთ, აქ, ჩვენი ხელმძღვანელი არის 1.

448
00:34:20,000 --> 00:34:24,000
Darn იგი. მე უბრალოდ ვფიქრობ, რომ magically-

449
00:34:24,000 --> 00:34:29,000
აქ, ჩვენი ხელმძღვანელი არის 1. მე ვაპირებ შევცვალო ჩემი ფერი ძალიან.

450
00:34:29,000 --> 00:34:36,000
აქ არის სიმები.

451
00:34:36,000 --> 00:34:41,000
ეს, ჩვენ შეგვიძლია ან წერენ, როგორც გავაკეთეთ მეტი აქ

452
00:34:41,000 --> 00:34:43,000
თავაკებით + q.strings.

453
00:34:43,000 --> 00:34:51,000
ბევრი ადამიანი ასევე დაწერა და q.strings [ხელმძღვანელი].

454
00:34:51,000 --> 00:34:55,000
ეს არ არის ნამდვილად ნებისმიერი ნაკლებად ეფექტური.

455
00:34:55,000 --> 00:34:58,000
თქვენ ალბათ ფიქრობთ, ეს როგორც თქვენ dereferencing და მერე მიღების მისამართს,

456
00:34:58,000 --> 00:35:04,000
მაგრამ შემდგენელი აპირებს თარგმნოს ის, თუ რა გვქონდა ადრე მაინც, q.strings + ხელმძღვანელი.

457
00:35:04,000 --> 00:35:06,000
ნებისმიერ შემთხვევაში გსურთ ვფიქრობ იგი.

458
00:35:06,000 --> 00:35:11,000
>> და რამდენი ბაიტი გვინდა კოპირება?

459
00:35:11,000 --> 00:35:15,000
[სტუდენტური] სიმძლავრე - ხელმძღვანელი.

460
00:35:15,000 --> 00:35:18,000
სიმძლავრე - ხელმძღვანელი.

461
00:35:18,000 --> 00:35:21,000
და მაშინ შეიძლება ყოველთვის წერენ გარეთ მაგალითად

462
00:35:21,000 --> 00:35:23,000
გაერკვნენ თუ ეს უფლება.

463
00:35:23,000 --> 00:35:26,000
[სტუდენტური] უნდა იყოფა 2 შემდეგ.

464
00:35:26,000 --> 00:35:30,000
ჰო, ისე, ვფიქრობ, ჩვენ შეგვიძლია გამოვიყენოთ ზომა.

465
00:35:30,000 --> 00:35:35,000
ჩვენ კვლავ გვაქვს ზომა მყოფი-

466
00:35:35,000 --> 00:35:39,000
გამოყენებით ზომა, ჩვენ გვაქვს ზომა ტოლია 4.

467
00:35:39,000 --> 00:35:42,000
ჩვენი ზომა არის 4. ჩვენი ხელმძღვანელი არის 1.

468
00:35:42,000 --> 00:35:46,000
ჩვენ გვინდა, რომ კოპირება ამ 3 ელემენტებს.

469
00:35:46,000 --> 00:35:54,000
სწორედ საღი აზრის შესამოწმებლად, რომ ზომა - ხელმძღვანელი არის სწორად 3.

470
00:35:54,000 --> 00:35:58,000
და ბრუნდება აქ, როგორც ჩვენ დაწყებამდე განაცხადა,

471
00:35:58,000 --> 00:36:00,000
თუ ჩვენ გამოყენებული სიმძლავრე, მაშინ ჩვენ ავღნიშნო უნდა დაყოს მიერ 2

472
00:36:00,000 --> 00:36:04,000
იმიტომ, რომ ჩვენ უკვე გაიზარდა ჩვენი მოცულობა, ამიტომ ჩვენ ვაპირებთ გამოვიყენოთ ზომა.

473
00:36:11,000 --> 00:36:13,000
რომ ასლები, რომ ნაწილი.

474
00:36:13,000 --> 00:36:18,000
ახლა ჩვენ გვჭირდება კოპირება სხვა ნაწილი, ნაწილი, რომელიც დარჩა დაწყება.

475
00:36:18,000 --> 00:36:28,000
>> რომ აპირებს memmove შევიდა რა პოზიცია?

476
00:36:28,000 --> 00:36:32,000
[სტუდენტური] Plus ზომა - ხელმძღვანელი.

477
00:36:32,000 --> 00:36:38,000
დიახ, ასე რომ ჩვენ უკვე გადაწერილი ზომის - უფროსი ბაიტი,

478
00:36:38,000 --> 00:36:43,000
და ასე თუ სად გვინდა კოპირება დარჩენილი ბაიტი არის ახალი

479
00:36:43,000 --> 00:36:48,000
და მერე ზომა მინუს-კარგად, ბაიტების რაოდენობას ჩვენ უკვე გადაწერილი სისტემაში

480
00:36:48,000 --> 00:36:52,000
და მაშინ სად ვიმყოფებით კოპირება საწყისი?

481
00:36:52,000 --> 00:36:54,000
[სტუდენტური] Q.strings [0].

482
00:36:54,000 --> 00:36:56,000
[Rob ბ] დიახ, q.strings.

483
00:36:56,000 --> 00:37:02,000
ჩვენ შეგვეძლო არც გააკეთებს და q.strings [0].

484
00:37:02,000 --> 00:37:05,000
ეს არის მნიშვნელოვნად ნაკლებია ვიდრე საერთო ამ.

485
00:37:05,000 --> 00:37:14,000
თუ ეს უბრალოდ იქნება 0, მაშინ თქვენ ტენდენცია ვხედავ q.strings.

486
00:37:14,000 --> 00:37:16,000
სწორედ აქ ჩვენ კოპირება საწყისი.

487
00:37:16,000 --> 00:37:18,000
რამდენი ბაიტი ჩვენ არ დაუტოვებიათ კოპირება? >> [სტუდენტური] 10.

488
00:37:18,000 --> 00:37:20,000
მარჯვენა.

489
00:37:20,000 --> 00:37:25,000
[სტუდენტური] გვაქვს, რომ გავამრავლოთ 5 - 10 ჯერ ზომა ბაიტებში ან რაღაც?

490
00:37:25,000 --> 00:37:30,000
ჰო, ასე რომ ეს არის სადაც რას ზუსტად ჩვენ გადაწერა?

491
00:37:30,000 --> 00:37:32,000
[სტუდენტური] [inaudible]

492
00:37:32,000 --> 00:37:34,000
რა არის გაცნობის რამ ჩვენ გადაწერა?

493
00:37:34,000 --> 00:37:36,000
[სტუდენტური] [inaudible]

494
00:37:36,000 --> 00:37:41,000
ჰო, ისე, char * s რომ ჩვენ გადაწერა, არ ვიცით, სადაც მოდის.

495
00:37:41,000 --> 00:37:47,000
, სადაც ისინი მიუთითებს, როგორიცაა სიმები, ჩვენ დასრულდება მდე ზრდის ის გადატანა მდგომ

496
00:37:47,000 --> 00:37:49,000
ან enqueuing გადატანა რიგიდან.

497
00:37:49,000 --> 00:37:51,000
სადაც მოდის, არ ვიცით.

498
00:37:51,000 --> 00:37:56,000
ჩვენ უბრალოდ უნდა ტრეკზე char * s თავს.

499
00:37:56,000 --> 00:38:00,000
ჩვენ არ გვინდა კოპირება ზომა - უფროსი bytes.

500
00:38:00,000 --> 00:38:03,000
ჩვენ გვინდა, რომ კოპირება ზომა - უფროსი char * s,

501
00:38:03,000 --> 00:38:11,000
ამიტომ ჩვენ ვაპირებთ გავამრავლოთ ამ მიერ sizeof (char *).

502
00:38:11,000 --> 00:38:17,000
იგივე ქვემოთ აქ ხელმძღვანელმა * sizeof (char *).

503
00:38:17,000 --> 00:38:24,000
>> [სტუდენტური] რა [inaudible]?

504
00:38:24,000 --> 00:38:26,000
ეს უფლება აქ?

505
00:38:26,000 --> 00:38:28,000
[სტუდენტური] არ არის, ქვემოთ, რომ ზომა - ხელმძღვანელი.

506
00:38:28,000 --> 00:38:30,000
[Rob ბ] ეს უფლება აქ?

507
00:38:30,000 --> 00:38:32,000
Pointer არითმეტიკული.

508
00:38:32,000 --> 00:38:35,000
როგორ მაჩვენებელი არითმეტიკული იმუშავებს არის

509
00:38:35,000 --> 00:38:40,000
ეს ავტომატურად multiplies მიერ ზომის ტიპის, რომ ჩვენ საქმე გვაქვს.

510
00:38:40,000 --> 00:38:46,000
ისევე აქ, ახალი + (ზომა - უფროსი)

511
00:38:46,000 --> 00:38:56,000
სწორედ ექვივალენტური და ახალი [ზომა - უფროსი]

512
00:38:56,000 --> 00:39:00,000
სანამ ჩვენ ვიმედოვნებთ, რომ მუშაობა სწორად,

513
00:39:00,000 --> 00:39:04,000
რადგან თუ ჩვენ საქმე გვაქვს int array, მაშინ რა ინდექსი მიერ GEO-

514
00:39:04,000 --> 00:39:07,000
ან, თუ ის საქართველოს ზომა 5 და გინდათ მე -4 ელემენტს, მაშინ ჩვენ ინდექსი შევიდა

515
00:39:07,000 --> 00:39:10,000
int array [4].

516
00:39:10,000 --> 00:39:14,000
თქვენ don't-[4] * ზომა int.

517
00:39:14,000 --> 00:39:21,000
მოდული ავტომატურად, და ამ შემთხვევაში

518
00:39:21,000 --> 00:39:29,000
არის სიტყვასიტყვით ექვივალენტი, ამიტომ bracket სინტაქსი

519
00:39:29,000 --> 00:39:34,000
უბრალოდ იქნება მოაქცია ამ როგორც კი შეადგინოს.

520
00:39:34,000 --> 00:39:38,000
რომ რაღაც თქვენ უნდა ფრთხილად, რომ

521
00:39:38,000 --> 00:39:42,000
როდესაც თქვენ დასძინა ზომა - უფროსი

522
00:39:42,000 --> 00:39:45,000
თქვენ დასძინა არა ერთი ბაიტი.

523
00:39:45,000 --> 00:39:53,000
თქვენ დასძინა ერთი char *, რომელიც შეიძლება ერთი ბაიტი ან რასაც.

524
00:39:53,000 --> 00:39:56,000
>> გაქვთ სხვა კითხვები?

525
00:39:56,000 --> 00:40:04,000
Okay, dequeue იქნება ადვილი.

526
00:40:04,000 --> 00:40:11,000
მე მივცემ თქვენ წუთიანი განახორციელოს.

527
00:40:11,000 --> 00:40:18,000
ოჰ, და მე ვფიქრობ, ეს არის იგივე სიტუაცია, სადაც

528
00:40:18,000 --> 00:40:21,000
რა enqueue შემთხვევაში, თუ ჩვენ enqueuing null,

529
00:40:21,000 --> 00:40:24,000
იქნებ გვინდა გაუმკლავდეს მას, იქნებ ჩვენ არ.

530
00:40:24,000 --> 00:40:27,000
ჩვენ არ გავაკეთებთ ერთხელ აქ, მაგრამ იგივე, რაც ჩვენი დასტის შემთხვევაში.

531
00:40:27,000 --> 00:40:34,000
თუ ჩვენ enqueue null, ჩვენ დაგვჭირდება იგნორირება მას.

532
00:40:34,000 --> 00:40:40,000
ვინმეს აქვს გარკვეული კოდი შემიძლია დახევის up?

533
00:40:40,000 --> 00:40:45,000
[სტუდენტური] მე უბრალოდ dequeue.

534
00:40:45,000 --> 00:40:56,000
ვერსია 2 არის, რომ-okay.

535
00:40:56,000 --> 00:40:59,000
თქვენ მინდა განვმარტო?

536
00:40:59,000 --> 00:41:01,000
[სტუდენტური] პირველი, თქვენ დარწმუნდით, არსებობს რაღაც მდგომ

537
00:41:01,000 --> 00:41:07,000
და რომ ზომა მიდის ქვემოთ მიერ 1.

538
00:41:07,000 --> 00:41:11,000
თქვენ უნდა გავაკეთოთ, და მერე დაბრუნდნენ ხელმძღვანელი

539
00:41:11,000 --> 00:41:13,000
და მაშინ გადატანა Head Up 1.

540
00:41:13,000 --> 00:41:19,000
Okay, ასე რომ, კუთხეში შემთხვევაში ჩვენ უნდა განიხილოს. Yeah.

541
00:41:19,000 --> 00:41:24,000
[სტუდენტური] თუ თქვენი უფროსი არის ბოლო ელემენტს,

542
00:41:24,000 --> 00:41:26,000
მაშინ არ მინდა უფროსი აღვნიშნო გარეთ მასივი.

543
00:41:26,000 --> 00:41:29,000
>> ჰო, ისე, როგორც კი უფროსი ჰიტები ბოლოს ჩვენი მასივი,

544
00:41:29,000 --> 00:41:35,000
როდესაც ჩვენ dequeue, ჩვენი ხელმძღვანელი უნდა modded თავში 0.

545
00:41:35,000 --> 00:41:40,000
სამწუხაროდ, ჩვენ არ შეგვიძლია გავაკეთოთ, რომ ერთი ნაბიჯით.

546
00:41:40,000 --> 00:41:44,000
ვფიქრობ გზა მინდა ალბათ გაასწორონ ის არის

547
00:41:44,000 --> 00:41:52,000
ეს იქნება char *, რა ჩვენ დაბრუნებას,

548
00:41:52,000 --> 00:41:55,000
რასაც თქვენი ცვლადის სახელი სურს.

549
00:41:55,000 --> 00:42:02,000
მაშინ ჩვენ გვინდა თავდაცვის სამინისტროს ხელმძღვანელი ჩვენი მოცულობა

550
00:42:02,000 --> 00:42:10,000
და შემდეგ დაბრუნდნენ ret.

551
00:42:10,000 --> 00:42:14,000
ბევრი ადამიანი აქ მათ შეიძლება გავაკეთოთ-

552
00:42:14,000 --> 00:42:19,000
ეს შემთხვევა-you'll ხალხს, თუ ხელმძღვანელი

553
00:42:19,000 --> 00:42:29,000
მეტია მოცულობა, გავაკეთოთ ხელმძღვანელი - ტევადობა.

554
00:42:29,000 --> 00:42:36,000
და ეს მხოლოდ სამუშაო გარშემო რა mod არის.

555
00:42:36,000 --> 00:42:41,000
უფროსი mod = ტევადობა ბევრად სუფთა

556
00:42:41,000 --> 00:42:51,000
საქართველოს შესაფუთი გარშემო, ვიდრე თუ ხელმძღვანელი მეტი ტევადობის ხელმძღვანელი - ტევადობა.

557
00:42:51,000 --> 00:42:56,000
>> კითხვები?

558
00:42:56,000 --> 00:43:02,000
Okay, ბოლო რამ ჩვენ არ დაუტოვებიათ არის ჩვენი დაკავშირებული სიაში.

559
00:43:02,000 --> 00:43:07,000
თქვენ შეიძლება გამოყენებულ იქნას ზოგიერთი უკავშირდება სია ქცევის თუ გააკეთეს

560
00:43:07,000 --> 00:43:11,000
უკავშირდება სიები თქვენს hash მაგიდები, თუ რა გააკეთეთ hash მაგიდასთან.

561
00:43:11,000 --> 00:43:15,000
გირჩევთ აკეთებს hash მაგიდასთან.

562
00:43:15,000 --> 00:43:17,000
თქვენ ალბათ უკვე გაკეთდა trie,

563
00:43:17,000 --> 00:43:23,000
მაგრამ ცდილობს უფრო რთულია.

564
00:43:23,000 --> 00:43:27,000
თეორიულად, ისინი asymptotically უკეთესი.

565
00:43:27,000 --> 00:43:30,000
მაგრამ შევჩერდეთ დიდი საბჭო,

566
00:43:30,000 --> 00:43:35,000
და ცდილობს არასდროს უკეთესად, და მათ დასჭირდეს მეტი მეხსიერება.

567
00:43:35,000 --> 00:43:43,000
ყველაფერი ცდილობს დამთავრდა თუ არა უარესი მეტი მუშაობა.

568
00:43:43,000 --> 00:43:49,000
ეს არის ის, რაც დავით Malan მისი გადაწყვეტა ყოველთვის არის

569
00:43:49,000 --> 00:43:56,000
არის ის ყოველთვის შეტყობინება მისი trie გადაწყვეტა და ვნახოთ სადაც გაკეთებული არის.

570
00:43:56,000 --> 00:44:00,000
რა იყო ის ქვეშ, დავით J?

571
00:44:00,000 --> 00:44:06,000
ის # 18, ისე, რომ არ საშინლად ცუდი,

572
00:44:06,000 --> 00:44:09,000
და ეს იქნება ერთ ერთი საუკეთესო ცდილობს შეგიძლიათ წარმოიდგინოთ, რომ

573
00:44:09,000 --> 00:44:17,000
ან ერთ ერთი საუკეთესო ცდილობს of trie.

574
00:44:17,000 --> 00:44:23,000
არის თუ არა არც კი მისი ორიგინალური გადაწყვეტა?

575
00:44:23,000 --> 00:44:29,000
ვგრძნობ, როგორიცაა trie გადაწყვეტილებები უფრო ამ სპექტრს RAM გამოყენება.

576
00:44:29,000 --> 00:44:33,000
>> ზემოთ ქვემოთ ძალიან ზევით, და RAM გამოყენება არის ერთჯერადი თანრიგისაგან.

577
00:44:33,000 --> 00:44:36,000
მჯდომარე მიმართ ბოლოში, და მერე დაიწყოს ხედავს ცდილობს

578
00:44:36,000 --> 00:44:41,000
სადაც თქვენ მიიღოს აბსოლუტურად მასიური RAM გამოყენება,

579
00:44:41,000 --> 00:44:45,000
და ცდილობს უფრო რთულია.

580
00:44:45,000 --> 00:44:53,000
მთლიანად არ ღირს, მაგრამ საგანმანათლებლო გამოცდილებას, თუ რა გააკეთეთ ერთი.

581
00:44:53,000 --> 00:44:56,000
ბოლო რამ არის ჩვენი დაკავშირებული სიაში,

582
00:44:56,000 --> 00:45:04,000
და ეს სამი რამ, stacks, რიგები, და დაკავშირებული სიები

583
00:45:04,000 --> 00:45:09,000
ნებისმიერი მომავალი რამ ოდესმე გააკეთოს კომპიუტერულ მეცნიერებათა

584
00:45:09,000 --> 00:45:12,000
აიღებს გაქვთ მნიშვნელოვანია იმ ეს ყველაფერი.

585
00:45:12,000 --> 00:45:19,000
ისინი არა იმდენად ფუნდამენტურია ყველაფერი.

586
00:45:19,000 --> 00:45:25,000
>> უკავშირებს სიებს და აქ ჩვენ საგნით უკავშირდება სია იქნება ჩვენი განხორციელება.

587
00:45:25,000 --> 00:45:34,000
რას უკავშირდება საგნით ნიშნავს ნაცვლად ორმაგად უკავშირდება? დიახ.

588
00:45:34,000 --> 00:45:37,000
[სტუდენტური] ეს მხოლოდ მიუთითებს შემდეგი მაჩვენებელი, ვიდრე გჭირდებათ,

589
00:45:37,000 --> 00:45:39,000
მოსწონს ერთი წინა და ერთი მის შემდეგ.

590
00:45:39,000 --> 00:45:44,000
ჰო, ისე სურათში ფორმატში, რა მე უბრალოდ?

591
00:45:44,000 --> 00:45:48,000
მე ორი რამ. მაქვს სურათი და ნახატი.

592
00:45:48,000 --> 00:45:51,000
სურათების ფორმატი, ჩვენი საგნით უკავშირდება სიები

593
00:45:51,000 --> 00:45:57,000
აუცილებლად, ჩვენ გვაქვს გარკვეული სახის მომცეთ ხელმძღვანელი ჩვენს სიაში,

594
00:45:57,000 --> 00:46:02,000
და შემდეგ შიგნით ჩვენს სიაში, ჩვენ უბრალოდ უნდა პოინტერები,

595
00:46:02,000 --> 00:46:05,000
და იქნებ ეს მიუთითებს null.

596
00:46:05,000 --> 00:46:08,000
ეს იქნება თქვენი ტიპიური ნახაზი საგნით უკავშირდება სიაში.

597
00:46:08,000 --> 00:46:14,000
ორმაგად უკავშირდება სიაში, შეგიძლიათ გადასვლა უკან.

598
00:46:14,000 --> 00:46:19,000
თუ მე გაძლევთ ნებისმიერი კვანძის სიაში, მაშინ აუცილებლად მისაღებად

599
00:46:19,000 --> 00:46:23,000
ნებისმიერი სხვა კვანძის სიაში თუ ის ორმაგად უკავშირდება სიაში.

600
00:46:23,000 --> 00:46:27,000
მაგრამ თუ მივიღებ თქვენ მესამე კვანძის სიაში და ეს საგნით უკავშირდება სია,

601
00:46:27,000 --> 00:46:30,000
არანაირად არ თქვენ ოდესმე აპირებს მისაღებად პირველი და მეორე კვანძების.

602
00:46:30,000 --> 00:46:34,000
და არსებობს სარგებელი და detriments, და ერთი აშკარა ერთი

603
00:46:34,000 --> 00:46:42,000
არის თქვენ დასჭირდეს მეტი ზომის, და თქვენ უნდა ტრეკზე, სადაც ეს ყველაფერი მიუთითებს არის.

604
00:46:42,000 --> 00:46:49,000
მაგრამ ჩვენ მხოლოდ აინტერესებს საგნით უკავშირდება.

605
00:46:49,000 --> 00:46:53,000
>> ცოტა რამ ჩვენ ვაპირებთ უნდა განახორციელოს.

606
00:46:53,000 --> 00:47:00,000
შენი typedef struct კვანძში, int i: struct კვანძის * შემდეგი; კვანძში.

607
00:47:00,000 --> 00:47:09,000
რომ typedef უნდა დაწვეს თქვენს გონებაში.

608
00:47:09,000 --> 00:47:14,000
Quiz 1 უნდა იყოს მისცეს typedef of უკავშირდება სია კვანძში,

609
00:47:14,000 --> 00:47:18,000
და თქვენ უნდა შეეძლოს დაუყოვნებლივ scribble რომ ქვევით

610
00:47:18,000 --> 00:47:22,000
გარეშე კი ფიქრობდა იგი.

611
00:47:22,000 --> 00:47:27,000
ვფიქრობ წყვილი კითხვები, რატომ გვჭირდება struct აქ?

612
00:47:27,000 --> 00:47:32,000
რატომ არ შეუძლიათ ჩვენ ვამბობთ კვანძის *?

613
00:47:32,000 --> 00:47:35,000
[სტუდენტური] [inaudible]

614
00:47:35,000 --> 00:47:38,000
Yeah.

615
00:47:38,000 --> 00:47:44,000
ერთადერთი, რაც განსაზღვრავს კვანძის როგორც რამ

616
00:47:44,000 --> 00:47:47,000
არის typedef თავად.

617
00:47:47,000 --> 00:47:55,000
მაგრამ, როგორც ამ ეტაპზე, როცა ჩვენ სახის დამუშავება ამ struct კვანძის განმარტება,

618
00:47:55,000 --> 00:48:01,000
ჩვენ არ დასრულებულა ჩვენი typedef გაუკეთებია, რადგან typedef არ დასრულებულა,

619
00:48:01,000 --> 00:48:05,000
კვანძი არ არსებობს.

620
00:48:05,000 --> 00:48:12,000
მაგრამ struct კვანძის აკეთებს, და ამ კვანძის აქ,

621
00:48:12,000 --> 00:48:14,000
ამ შეიძლება მოუწოდა არაფერი.

622
00:48:14,000 --> 00:48:16,000
ეს შეიძლება ეწოდოს n.

623
00:48:16,000 --> 00:48:19,000
ეს შეიძლება ეწოდოს დაკავშირებული სიაში კვანძში.

624
00:48:19,000 --> 00:48:21,000
შეიძლება მოუწოდა არაფერი.

625
00:48:21,000 --> 00:48:26,000
მაგრამ ეს struct კვანძის საჭიროებს მოუწოდა იგივე როგორც ამ struct კვანძში.

626
00:48:26,000 --> 00:48:29,000
რა რეკავთ ამ აქვს ასევე აქ,

627
00:48:29,000 --> 00:48:32,000
და ისე, რომ ასევე პასუხობს მეორე წერტილი კითხვა

628
00:48:32,000 --> 00:48:37,000
რის გამოც-უამრავი ჯერ როდესაც ხედავთ structs და typedefs of structs,

629
00:48:37,000 --> 00:48:42,000
დაინახავთ ანონიმური structs სადაც თქვენ უბრალოდ ნახეთ typedef struct,

630
00:48:42,000 --> 00:48:47,000
განხორციელების struct, ლექსიკონი, ან რასაც.

631
00:48:47,000 --> 00:48:51,000
>> რატომ აქ გვჭირდება ვთქვა კვანძის?

632
00:48:51,000 --> 00:48:54,000
რატომ არ შეიძლება ეს იყოს ანონიმური struct?

633
00:48:54,000 --> 00:48:56,000
თითქმის იგივე პასუხი.

634
00:48:56,000 --> 00:48:58,000
[სტუდენტური] თქვენ უნდა უწოდებს ფარგლებში struct.

635
00:48:58,000 --> 00:49:04,000
Yeah, ფარგლებში struct, თქვენ უნდა მიმართოს struct თავად.

636
00:49:04,000 --> 00:49:10,000
თუ არ მისცეს struct სახელი, თუ ის ანონიმური struct, ვერ უწოდებს.

637
00:49:10,000 --> 00:49:17,000
და ბოლოს მაინც-ეს უნდა იყოს გარკვეულწილად მარტივია,

638
00:49:17,000 --> 00:49:20,000
და მათ უნდა დაეხმაროს ხვდები თუ თქვენ წერა ამ ქვევით

639
00:49:20,000 --> 00:49:24,000
რომ თქვენ აკეთებთ რაღაც თუ ეს სახის რამ არ აქვს აზრი.

640
00:49:24,000 --> 00:49:28,000
ბოლო მაგრამ არა მაინც, რატომ ამ უნდა იყოს struct კვანძის *?

641
00:49:28,000 --> 00:49:34,000
რატომ არ შეიძლება ეს უბრალოდ უნდა struct კვანძის შემდეგი?

642
00:49:34,000 --> 00:49:37,000
[სტუდენტური] მომცეთ შემდეგი struct.

643
00:49:37,000 --> 00:49:39,000
სწორედ აუცილებლად რაც გვინდა.

644
00:49:39,000 --> 00:49:42,000
რატომ შეიძლება იგი არასოდეს არ იქნება struct კვანძის შემდეგი?

645
00:49:42,000 --> 00:49:50,000
რატომ უნდა იყოს struct კვანძის * შემდეგი? Yeah.

646
00:49:50,000 --> 00:49:53,000
[სტუდენტური] ეს მოსწონს უსასრულო ციკლი.

647
00:49:53,000 --> 00:49:55,000
Yeah.

648
00:49:55,000 --> 00:49:57,000
[სტუდენტური] უმჯობესი იქნება ერთ.

649
00:49:57,000 --> 00:50:02,000
ჰო, უბრალოდ ფიქრობთ, როგორ მოიქცევიან ზომა ან რამე.

650
00:50:02,000 --> 00:50:08,000
ზომა struct ძირითადად + ან - ზოგიერთი ნიმუში აქ ან იქ.

651
00:50:08,000 --> 00:50:15,000
ეს ძირითადად იქნება თანხა ზომის რამ struct.

652
00:50:15,000 --> 00:50:18,000
ეს უფლება აქ, შეცვლის გარეშე არაფერი, ზომა იქნება ადვილი.

653
00:50:18,000 --> 00:50:24,000
ზომა struct კვანძის იქნება ზომა i + ზომა შემდეგი.

654
00:50:24,000 --> 00:50:27,000
ზომა I იქნება 4. ზომა შემდეგი იქნება 4.

655
00:50:27,000 --> 00:50:30,000
ზომა struct კვანძის იქნება 8.

656
00:50:30,000 --> 00:50:34,000
თუ ჩვენ არ გვაქვს *, ფიქრი sizeof,

657
00:50:34,000 --> 00:50:37,000
მაშინ sizeof (I) იქნება 4.

658
00:50:37,000 --> 00:50:43,000
ზომა struct კვანძის შემდეგი იქნება ზომა i + ზომა struct კვანძის შემდეგი

659
00:50:43,000 --> 00:50:46,000
+ ზომა i + ზომა struct კვანძის შემდეგი.

660
00:50:46,000 --> 00:50:55,000
კარგი იქნება უსასრულო უკან კვანძების.

661
00:50:55,000 --> 00:51:00,000
ამიტომ ასე რამ უნდა იყოს.

662
00:51:00,000 --> 00:51:03,000
>> ერთხელ, აუცილებლად გვემახსოვრება, რომ,

663
00:51:03,000 --> 00:51:06,000
ან თუნდაც გაგება საკმარისი რომ თქვენ შეგიძლიათ შეძლებს

664
00:51:06,000 --> 00:51:12,000
მიზეზი მეშვეობით, თუ რას უნდა გამოიყურებოდეს.

665
00:51:12,000 --> 00:51:14,000
რამ ჩვენ ვაპირებთ სურთ განახორციელონ.

666
00:51:14,000 --> 00:51:18,000
თუ სიგრძეზე სიაში-

667
00:51:18,000 --> 00:51:21,000
თქვენ შეიძლება მოატყუო და შეინახოს გარშემო

668
00:51:21,000 --> 00:51:24,000
გლობალური სიგრძის ან რაღაც, მაგრამ ჩვენ არ ვაპირებთ გავაკეთოთ, რომ.

669
00:51:24,000 --> 00:51:28,000
ჩვენ ვაპირებთ ითვლიან სიგრძეზე სიაში.

670
00:51:28,000 --> 00:51:34,000
ჩვენ შეიცავს, ასე რომ ძირითადად მოსწონს ძებნა,

671
00:51:34,000 --> 00:51:41,000
ამიტომ ჩვენ გვაქვს უკავშირდება სიაში რიცხვებით თუ ამ რიცხვის არის დაკავშირებულია სიაში.

672
00:51:41,000 --> 00:51:44,000
Prepend აპირებს ჩადეთ დასაწყისში სიაში.

673
00:51:44,000 --> 00:51:46,000
დამატება აპირებს ჩადეთ დასასრულს.

674
00:51:46,000 --> 00:51:53,000
Insert_sorted აპირებს INSERT INTO დახარისხებული თანამდებობა სიაში.

675
00:51:53,000 --> 00:52:01,000
Insert_sorted სახის ვარაუდობს, რომ თქვენ არასოდეს არ გამოუყენებია prepend ან დამატება ცუდ გზებს.

676
00:52:01,000 --> 00:52:09,000
>> Insert_sorted როცა თქვენ განხორციელების insert_sorted-

677
00:52:09,000 --> 00:52:13,000
ვთქვათ გვაქვს უკავშირდება სიაში.

678
00:52:13,000 --> 00:52:18,000
ეს არის ის, რაც მას გაკეთებული ჰგავს, 2, 4, 5.

679
00:52:18,000 --> 00:52:24,000
მინდა ჩადეთ 3, ასე რომ სანამ სიაში თავად უკვე დახარისხებული,

680
00:52:24,000 --> 00:52:27,000
ადვილი მოძიების, სადაც 3 ეკუთვნის.

681
00:52:27,000 --> 00:52:29,000
მე იწყება 2.

682
00:52:29,000 --> 00:52:32,000
Okay, 3 მეტია 2, ასე რომ მინდა შენარჩუნება აპირებს.

683
00:52:32,000 --> 00:52:35,000
ოჰ, 4 ძალიან დიდი, ასე რომ მე ვიცი 3 აპირებს წავიდეს შორის 2 და 4,

684
00:52:35,000 --> 00:52:39,000
და მე უნდა დააფიქსიროს მაჩვენებლებისა და ყველა რომ პერსონალი.

685
00:52:39,000 --> 00:52:43,000
მაგრამ თუ ჩვენ არ მკაცრად გამოიყენოს insert_sorted,

686
00:52:43,000 --> 00:52:50,000
მინდა მოდით უბრალოდ, ვამბობთ მე prepend 6,

687
00:52:50,000 --> 00:52:55,000
მაშინ ჩემი დაკავშირებული სიაში აპირებს გახდეს ამ.

688
00:52:55,000 --> 00:53:01,000
ახლა აზრი არ აქვს, ისე insert_sorted, შეგიძლიათ უბრალოდ ვივარაუდოთ

689
00:53:01,000 --> 00:53:04,000
რომ სიაში დალაგებულია, თუმცა ოპერაციების არსებობს

690
00:53:04,000 --> 00:53:09,000
რომელიც შეიძლება გამოიწვიოს იგი არ იყოს დახარისხებული, და ამით ყველაფერი მთავრდება.

691
00:53:09,000 --> 00:53:20,000
მოძებნა გამოსადეგი ჩანართით ისე ეს ის ძირითადი რამ, რაც სხვებისათვის უნდა განახორციელოს.

692
00:53:20,000 --> 00:53:24,000
>> ახლა მიიღოს წუთის გავაკეთოთ სიგრძე და შეიცავს,

693
00:53:24,000 --> 00:53:30,000
და იმ უნდა იყოს შედარებით სწრაფი.

694
00:53:41,000 --> 00:53:48,000
Nearing დახურვის დრო, ასე რომ ვინმეს აქვს რამე სიგრძე ან შეიცავს?

695
00:53:48,000 --> 00:53:50,000
ისინი იქნება თითქმის იდენტურია.

696
00:53:50,000 --> 00:53:57,000
[სტუდენტური] სიგრძე.

697
00:53:57,000 --> 00:54:01,000
ვნახოთ, გადასინჯვის.

698
00:54:01,000 --> 00:54:04,000
Okay.

699
00:54:12,000 --> 00:54:15,000
თქვენ მინდა განვმარტო?

700
00:54:15,000 --> 00:54:21,000
[სტუდენტური] მე უბრალოდ შექმნათ კურსორი კვანძის და ინიციალიზაცია მას პირველი, რომელიც ჩვენი გლობალური ცვლადი,

701
00:54:21,000 --> 00:54:27,000
და მერე შეამოწმეთ თუ null ასე რომ არ მიიღოთ seg ბრალია და დაბრუნების 0 თუ ეს საქმე.

702
00:54:27,000 --> 00:54:34,000
წინააღმდეგ შემთხვევაში, მე loop მეშვეობით, შენახვა ტრეკზე ფარგლებში მთელი რიცხვი

703
00:54:34,000 --> 00:54:38,000
რამდენჯერ მე შემოწმდა შემდეგი ელემენტის სიაში

704
00:54:38,000 --> 00:54:43,000
და იმავე ნამატი ოპერაცია ასევე წვდომას, რომ ფაქტობრივი ელემენტს,

705
00:54:43,000 --> 00:54:47,000
და მერე მუდმივად მიიღოს შეამოწმეთ, რომ ეს null,

706
00:54:47,000 --> 00:54:56,000
და თუ ეს null, მაშინ ხერხდება და მხოლოდ ბრუნდება რაოდენობის ელემენტები მე შემოწმდა.

707
00:54:56,000 --> 00:55:01,000
>> [Rob ბ] ვინმეს აქვს რაიმე კომენტარს არაფერი?

708
00:55:01,000 --> 00:55:06,000
ეს გამოიყურება ჯარიმა სისწორის ჭკვიანი.

709
00:55:06,000 --> 00:55:10,000
[სტუდენტური] არა მგონია, თქვენ უნდა კვანძის == null.

710
00:55:10,000 --> 00:55:13,000
ჰო, ასე რომ, თუ კვანძის == null დაბრუნების 0.

711
00:55:13,000 --> 00:55:18,000
მაგრამ თუ კვანძის == null მაშინ ამ-oh, არსებობს სისწორის საკითხი.

712
00:55:18,000 --> 00:55:23,000
ეს იყო მხოლოდ თქვენ დაბრუნების მე, მაგრამ ეს არ ფარგლებს ახლავე.

713
00:55:23,000 --> 00:55:30,000
თქვენ უბრალოდ უნდა int i, ასე რომ = 0.

714
00:55:30,000 --> 00:55:34,000
მაგრამ თუ კვანძის არის null, მერე ისევ იქნება 0,

715
00:55:34,000 --> 00:55:39,000
და ჩვენ ვაპირებთ დაბრუნებას 0, ასე რომ ამ შემთხვევაში იდენტურია.

716
00:55:39,000 --> 00:55:48,000
კიდევ ერთი საერთო რამ არის შენარჩუნება დეკლარაცია

717
00:55:48,000 --> 00:55:51,000
საქართველოს კვანძის შიგნით ამისთვის loop.

718
00:55:51,000 --> 00:55:54,000
თქვენ შეიძლება ითქვას-ო, არა.

719
00:55:54,000 --> 00:55:56,000
მოდით შეინახოს იგი როგორც ამ.

720
00:55:56,000 --> 00:55:59,000
მე ალბათ დააყენა int i = 0 აქ,

721
00:55:59,000 --> 00:56:05,000
შემდეგ კვანძის * node = პირველი აქ.

722
00:56:05,000 --> 00:56:11,000
და ეს არის ალბათ ასე, მოშორების ეს ახლა.

723
00:56:11,000 --> 00:56:14,000
ეს არის ალბათ როგორ მინდა არ წერია ეს.

724
00:56:14,000 --> 00:56:21,000
თქვენ შეიძლება ასევე-ეძებს ის მოსწონს ეს.

725
00:56:21,000 --> 00:56:25,000
ამ loop სტრუქტურა უფლება აქ

726
00:56:25,000 --> 00:56:30,000
უნდა იყოს თითქმის როგორც ბუნებრივი თქვენ როგორც int i = 0

727
00:56:30,000 --> 00:56:33,000
მე ნაკლებია, ვიდრე სიგრძეზე მასივი მე + +.

728
00:56:33,000 --> 00:56:38,000
თუ ასე თქვენ iterate მეტი მასივი, ასე თქვენ iterate მეტი უკავშირდება სიაში.

729
00:56:38,000 --> 00:56:45,000
>> ეს უნდა იყოს მეორე ბუნება რაღაც მომენტში.

730
00:56:45,000 --> 00:56:50,000
ამის გათვალისწინებით, ეს იქნება თითქმის იგივე.

731
00:56:50,000 --> 00:56:57,000
თქვენ ვაპირებთ გვინდა iterate მეტი დაკავშირებული სიაში.

732
00:56:57,000 --> 00:57:02,000
თუ node-არ ვიცი რა ღირებულება ეწოდება.

733
00:57:02,000 --> 00:57:04,000
Node მე.

734
00:57:04,000 --> 00:57:15,000
თუ ღირებულება, რომ კვანძის = ვბრუნდები ასეა, და ამით ყველაფერი მთავრდება.

735
00:57:15,000 --> 00:57:18,000
გაითვალისწინეთ, რომ ერთადერთი გზა ჩვენ უნდა დააბრუნოს ყალბი

736
00:57:18,000 --> 00:57:23,000
არის თუ ჩვენ iterate მთელ უკავშირდება სიაში და არასდროს დაბრუნდება ასეა,

737
00:57:23,000 --> 00:57:29,000
ასე რომ რა ეს იმას.

738
00:57:29,000 --> 00:57:36,000
როგორც მინიშნება-ჩვენ ალბათ ვერ მიიღებენ, რათა დამატება ან prepend.

739
00:57:36,000 --> 00:57:39,000
>> სწრაფი ბოლო შენიშვნა.

740
00:57:39,000 --> 00:57:52,000
თუ ხედავთ სტატიკური სიტყვით, ასე ვთქვათ სტატიკური int რაოდენობა = 0,

741
00:57:52,000 --> 00:57:56,000
შემდეგ ვაკეთებთ რაოდენობა + +, შეგიძლიათ ძირითადად ვფიქრობ, რომ ეს გლობალური ცვლადი,

742
00:57:56,000 --> 00:58:00,000
მიუხედავად იმისა, რომ მე უბრალოდ განაცხადა, რომ ეს არ არის, თუ როგორ ვაპირებთ განვახორციელოთ სიგრძე.

743
00:58:00,000 --> 00:58:06,000
მე ამით აქ და შემდეგ ითვლიან + +.

744
00:58:06,000 --> 00:58:11,000
არანაირად შეგვიძლია შემოსვლა კვანძის ჩვენს დაკავშირებული სიაში ჩვენ დამატება ჩვენი რაოდენობა.

745
00:58:11,000 --> 00:58:15,000
წერტილი ეს რა სტატიკურ სიტყვით ნიშნავს.

746
00:58:15,000 --> 00:58:20,000
თუ მე უბრალოდ ჰქონდა int რაოდენობა = 0, რომელიც იქნება რეგულარული წლის გლობალური ცვლადი.

747
00:58:20,000 --> 00:58:25,000
რა სტატიკურ int რაოდენობა ნიშნავს, რომ ეს არის გლობალური ცვლადი ამ ფაილის.

748
00:58:25,000 --> 00:58:28,000
შეუძლებელია, რომ ზოგიერთი სხვა ფაილი,

749
00:58:28,000 --> 00:58:34,000
მინდა იფიქრონ pset 5, თუ თქვენ არ დაიწყო.

750
00:58:34,000 --> 00:58:39,000
თქვენ გაქვთ ორივე speller.c, და თქვენ dictionary.c,

751
00:58:39,000 --> 00:58:42,000
და თუ უბრალოდ განაცხადოს რამ გლობალური, მაშინ არაფერი speller.c

752
00:58:42,000 --> 00:58:45,000
შეიძლება გამოიყენოთ in dictionary.c და პირიქით.

753
00:58:45,000 --> 00:58:48,000
გლობალური ცვლადები ხელმისაწვდომია ნებისმიერი. გ ფაილი,

754
00:58:48,000 --> 00:58:54,000
მაგრამ სტატიკური ცვლადები მხოლოდ ხელმისაწვდომი შიგნიდან ფაილი თვით,

755
00:58:54,000 --> 00:59:01,000
ასე შიგნით მართლწერის შემოწმება ან შიგნით dictionary.c,

756
00:59:01,000 --> 00:59:06,000
ეს არის ერთგვარი როგორ მინდა განვაცხადო ჩემი ცვლადი ამისთვის ზომა ჩემი მასივი

757
00:59:06,000 --> 00:59:10,000
ან ზომის ჩემი პუნქტების სიტყვების ლექსიკონი.

758
00:59:10,000 --> 00:59:15,000
მას შემდეგ, რაც მე არ მინდა განვაცხადო გლობალური ცვლადი, რომ ვინმეს ხელი მიუწვდება,

759
00:59:15,000 --> 00:59:18,000
მე ნამდვილად მხოლოდ მაინტერესებს, ჩემი საკუთარი მიზნებისთვის.

760
00:59:18,000 --> 00:59:21,000
>> კარგი რამ შესახებ ეს არის ასევე მთელი სახელი შეჯახების პერსონალი.

761
00:59:21,000 --> 00:59:27,000
თუ რაიმე სხვა ფაილი ცდილობს გლობალური ცვლადში რაოდენობა, რამ წასვლა ძალიან, ძალიან არასწორი,

762
00:59:27,000 --> 00:59:33,000
ასე რომ ეს ლამაზად ინარჩუნებს რამ უსაფრთხო, და მხოლოდ თქვენ შეგიძლიათ თქვათ ეს,

763
00:59:33,000 --> 00:59:38,000
და არავინ შეიძლება და, თუ ვინმე აცხადებს გლობალური ცვლადში რაოდენობა,

764
00:59:38,000 --> 00:59:43,000
მაშინ ხელს არ შეუშლის თქვენი სტატიკური ცვლადში რაოდენობა.

765
00:59:43,000 --> 00:59:47,000
რაც სტატიკური არის. ეს ფაილი გლობალური ცვლადი.

766
00:59:47,000 --> 00:59:52,000
>> კითხვები შესახებ არაფერი?

767
00:59:52,000 --> 00:59:59,000
ყველა კომპლექტი. Bye.

768
00:59:59,000 --> 01:00:03,000
[CS50.TV]