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

2
00:00:02,000 --> 00:00:04,000
[Nate Hardison] [ჰარვარდის უნივერსიტეტის]

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

4
00:00:07,000 --> 00:00:10,000
>> ყველა უფლება, მივესალმებით თავში მონაკვეთზე.

5
00:00:10,000 --> 00:00:13,000
ამ კვირის მონაკვეთზე ჩვენ ვაპირებთ რამდენიმე რამ.

6
00:00:13,000 --> 00:00:17,000
ჩვენ ვაპირებთ პირველი recap პრობლემა Set 2,

7
00:00:17,000 --> 00:00:20,000
რაც Caesar და Vigenère პრობლემა კომპლექტი.

8
00:00:20,000 --> 00:00:23,000
და შემდეგ ჩვენ ვაპირებთ ჩაყვინთვის შევიდა Quiz 0 მიმოხილვა

9
00:00:23,000 --> 00:00:26,000
და ხარჯავენ ცოტა დრო recapping რა ჩვენ ვისაუბრეთ

10
00:00:26,000 --> 00:00:30,000
თითოეულ ლექციების ჯერჯერობით, და ჩვენ ასევე გავაკეთებთ რამდენიმე პრობლემები

11
00:00:30,000 --> 00:00:32,000
საწყისი წინა წლის ვიქტორინებში.

12
00:00:32,000 --> 00:00:36,000
ამ გზით თქვენ ბიჭები გვყავს კარგი გზა მოსამზადებლად, რომ.

13
00:00:36,000 --> 00:00:40,000
>> უნდა დაიწყოს, მე გაიჭედოთ up რამდენიმე კარგი გადაწყვეტილებები

14
00:00:40,000 --> 00:00:45,000
ამისთვის წინა პრობლემა კომპლექტი, პრობლემა უცნობია 2, ამ სივრცეში.

15
00:00:45,000 --> 00:00:48,000
თუ ბიჭები ყველა მოხვდა ამ ბმულს

16
00:00:48,000 --> 00:00:53,000
და თუ დაწკაპავთ ჩემი სახელი და დააკლიკეთ ჩემი პირველი გადასინჯვის

17
00:00:53,000 --> 00:00:56,000
დაინახავთ caesar.c, სწორედ იმას, რასაც მე ეძებს.

18
00:00:56,000 --> 00:01:00,000
მოდით ვისაუბროთ ამ მართლაც სწრაფად.

19
00:01:00,000 --> 00:01:02,000
ეს არის მხოლოდ ნიმუში გადაწყვეტა.

20
00:01:02,000 --> 00:01:05,000
ეს არ არის აუცილებლად სრულყოფილი გადაწყვეტა.

21
00:01:05,000 --> 00:01:08,000
არსებობს ბევრი სხვადასხვა გზა წერენ ამ,

22
00:01:08,000 --> 00:01:10,000
მაგრამ არსებობს რამდენიმე რამ, რომ მინდოდა გააშუქებს

23
00:01:10,000 --> 00:01:13,000
რომ დავინახე, როგორც მე შეფასების, საერთო შეცდომები, ვფიქრობ

24
00:01:13,000 --> 00:01:18,000
ამ გადაწყვეტა არ ძალიან კარგი სამუშაო გატარება.

25
00:01:18,000 --> 00:01:22,000
>> პირველი არის გარკვეული სახის header კომენტარი ზედა.

26
00:01:22,000 --> 00:01:25,000
On ხაზების 1 მეშვეობით 7 ხედავთ ინფორმაცია

27
00:01:25,000 --> 00:01:28,000
რა ზუსტად ეს პროგრამა აკეთებს.

28
00:01:28,000 --> 00:01:32,000
კარგი სტანდარტული პრაქტიკა, როდესაც თქვენ წერილობით C კოდი

29
00:01:32,000 --> 00:01:35,000
მიუხედავად, თუ თქვენი პროგრამა შეიცავს ერთი ფაილი ან

30
00:01:35,000 --> 00:01:38,000
თუ არა ეს განხეთქილება, რამოდენიმე ფაილი, გვქონდეს გარკვეული

31
00:01:38,000 --> 00:01:40,000
orienting კომენტარი ზედა.

32
00:01:40,000 --> 00:01:43,000
ეს არის ასევე მათთვის, ვისაც გარეთ და დაწეროთ კოდი რეალურ ცხოვრებაში.

33
00:01:43,000 --> 00:01:47,000
ეს არის სადაც ისინი ყველაფერს დააყენა ინფორმაცია საავტორო უფლებების შესახებ.

34
00:01:47,000 --> 00:01:50,000
ქვემოთ მოცემულია # მოიცავს.

35
00:01:50,000 --> 00:01:55,000
On line 16 არსებობს ამ # განსაზღვრავს, რომელიც ჩვენ დაბრუნებას მხოლოდ ცოტა.

36
00:01:55,000 --> 00:01:59,000
და შემდეგ კიდევ ფუნქცია იწყება, ერთხელ მთავარ იწყება,

37
00:01:59,000 --> 00:02:03,000
რადგან ეს პროგრამა უკვე ყველა შეიცავს ერთი ფუნქცია

38
00:02:03,000 --> 00:02:09,000
ძალიან პირველი რაც ხდება და ეს ძალიან idiomatic და ტიპიური C პროგრამის

39
00:02:09,000 --> 00:02:14,000
რომ იღებს in command line არგუმენტები-ის არის, რომ იგი მაშინვე ამოწმებს

40
00:02:14,000 --> 00:02:18,000
>> ამისთვის არგუმენტი რაოდენობა, argc.

41
00:02:18,000 --> 00:02:24,000
მარჯვენა აქ ჩვენ ვხედავთ, რომ ეს პროგრამა ელოდება 2 არგუმენტები ზუსტად.

42
00:02:24,000 --> 00:02:27,000
გახსოვდეთ არსებობს, რომ პირველი არგუმენტი რომ სპეციალური ერთი

43
00:02:27,000 --> 00:02:29,000
რომ ყოველთვის პროგრამის დასახელება, რომელიც მიმდინარეობს აწარმოებს,

44
00:02:29,000 --> 00:02:31,000
სახელწოდება შესრულებად ფაილს.

45
00:02:31,000 --> 00:02:36,000
და მერე რა ეს იმას არის ეს ხელს უშლის მომხმარებლისთვის გაშვებული პროგრამა

46
00:02:36,000 --> 00:02:42,000
მეტი ან უფრო ნაკლები არგუმენტები.

47
00:02:42,000 --> 00:02:44,000
მიზეზი გვინდა შევამოწმოთ ეს დაუყოვნებლივ არის, რადგან

48
00:02:44,000 --> 00:02:52,000
ჩვენ არ შეგვიძლია რეალურად გავქთ ამ argv მასივი უფლება აქ საიმედოდ

49
00:02:52,000 --> 00:02:55,000
სანამ ჩვენ შეამოწმეს, თუ რამდენად დიდი ეს არის.

50
00:02:55,000 --> 00:02:58,000
>> ერთი საერთო შეცდომები დავინახე იყო ხალხი დაუყოვნებლივ წავიდეს

51
00:02:58,000 --> 00:03:01,000
და Grab argv [1].

52
00:03:01,000 --> 00:03:06,000
მათ მინდა დაიბრუნოს გასაღები არგუმენტი გარეთ მასივი და არ უნდა მე შეამოწმოს მასზე,

53
00:03:06,000 --> 00:03:11,000
შემდეგ კი მინდა გავაკეთოთ გამოცდა argc ასევე შემდეგი ტესტი,

54
00:03:11,000 --> 00:03:16,000
თუ არა პირველი არგუმენტი იყო მართლაც მთელი რიცხვი, ამავე დროს,

55
00:03:16,000 --> 00:03:20,000
და რომ არ მუშაობს, რადგან იმ შემთხვევაში, რომ არ არსებობს არგუმენტი

56
00:03:20,000 --> 00:03:26,000
თქვენ უნდა grabbing არგუმენტი, რომ იქ არ არის ან ცდილობს დაიბრუნოს ერთი რომ იქ არ არის.

57
00:03:26,000 --> 00:03:29,000
>> სხვა დიდი რამ, რომ თქვენ უნდა შეამჩნია ის არის, რომ

58
00:03:29,000 --> 00:03:32,000
თქვენ ყოველთვის გვინდა ამობეჭდოთ გარკვეული სასარგებლო შეცდომა

59
00:03:32,000 --> 00:03:34,000
რათა მომხმარებელს ორიენტი მათ.

60
00:03:34,000 --> 00:03:37,000
დარწმუნებული ვარ, თქვენ ყველა პროგრამების გასაშვებად, სადაც უეცრად იგი დამსხვრევაზე,

61
00:03:37,000 --> 00:03:41,000
და თქვენ ამ სასაცილოა პატარა დიალოგში, რომ pops up და აცხადებს,

62
00:03:41,000 --> 00:03:44,000
რაღაც horribly cryptic და იქნებ გაძლევთ შეცდომის კოდი ან რამე მაგდაგვარს

63
00:03:44,000 --> 00:03:47,000
რომ აზრი არა აქვს.

64
00:03:47,000 --> 00:03:50,000
ეს არის სადაც ნამდვილად გსურთ მოგვაწოდოთ რაიმე გამოსადეგი

65
00:03:50,000 --> 00:03:54,000
და მიზნად ისახავს მომხმარებლის ასე რომ, როდესაც ისინი გაუშვით დადიან "ოჰ," სახე პალმის.

66
00:03:54,000 --> 00:03:58,000
"მე ვიცი, ზუსტად რა უნდა გააკეთოს. ვიცი როგორ დაფიქსირება ამ."

67
00:03:58,000 --> 00:04:01,000
>> თუ არ ბეჭდვა გაგზავნა, მაშინ დასრულდება მდე რეალურად

68
00:04:01,000 --> 00:04:04,000
წასვლის მომხმარებლის წასვლა შეამოწმოს თქვენი კოდის

69
00:04:04,000 --> 00:04:07,000
გაერკვნენ, თუ რა მოხდა ისე.

70
00:04:07,000 --> 00:04:11,000
არსებობს გარკვეული ჯერ რომ თქვენ გამოიყენოთ სხვადასხვა შეცდომა კოდები.

71
00:04:11,000 --> 00:04:14,000
აქ ჩვენ მხოლოდ გამოიყენება ერთი ვთქვა იყო შეცდომა,

72
00:04:14,000 --> 00:04:16,000
იყო შეცდომა, იყო შეცდომა.

73
00:04:16,000 --> 00:04:20,000
Bigger პროგრამები, ხშირად პროგრამები, რომლებიც მოუწოდა სხვა პროგრამები,

74
00:04:20,000 --> 00:04:25,000
დაბრუნდება გარკვეული სპეციალური შეცდომა კოდები სხვადასხვა სცენარების

75
00:04:25,000 --> 00:04:28,000
to პროგრამულად დაუკავშირდეს, რაც თქვენ წინააღმდეგ შემთხვევაში

76
00:04:28,000 --> 00:04:32,000
უბრალოდ გამოიყენოთ ლამაზი English გზავნილი.

77
00:04:32,000 --> 00:04:35,000
ზემოთ.

78
00:04:35,000 --> 00:04:37,000
როგორც ვმუშაობთ down, ხედავთ ჩვენ გაიყვანოს გასაღები გარეთ.

79
00:04:37,000 --> 00:04:40,000
ჩვენ ვამოწმებთ თუ გასაღები ჯდება.

80
00:04:40,000 --> 00:04:42,000
მივიღებთ გზავნილი მომხმარებლის.

81
00:04:42,000 --> 00:04:46,000
მიზეზი ჩვენ გავაკეთებთ ამ გააკეთოს ხოლო loop-და ეს არის ის, რომ ჩვენ დაფარავს

82
00:04:46,000 --> 00:04:50,000
წელს ცოტა, მაგრამ აღმოჩნდება, რომ, თუ თქვენ აკრიფოთ კონტროლის D

83
00:04:50,000 --> 00:04:54,000
როდესაც თქვენ, რომ GetString სწრაფი on ტერმინალი

84
00:04:54,000 --> 00:04:59,000
რა, რომ რეალურად არ არის ის აგზავნის სპეციალური ხასიათის

85
00:04:59,000 --> 00:05:01,000
პროგრამის.

86
00:05:01,000 --> 00:05:05,000
ეს მოუწოდა ELF ან ფაილის დასასრულს ხასიათი.

87
00:05:05,000 --> 00:05:08,000
და ამ შემთხვევაში, ჩვენი გაგზავნა სიმებიანი იქნება null,

88
00:05:08,000 --> 00:05:14,000
ასე რომ, ეს არ იყო რაღაც ჩვენ შემოწმდება პრობლემის მითითებული თავად.

89
00:05:14,000 --> 00:05:17,000
>> მაგრამ როგორც კი, ახლა რომ დავიწყეთ ლაპარაკი პოინტერები

90
00:05:17,000 --> 00:05:21,000
და დინამიური მეხსიერების გამოყოფის შესახებ ბევრი,

91
00:05:21,000 --> 00:05:25,000
შემოწმების for null როდესაც თქვენ გაქვთ ფუნქცია, რომელიც შესაძლოა

92
00:05:25,000 --> 00:05:30,000
დაბრუნების null როგორც ფასეულობა არის ის, რაც თქვენ გსურთ მიიღონ ჩვევა აკეთებს.

93
00:05:30,000 --> 00:05:33,000
ეს არის, პირველ რიგში, აქ საილუსტრაციოდ.

94
00:05:33,000 --> 00:05:36,000
მაგრამ როცა ვხედავ GetString მომავალში,

95
00:05:36,000 --> 00:05:41,000
ასე საწყისი პრობლემა უცნობია 4 წლის, თქვენ გვინდა, რომ ეს გონებაში.

96
00:05:41,000 --> 00:05:44,000
ისევ და ისევ, ეს არ არის საკითხი პრობლემის უცნობია 3 ან წლიდან ჩვენ არ დაფარული იგი ამჟამად.

97
00:05:44,000 --> 00:05:53,000
საბოლოოდ, მივიღებთ ამ ნაწილზე, სადაც ჩვენ კიდევ მთავარ დაშიფვრის მარყუჟის,

98
00:05:53,000 --> 00:05:57,000
და არსებობს რამდენიმე რამ ხდება აქ.

99
00:05:57,000 --> 00:06:02,000
პირველი, ჩვენ iterate მთელ გაგზავნა სიმებიანი თავად.

100
00:06:02,000 --> 00:06:07,000
აქ ჩვენ ინახება strlen ზარის პირობებში,

101
00:06:07,000 --> 00:06:12,000
რომელიც ხმების თქვენ არ აღნიშნა, არ არის დიდი გზაა გასავლელი.

102
00:06:12,000 --> 00:06:15,000
თურმე ამ შემთხვევაში ეს ასევე არ დიდი,

103
00:06:15,000 --> 00:06:20,000
ნაწილობრივ იმიტომ, რომ ჩვენ შეცვლის შინაარსი გაგზავნა თავისთავად

104
00:06:20,000 --> 00:06:27,000
შიგნით ამისთვის loop ასე რომ, თუ ჩვენ გვაქვს გაგზავნა რომ 10 სიმბოლომდე

105
00:06:27,000 --> 00:06:32,000
პირველად ჩვენ ვიწყებთ რომ მარყუჟი strlen დაბრუნდება რა?

106
00:06:32,000 --> 00:06:35,000
10.

107
00:06:35,000 --> 00:06:40,000
>> მაგრამ თუ ჩვენ მაშინ ცვლილებები გაგზავნა, ვთქვათ ჩვენ ცვლილებები თავის მე -5 ხასიათი,

108
00:06:40,000 --> 00:06:46,000
და ჩვენ ჩააგდოს წელს \ 0 ხასიათი მე -5 პოზიცია,

109
00:06:46,000 --> 00:06:49,000
on მომდევნო iteration strlen (გაგზავნა) არ დაუბრუნდება რა თქმა

110
00:06:49,000 --> 00:06:52,000
პირველად ჩვენ iterated,

111
00:06:52,000 --> 00:06:56,000
მაგრამ ნაცვლად დაბრუნების 5 რადგან ჩვენ დაუშინეს ამ null Terminator,

112
00:06:56,000 --> 00:06:59,000
და სიმებიანი მისი სიგრძე განისაზღვრება

113
00:06:59,000 --> 00:07:03,000
მიერ პოზიცია, რომ \ 0.

114
00:07:03,000 --> 00:07:09,000
ამ შემთხვევაში, ეს არის დიდი გზაა გასავლელი, რადგან ჩვენ შეცვლის მას ადგილი.

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

116
00:07:13,000 --> 00:07:16,000
თუ შეგიძლიათ მიიღოთ მათემატიკის სწორი.

117
00:07:16,000 --> 00:07:19,000
ყველა რომ საჭირო არის, რათა შეამოწმოს თუ არა წერილი, რომ თქვენ ეძებს

118
00:07:19,000 --> 00:07:21,000
არის ზედა ან ამას.

119
00:07:21,000 --> 00:07:24,000
>> მიზეზი ჩვენ მხოლოდ უნდა შევამოწმოთ, რომ და არ გვაქვს შევამოწმოთ

120
00:07:24,000 --> 00:07:27,000
არის ალფა საქმე, რადგან

121
00:07:27,000 --> 00:07:30,000
თუ ხასიათი არის ზედა ან თუ ამას

122
00:07:30,000 --> 00:07:33,000
მაშინ ის აუცილებლად ანბანურ ასოს,

123
00:07:33,000 --> 00:07:38,000
იმიტომ, რომ ჩვენ არ გვაქვს ზედა და ამას ციფრები.

124
00:07:38,000 --> 00:07:41,000
სხვა რამ გავაკეთოთ და ეს პატარა სახიფათო-

125
00:07:41,000 --> 00:07:45,000
არის ჩვენ შეცვლილია სტანდარტული კეისრის კოდი ფორმულა

126
00:07:45,000 --> 00:07:49,000
რომ მივეცით პრობლემის კომპლექტი სპეციფიკაცია.

127
00:07:49,000 --> 00:07:52,000
რა არის განსხვავებული აქ არის ის, რომ ჩვენ ჩამოჭრილია მთლიანი თანხიდან

128
00:07:52,000 --> 00:07:58,000
წელს ზედა შემთხვევაში დედაქალაქში, შემდეგ კი ჩვენ დამატებული კაპიტალი

129
00:07:58,000 --> 00:08:02,000
უკან დასასრულს.

130
00:08:02,000 --> 00:08:05,000
>> მე ვიცი რამდენიმე თქვენგანს გაკეთდეს ამ თქვენს კოდი.

131
00:08:05,000 --> 00:08:09,000
ხომ ნებისმიერ ხაზვის თქვენს წარდგინება?

132
00:08:09,000 --> 00:08:13,000
თქვენ ეს. შეგიძლიათ განმარტონ, თუ რა ეს იმას, Sahb?

133
00:08:13,000 --> 00:08:18,000
By subtracting ის, იმიტომ, რომ თქვენ გააკეთა mod უფლება მას შემდეგ,

134
00:08:18,000 --> 00:08:21,000
თქვენ უნდა მიიღოს იგი გარეთ, რათა გზა თქვენ [ხველების] პოზიცია.

135
00:08:21,000 --> 00:08:25,000
ხოლო შემდეგ დასძინა უკან მოგვიანებით თქვენ გადაინაცვლა მეტი ერთი, რომ თქვენ სურდა.

136
00:08:25,000 --> 00:08:27,000
ჰო, ზუსტად.

137
00:08:27,000 --> 00:08:32,000
რა Sahb განაცხადა იყო ის, რომ როდესაც ჩვენ გვინდა დაამატოთ

138
00:08:32,000 --> 00:08:36,000
ჩვენი გაგზავნა და ჩვენი გასაღები ერთად

139
00:08:36,000 --> 00:08:42,000
და შემდეგ mod რომ, თავდაცვის სამინისტროს, რომ NUM_LETTERS,

140
00:08:42,000 --> 00:08:50,000
თუ ჩვენ არ მასშტაბირება ჩვენი გაგზავნა შევიდა შესაბამისი 0 დან 25 Range პირველი,

141
00:08:50,000 --> 00:08:54,000
მაშინ ჩვენ შეიძლება დასრულდება მდე მიღების მართლაც უცნაური ხმების

142
00:08:54,000 --> 00:08:59,000
რადგან ღირებულებებს რომ ჩვენ შევხედავთ შევხედოთ გაგზავნა [i],

143
00:08:59,000 --> 00:09:03,000
შევხედოთ შ ხასიათი ჩვენი ბარის ტექსტში გაგზავნა,

144
00:09:03,000 --> 00:09:08,000
არის ღირებულების სადღაც ამ 65 დან 122 დიაპაზონი

145
00:09:08,000 --> 00:09:13,000
ეფუძნება ASCII ღირებულებების ზედა მეშვეობით ამას z.

146
00:09:13,000 --> 00:09:18,000
და ამრიგად, როდესაც თავდაცვის სამინისტროს მიერ 26 ან NUM_LETTERS,

147
00:09:18,000 --> 00:09:23,000
მას შემდეგ იყო ჩვენი # განსაზღვრავს ზედა მარჯვენა აქ,

148
00:09:23,000 --> 00:09:28,000
რომ აპირებს მოგვცეს ღირებულება, რომელიც არის ამ 0 დან 25 დიაპაზონი,

149
00:09:28,000 --> 00:09:30,000
და ჩვენ გვჭირდება გზა მაშინ მასშტაბი რომ უკან მდე

150
00:09:30,000 --> 00:09:32,000
და მიიღეთ იგი შესაბამის ASCII სპექტრი.

151
00:09:32,000 --> 00:09:36,000
უმარტივეს გზას გავაკეთებთ არის მხოლოდ მასშტაბის ყველაფერი ქვევით

152
00:09:36,000 --> 00:09:39,000
შევიდა 0 დან 25 ქედიდან იწყება,

153
00:09:39,000 --> 00:09:43,000
და მერე გადაიტანოს ყველაფერი უკან მდე დასასრულს.

154
00:09:43,000 --> 00:09:46,000
>> კიდევ ერთი საერთო შეცდომა რომ დავინახე ხალხს გადაეყარონ ის არის, რომ

155
00:09:46,000 --> 00:09:50,000
თუ არ მართლაც ამ სკალირების დაუყოვნებლივ

156
00:09:50,000 --> 00:09:53,000
და თქვენ დაამატოთ გაგზავნა და გასაღები ერთად და თქვენ დაამატოთ ისინი, ვთქვათ,

157
00:09:53,000 --> 00:09:58,000
შევიდა char ცვლადი, პრობლემა, რომ

158
00:09:58,000 --> 00:10:01,000
არის წლიდან გაგზავნა [i] ეს არის შედარებით დიდი რაოდენობის დასაწყისისთვის-

159
00:10:01,000 --> 00:10:05,000
გვახსოვს ის მინიმუმ 65 თუ ზედა ხასიათი-

160
00:10:05,000 --> 00:10:09,000
თუ თქვენ გაქვთ დიდი გასაღები, ვთქვათ, რაღაც 100,

161
00:10:09,000 --> 00:10:13,000
და თქვენ დაამატოთ იმ 2 ერთად შევიდა ხელმოწერილი char თქვენ აპირებს მიიღოს overflow.

162
00:10:13,000 --> 00:10:17,000
თქვენ აპირებს მიიღოს ღირებულება რომ აღემატება 127,

163
00:10:17,000 --> 00:10:22,000
რაც ყველაზე დიდი ღირებულება, რომ char ცვლადი შეიძლება გამართავს.

164
00:10:22,000 --> 00:10:26,000
ერთხელ, ამიტომ მინდა გსურთ, რომ სახის რამ იწყება.

165
00:10:26,000 --> 00:10:29,000
ზოგიერთი ხალხი გარშემო, რომ საქმე, რომელსაც აკეთებს, თუ სხვაგან და ტესტირების

166
00:10:29,000 --> 00:10:33,000
რომ ნახოთ, თუ ამას overflow ადრე აკეთებდა რომ,

167
00:10:33,000 --> 00:10:36,000
მაგრამ ამ გზით იღებს გარშემო რომ.

168
00:10:36,000 --> 00:10:40,000
და შემდეგ ამ გადაწყვეტა ჩვენ ამობეჭდილი მთელი სიმებიანი დროს ბოლომდე.

169
00:10:40,000 --> 00:10:45,000
სხვა ადამიანები, ამობეჭდილი ხასიათი დროს. ორივე გასაოცარია.

170
00:10:45,000 --> 00:10:51,000
ამ ეტაპზე, რა ბიჭებს რაიმე კითხვა, ნებისმიერი კომენტარი ამის შესახებ?

171
00:10:51,000 --> 00:10:56,000
რამ გსურთ, რამ არ მოგწონთ?

172
00:10:56,000 --> 00:10:58,000
>> მე მქონდა შეკითხვა.

173
00:10:58,000 --> 00:11:01,000
იქნებ მე გამომრჩა ის დროს თქვენი განმარტება, მაგრამ რამდენად შეესაბამება ეს პროგრამა

174
00:11:01,000 --> 00:11:07,000
გაფართოებული ფართების დამაკავშირებელი გასაღები სიგრძეზე ტექსტი?

175
00:11:07,000 --> 00:11:10,000
ეს არის უბრალოდ კეისრის კოდი. >> ოჰ, უკაცრავად, yeah.

176
00:11:10,000 --> 00:11:13,000
ჰო, ჩვენ დავინახავთ, რომ.

177
00:11:13,000 --> 00:11:16,000
In კეისრის კოდი მივიღეთ გარშემო, რომ რადგან

178
00:11:16,000 --> 00:11:18,000
ჩვენ მხოლოდ flipped სიმბოლო.

179
00:11:18,000 --> 00:11:27,000
ჩვენ მხოლოდ გარდამავალია მათ თუ ისინი ზედა ან ამას.

180
00:11:27,000 --> 00:11:32,000
თქვენ ბიჭები შეგრძნება საკმაოდ კარგი ამის შესახებ?

181
00:11:32,000 --> 00:11:34,000
Feel free to copy ამ სახლს, მას,

182
00:11:34,000 --> 00:11:37,000
შეადაროთ იგი რასაც თქვენ ბიჭები დაწერა.

183
00:11:37,000 --> 00:11:42,000
აუცილებლად მოგერიდებათ გამოგვიგზავნოთ კითხვები ამის შესახებ ძალიან.

184
00:11:42,000 --> 00:11:46,000
ისევ და ისევ, გააცნობიეროს, რომ მიზანი აქ თქვენი პრობლემა ადგენს

185
00:11:46,000 --> 00:11:50,000
არ არის მისაღებად თქვენ ბიჭები დაწერა სრულყოფილი კოდი თქვენი პრობლემა კომპლექტი.

186
00:11:50,000 --> 00:11:57,000
ეს სწავლის გამოცდილება. Yeah.

187
00:11:57,000 --> 00:12:01,000
>> თავში do ხოლო მარყუჟის, თუ იგი შეადგენს null,

188
00:12:01,000 --> 00:12:06,000
ასე null უბრალოდ არაფერს ნიშნავს, უბრალოდ დააჭიროთ?

189
00:12:06,000 --> 00:12:12,000
Null არის სპეციალური მაჩვენებელი ღირებულების,

190
00:12:12,000 --> 00:12:17,000
და ჩვენ ვიყენებთ null როდესაც ჩვენ მინდა ვთქვა

191
00:12:17,000 --> 00:12:23,000
ჩვენ გვაქვს მაჩვენებელი ცვლადს, რომელიც მიუთითებს არაფერი.

192
00:12:23,000 --> 00:12:28,000
და ა.შ. როგორც წესი, ეს ნიშნავს, რომ ამ ცვლადი, ამ გაგზავნა ცვლადი

193
00:12:28,000 --> 00:12:35,000
არის ცარიელი, და აქ, რადგან ჩვენ გამოყენებით CS50 სპეციალური string ტიპის,

194
00:12:35,000 --> 00:12:37,000
რა არის CS50 string ტიპის?

195
00:12:37,000 --> 00:12:42,000
გინახავთ რა არის, როდესაც დავით გამოყვანილია hood ლექციების?

196
00:12:42,000 --> 00:12:44,000
ეს ხმაურიანი-ის მაჩვენებელი, არა?

197
00:12:44,000 --> 00:12:48,000
Okay, yeah. >> ეს char *.

198
00:12:48,000 --> 00:12:52,000
და ასე ნამდვილად შეგვეძლო შეცვლის ამ

199
00:12:52,000 --> 00:12:56,000
უფლება აქ char * გაგზავნა,

200
00:12:56,000 --> 00:13:04,000
და ასე GetString ფუნქცია, თუ იგი არ წარმატებით მიიღოს სიმებიანი საწყისი მომხმარებელი,

201
00:13:04,000 --> 00:13:08,000
მას არ შეუძლია გარჩევის სიმებიანი და ერთ შემთხვევაში, რომელშიც იგი ვერ გარჩევის სიმებიანი

202
00:13:08,000 --> 00:13:11,000
არის თუ მომხმარებელი სახის ფაილის დასასრულს ხასიათი, კონტროლის D,

203
00:13:11,000 --> 00:13:17,000
რომელიც არ არის რაღაც თქვენ ჩვეულებრივ აკეთებთ, მაგრამ თუ ეს მოხდება

204
00:13:17,000 --> 00:13:20,000
მაშინ ფუნქცია დააბრუნებს ამ null ღირებულება, როგორც გზას ვამბობ,

205
00:13:20,000 --> 00:13:23,000
"Hey, I ვერ string."

206
00:13:23,000 --> 00:13:27,000
რა მოხდება, თუ არ დააყენა გაგზავნა = null,

207
00:13:27,000 --> 00:13:30,000
რაც არის ის, რასაც ჩვენ არ აკეთებდა ჯერ არ გაქვთ?

208
00:13:30,000 --> 00:13:32,000
რატომ უნდა იყოს, რომ პრობლემა აქ?

209
00:13:32,000 --> 00:13:38,000
რადგან ვიცი, რომ ჩვენ ვისაუბრეთ ცოტა ლექციების შესახებ მეხსიერების გაჟონვის.

210
00:13:38,000 --> 00:13:42,000
ჰო, მოდით, ჯერ ვნახოთ, რა მოხდება.

211
00:13:42,000 --> 00:13:44,000
>> ბასილ კითხვაზე იყო, თუ რა მოხდება, თუ არ რეალურად

212
00:13:44,000 --> 00:13:48,000
ამ გაგზავნა = null ტესტი?

213
00:13:48,000 --> 00:13:51,000
მოდით გადახვევა მდე დაბრუნება.

214
00:13:51,000 --> 00:13:53,000
თქვენ ბიჭები შეიძლება კომენტარის ამ გარეთ.

215
00:13:53,000 --> 00:13:55,000
სინამდვილეში, მე შეინახეთ ის გადასინჯვის.

216
00:13:55,000 --> 00:13:58,000
ეს იქნება ცვლილებათა 3.

217
00:13:58,000 --> 00:14:02,000
რა თქვენ უნდა გააკეთოთ, რომ აწარმოებს ამ პროგრამის თქვენ უნდა დააჭიროთ ამ Gear ხატი აქ,

218
00:14:02,000 --> 00:14:04,000
და თქვენ უნდა დაამატოთ არგუმენტი მას.

219
00:14:04,000 --> 00:14:10,000
თქვენ უნდა მისცეს მას გასაღები არგუმენტი, რადგან ჩვენ გვინდა კორიდორი ბრძანების არგუმენტი.

220
00:14:10,000 --> 00:14:13,000
აქ მე ვაპირებ მისთვის ხმების 3. მომწონს 3.

221
00:14:13,000 --> 00:14:19,000
ახლა zooming უკან გარეთ, გაშვებული პროგრამა.

222
00:14:19,000 --> 00:14:24,000
ეს გაშვებული, შედგენა, შენობა.

223
00:14:24,000 --> 00:14:27,000
Here We Go. ეს ლოდინი უნდა აიძულა.

224
00:14:27,000 --> 00:14:33,000
თუ მე აკრიფოთ რაღაც მიესალმები-სად, რომ წავიდეთ?

225
00:14:33,000 --> 00:14:38,000
ოჰ, ჩემი პროგრამა აიღო ძალიან გრძელია გასაშვებად. მე jawing დიდი ხანია.

226
00:14:38,000 --> 00:14:40,000
აქ გადის.

227
00:14:40,000 --> 00:14:43,000
ახლა აკრიფოთ hello.

228
00:14:43,000 --> 00:14:46,000
ჩვენ ვხედავთ, რომ ეს encrypts სათანადოდ.

229
00:14:46,000 --> 00:14:52,000
ახლა რა ხდება, თუ სწრაფი GetString დაბრუნების null?

230
00:14:52,000 --> 00:14:57,000
გახსოვდეთ, მე ვთქვი, რომ ჩვენ, რომ დაჭერით კონტროლის D ამავე დროს.

231
00:14:57,000 --> 00:14:59,000
მე გადახვევა აქ. ჩვენ გაუშვით ერთხელ.

232
00:14:59,000 --> 00:15:01,000
შენობა. არსებობს მიდის.

233
00:15:01,000 --> 00:15:04,000
ახლა, როდესაც მე მოხვდა კონტროლის D

234
00:15:04,000 --> 00:15:12,000
მე მივიღე ეს ხაზი, რომელიც ამბობს opt/sandbox50/bin/run.sh, სეგმენტირება ბრალია.

235
00:15:12,000 --> 00:15:15,000
თქვენ ბიჭები ჩანს, რომ ადრე?

236
00:15:15,000 --> 00:15:17,000
>> [სტუდენტური] რატომ არის იქ არ >> უკაცრავად?

237
00:15:17,000 --> 00:15:20,000
[სტუდენტური] რატომ არის იქ არ core ნაგავსაყრელი ამ შემთხვევაში?

238
00:15:20,000 --> 00:15:26,000
ძირითადი ნაგავსაყრელი არის-საკითხია, თუ რატომ არის იქ არ core ნაგავსაყრელი აქ?

239
00:15:26,000 --> 00:15:29,000
კითხვაზე არის ის, რომ იქ არ უნდა იყოს, მაგრამ ეს ძირითადი ნაგავსაყრელი არის ფაილი

240
00:15:29,000 --> 00:15:31,000
რომ იღებს ინახება მყარ დისკზე.

241
00:15:31,000 --> 00:15:34,000
ამ შემთხვევაში ჩვენ გამორთულია ძირითადი dumps

242
00:15:34,000 --> 00:15:37,000
წლის პერსპექტივაში სერვერი ისე, რომ ჩვენ არ გვაქვს ადამიანებს seg faulting

243
00:15:37,000 --> 00:15:40,000
და მშენებლობაზე ტონა ძირითადი dumps.

244
00:15:40,000 --> 00:15:46,000
თუმცა შესაძლოა კიდევ ერთი.

245
00:15:46,000 --> 00:15:48,000
Core dumps არიან სახის რამ, რომ შეგიძლიათ ხშირად გამორთოთ,

246
00:15:48,000 --> 00:15:52,000
და ზოგჯერ, რასაც აკეთებთ.

247
00:15:52,000 --> 00:15:55,000
სეგმენტაცია ბრალია, რომ პასუხი გასცეს შეკითხვას, ბასილ,

248
00:15:55,000 --> 00:16:00,000
ამბობს, რომ ჩვენ შევეცადეთ წვდომისათვის მაჩვენებელი

249
00:16:00,000 --> 00:16:05,000
რომ არ იყო მითითებული, რომ აღვნიშნო, რომ არაფერს.

250
00:16:05,000 --> 00:16:09,000
დამახსოვრება Binky in ვიდეო, როდესაც Binky ცდილობს

251
00:16:09,000 --> 00:16:12,000
წასვლა შედიხართ მაჩვენებელი, არ მიუთითებს რაიმე?

252
00:16:12,000 --> 00:16:16,000
ამ შემთხვევაში ვფიქრობ ტექნიკურად მაჩვენებელი არის მიუთითებს რაღაც.

253
00:16:16,000 --> 00:16:20,000
ეს მიუთითებს null, რომელიც ტექნიკურად 0,

254
00:16:20,000 --> 00:16:25,000
მაგრამ, რომ არ არის დადგენილი იყოს სეგმენტი, რომ არ არის ხელმისაწვდომი

255
00:16:25,000 --> 00:16:28,000
თქვენი პროგრამა, ასე რომ თქვენ მიიღოთ სეგმენტაცია ბრალია

256
00:16:28,000 --> 00:16:31,000
იმიტომ, რომ თქვენ არ წვდომის მეხსიერების რომ წელს ძალაში სეგმენტი

257
00:16:31,000 --> 00:16:38,000
მოსწონს ბევრი სეგმენტი ან დასტის სეგმენტი ან მონაცემები სეგმენტი.

258
00:16:38,000 --> 00:16:40,000
ზემოთ.

259
00:16:40,000 --> 00:16:48,000
აღარ კითხვებს Caesar?

260
00:16:48,000 --> 00:16:51,000
>> მოდით გადაადგილება. მოდით შევხედოთ ცვლილებათა 2 მართლაც სწრაფად.

261
00:16:51,000 --> 00:17:00,000
სწორედ Vigenère.

262
00:17:00,000 --> 00:17:04,000
აქ Vigenère

263
00:17:04,000 --> 00:17:06,000
ჩვენ გავლა ამ ერთი საკმაოდ სწრაფად, რადგან, კიდევ ერთხელ,

264
00:17:06,000 --> 00:17:10,000
Vigenère და ცეზარ საკმაოდ მსგავსი.

265
00:17:10,000 --> 00:17:12,000
ჰედერის კომენტარი მანამდე,

266
00:17:12,000 --> 00:17:17,000
# განსაზღვრავს მანამდე თავიდან ასაცილებლად გამოყენებით ამ ჯადოსნური ნომრები.

267
00:17:17,000 --> 00:17:21,000
ლამაზი რამ არის ამბობენ გვინდოდა გადავა

268
00:17:21,000 --> 00:17:23,000
სხვადასხვა ანბანი ან რამე მაგდაგვარს.

269
00:17:23,000 --> 00:17:26,000
ვიდრე მქონე წასვლა ხელით შეცვალოთ ყველა 26 წელს კოდი

270
00:17:26,000 --> 00:17:30,000
ჩვენ შეგვიძლია შევცვალოთ ეს 27 ან ვარდნა მისი დანგრევა

271
00:17:30,000 --> 00:17:34,000
თუ ჩვენ გამოყენებით სხვადასხვა დამწერლობას, სხვადასხვა ენებზე.

272
00:17:34,000 --> 00:17:38,000
ისევ და ისევ, ჩვენ მივიღეთ ამ შემოწმების არგუმენტი რაოდენობა,

273
00:17:38,000 --> 00:17:42,000
და მართლაც შეგიძლიათ თითქმის მიიღოს ეს თარგი.

274
00:17:42,000 --> 00:17:46,000
საკმაოდ ბევრი ყველა პროგრამა წერთ უნდა ჰქონდეს-

275
00:17:46,000 --> 00:17:50,000
თუ ის ბრძანება ხაზი არგუმენტები-ზოგიერთ თანმიმდევრობა ხაზები

276
00:17:50,000 --> 00:17:55,000
რომ წერია ასე დასაწყისშივე.

277
00:17:55,000 --> 00:17:59,000
სწორედ ერთერთი პირველი საღი აზრის ტესტები გსურთ.

278
00:17:59,000 --> 00:18:03,000
>> აქ რაც ჩვენ გააკეთა, ჩვენ მივიღეთ დარწმუნებულია, რომ

279
00:18:03,000 --> 00:18:06,000
სიტყვით იყო ძალაში, და რომ იყო მეორე გამშვები რომ გავაკეთეთ.

280
00:18:06,000 --> 00:18:11,000
გაითვალისწინეთ ერთხელ, რომ ჩვენ გამოყოფილი ამ საწყისი argc და 2.

281
00:18:11,000 --> 00:18:14,000
გაითვალისწინეთ, რომ ამ შემთხვევაში ერთი რამ, რომ ჩვენ უნდა გაეკეთებინათ იყო ნაცვლად

282
00:18:14,000 --> 00:18:18,000
გამოყენების to მე გვინდოდა, რათა შეამოწმოს მთელი ტექსტი,

283
00:18:18,000 --> 00:18:21,000
და იმისათვის, რომ გავაკეთოთ, რომ თქვენ ნამდვილად უნდა წახვიდე ხასიათი ხასიათი

284
00:18:21,000 --> 00:18:23,000
მეტი სიმებიანი.

285
00:18:23,000 --> 00:18:29,000
იქ არ არის კარგი გზა მოვუწოდებთ რაღაც მასზე

286
00:18:29,000 --> 00:18:31,000
რადგან კი, მაგალითად, რომ მე დავბრუნდები 0

287
00:18:31,000 --> 00:18:37,000
თუ მას არ შეუძლია გარჩევის რიცხვი, ისე, რომ არც კი მუშაობენ.

288
00:18:37,000 --> 00:18:42,000
ისევ, ლამაზი გაგზავნა ვეუბნებოდი მომხმარებლის ზუსტად რა მოხდა.

289
00:18:42,000 --> 00:18:45,000
მაშინ აქ, კიდევ ერთხელ, ჩვენ ასევე ამუშავებს შემთხვევაში

290
00:18:45,000 --> 00:18:50,000
მომხმარებლის ტიპების კონტროლი D შემთხვევითი ხასიათი.

291
00:18:50,000 --> 00:18:54,000
>> და შემდეგ Charlotte კითხვა ჰქონდა, ადრე, თუ როგორ ჩვენ შევძლებთ გამოტოვება ფართები

292
00:18:54,000 --> 00:18:57,000
ჩვენს სიმებიანი აქ.

293
00:18:57,000 --> 00:19:00,000
ეს იყო ერთგვარი მსგავსია იმისა, რაც ჩვენ ერთად Myspace პროგრამა

294
00:19:00,000 --> 00:19:04,000
რომ ჩვენ ნაწილში, და გზა ამ მუშაობდა

295
00:19:04,000 --> 00:19:08,000
ის არის, რომ ჩვენ მუხლუხიანი რაოდენობის ასოები, რომლებიც ჩვენ გვინდა უნახავს.

296
00:19:08,000 --> 00:19:13,000
როგორც ჩვენ ფეხით მეტი გაგზავნა სიმებიანი, როგორც ჩვენ ფეხით მეტი ხასიათი ხასიათი,

297
00:19:13,000 --> 00:19:16,000
ჩვენ მუხლუხიანი ინდექსი როგორც ნაწილი ჩვენი ამისთვის მარყუჟი, და შემდეგ ჩვენ ასევე მუხლუხიანი

298
00:19:16,000 --> 00:19:21,000
პუნქტების წერილები, ისე არასამთავრობო სპეციალური სიმბოლოების, არასამთავრობო ციფრები, არასამთავრობო თეთრი სივრცე

299
00:19:21,000 --> 00:19:27,000
რომ ჩვენ გვინდა ჩანს ცალკე ცვლადი.

300
00:19:27,000 --> 00:19:33,000
და მაშინ ეს გადაწყვეტა modifies გასაღები

301
00:19:33,000 --> 00:19:41,000
მიიღოს ფაქტობრივი გასაღები მთელი რიცხვი, და ეს იმას, რომ on the fly,

302
00:19:41,000 --> 00:19:47,000
უფლება სანამ შემდეგ გრძელდება დაშიფვრა ფაქტობრივი გაგზავნა ხასიათი.

303
00:19:47,000 --> 00:19:50,000
არსებობს რამდენიმე გადაწყვეტილებები, რომლებიც შესანიშნავად დიდი ძალიან

304
00:19:50,000 --> 00:19:58,000
რომ ცვლილებები გასაღები up როდესაც ტესტირება გასაღები მოქმედების.

305
00:19:58,000 --> 00:20:01,000
გარდა ამისა მიღების დარწმუნებული ვარ, რომ ხასიათი და სიტყვით

306
00:20:01,000 --> 00:20:05,000
იყო ანბანურ ასოს იგი ასევე აღმოჩნდა, რომ შევიდა მთელი რიცხვი

307
00:20:05,000 --> 00:20:13,000
in 0 დან 25 Range შემდეგ გამოტოვოთ მქონე გავაკეთოთ, რომ მოგვიანებით ამ for loop.

308
00:20:13,000 --> 00:20:18,000
ერთხელ, ხედავთ აქ ეს ნამდვილად ზუსტად იგივე კოდი

309
00:20:18,000 --> 00:20:22,000
რომ ჩვენ გამოყენებული Caesar ამ ეტაპზე.

310
00:20:22,000 --> 00:20:25,000
თქვენ აკეთებთ ზუსტი იგივე, ასე რომ რეალური შეასრულა არის მჭიდროდაა გარეთ

311
00:20:25,000 --> 00:20:30,000
როგორ ვაქციოთ სიტყვით შევიდა რიცხვი.

312
00:20:30,000 --> 00:20:35,000
>> ერთი რამ, რომ ჩვენ აქ, რომ არის პატარა მკვრივი

313
00:20:35,000 --> 00:20:39,000
არის ჩვენ გაიმეორა ეს ფრაზა, მე ვფიქრობ, რომ თქვენ შეიძლება ეძახით,

314
00:20:39,000 --> 00:20:45,000
3 ცალკე ჯერ ხაზები 58, 59, და 61.

315
00:20:45,000 --> 00:20:52,000
შეგიძლიათ ვინმეს ახსნას რა ზუსტად ეს ფრაზა არ?

316
00:20:52,000 --> 00:20:55,000
ეს წვდომის ხასიათი, როგორც თქვენ განაცხადა.

317
00:20:55,000 --> 00:20:59,000
ჰო [inaudible] პერსონაჟი სიტყვით,

318
00:20:59,000 --> 00:21:04,000
და ამიტომ რაოდენობის ასოები ჩანს, რადგან თქვენ მხოლოდ მოძრავი გასწვრივ

319
00:21:04,000 --> 00:21:06,000
სიტყვით კიდევ ვნახე წერილი,

320
00:21:06,000 --> 00:21:10,000
ასე რომ აპირებს ეფექტურად გამოტოვოთ ფართები და პერსონალის იგრძნობა.

321
00:21:10,000 --> 00:21:12,000
ჰო, ზუსტად.

322
00:21:12,000 --> 00:21:16,000
და შემდეგ კიდევ ვნახე სიტყვით ცარიელი უბრალოდ mod ასე რომ თქვენ გადაადგილდება გარშემო.

323
00:21:16,000 --> 00:21:18,000
სწორედ. სწორედ სრულყოფილი განმარტება.

324
00:21:18,000 --> 00:21:23,000
რა კევინ განაცხადა, რომ ჩვენ გვინდა ინდექსი შევიდა სიტყვით.

325
00:21:23,000 --> 00:21:28,000
ჩვენ გვინდა num_letters_seen ხასიათი, თუ გნებავთ,

326
00:21:28,000 --> 00:21:32,000
მაგრამ თუ num_letters_seen აღემატება სიგრძეზე სიტყვით,

327
00:21:32,000 --> 00:21:37,000
გზა მივიღებთ ისევ შესაბამისი დიაპაზონი არის ვიყენებთ mod ოპერატორი

328
00:21:37,000 --> 00:21:40,000
ეფექტურად საერთო გარშემო.

329
00:21:40,000 --> 00:21:43,000
მაგალითად, როგორც მოკლე, ჩვენი სიტყვით არის ბეკონი,

330
00:21:43,000 --> 00:21:46,000
და ეს 5 წერილებს ხანგრძლივი.

331
00:21:46,000 --> 00:21:50,000
მაგრამ ჩვენ ვნახეთ 6 შრიფტით ჩვენი ძირითადი ტექსტი ამ ეტაპზე

332
00:21:50,000 --> 00:21:52,000
და დაშიფრული 6.

333
00:21:52,000 --> 00:21:57,000
ჩვენ დასრულდება მდე წვდომის num_letters_seen,

334
00:21:57,000 --> 00:22:00,000
რომელიც 6, mod სიგრძეზე სიტყვით, 5,

335
00:22:00,000 --> 00:22:04,000
და ა.შ. ჩვენ კიდევ 1 და ა.შ. რაც ჩვენ გავაკეთებთ არის ჩვენ გამოგიგზავნით

336
00:22:04,000 --> 00:22:14,000
შედიხართ პირველ სიმბოლოს შიგნით ჩვენი სიტყვით იმ ეტაპზე.

337
00:22:14,000 --> 00:22:21,000
>> ყველა უფლება, ნებისმიერი შეკითხვა Vigenère

338
00:22:21,000 --> 00:22:26,000
სანამ ჩვენ გადასვლა?

339
00:22:26,000 --> 00:22:31,000
თქვენ ბიჭები შეგრძნება საკმაოდ კარგი ამის შესახებ?

340
00:22:31,000 --> 00:22:35,000
ზემოთ, დიდი.

341
00:22:35,000 --> 00:22:38,000
მე გვინდა დავრწმუნდეთ, რომ თქვენ ბიჭები იღებენ შანსს ვხედავ კოდი

342
00:22:38,000 --> 00:22:48,000
რომ ჩვენ ვფიქრობთ გამოიყურება კარგი და აქვს შანსი ვისწავლოთ მისგან.

343
00:22:48,000 --> 00:22:53,000
ეს იქნება ბოლო ჩვენ უნდა გამოყენებით ფართების დროისათვის,

344
00:22:53,000 --> 00:22:59,000
და ჩვენ ვაპირებთ გარდამავალი ახლა, და მე ვაპირებ წასვლა cs50.net/lectures

345
00:22:59,000 --> 00:23:06,000
ამიტომ ჩვენ შეგვიძლია გავაკეთოთ ცოტა Quiz მიმოხილვა.

346
00:23:06,000 --> 00:23:10,000
საუკეთესო საშუალებაა ვფიქრობ უნდა დაიწყოს აკეთებს Quiz მიმოხილვა

347
00:23:10,000 --> 00:23:15,000
არის მისვლა ამ ლექციები გვერდზე, cs50.net/lectures,

348
00:23:15,000 --> 00:23:20,000
და ქვეშ თითოეული კვირაში სასაქონლო, ისე, თუ გავითვალისწინებთ აქ კვირა 0,

349
00:23:20,000 --> 00:23:27,000
მე ვხედავ, რომ ჩვენ გვაქვს ჩამონათვალი თემები, რომ ჩვენ დაფარული კვირა 0.

350
00:23:27,000 --> 00:23:31,000
>> თუ რომელიმე ამ თემებზე ჩანს უცნობ თქვენ

351
00:23:31,000 --> 00:23:34,000
თქვენ აუცილებლად მინდა დაბრუნდეს და scour ლექცია შენიშვნები და შესაძლოა

352
00:23:34,000 --> 00:23:39,000
კი skim მეშვეობით ლექციების, უყუროთ მათ კვლავ თუ გინდათ

353
00:23:39,000 --> 00:23:44,000
მისაღებად შეგრძნებას რა ხდება თითოეულ ამ თემებზე.

354
00:23:44,000 --> 00:23:49,000
მინდა ვთქვა, დამატებით ამ წლის ერთ cool რესურსების გვაქვს

355
00:23:49,000 --> 00:23:55,000
არის ამ შორტები, რომ ჩვენ შევქმენით და, თუ გადავხედავთ კვირა 0,

356
00:23:55,000 --> 00:24:00,000
ჩვენ არ გვაქვს ყველა თემები დაფარული, მაგრამ ჩვენ მივიღეთ საკმაოდ რამდენიმესი,

357
00:24:00,000 --> 00:24:03,000
ზოგიერთი trickier პირობა, ასე თვალს ამ შორტები ერთხელ

358
00:24:03,000 --> 00:24:08,000
კარგ მისაღებად თქვენ მდე სიჩქარე.

359
00:24:08,000 --> 00:24:15,000
კერძოდ, მე ვაპირებ მა დანამატი ამისთვის 3 წლის ბოლოში, რადგან მე იმ.

360
00:24:15,000 --> 00:24:20,000
მაგრამ თუ თქვენ ბრძოლა ორობითი, ბიტი, hex, რომ მსგავსი საქმიანობები,

361
00:24:20,000 --> 00:24:22,000
ორობითი არის დიდი ადგილი დაიწყოს.

362
00:24:22,000 --> 00:24:25,000
ASCII არის კიდევ ერთი რომ კარგია სანახავად ძალიან.

363
00:24:25,000 --> 00:24:31,000
თქვენ შეგიძლიათ კიდევ უყუროთ ჩემთვის 1.5x სიჩქარე თუ მე ვაპირებ ძალიან ნელა თქვენთვის.

364
00:24:31,000 --> 00:24:35,000
რადგან მიმოხილვა, მოგერიდებათ გაგვაჩნია.

365
00:24:35,000 --> 00:24:40,000
>> უბრალოდ უნდა დაიწყოს ნამდვილად სწრაფად, ჩვენ ვაპირებთ გავლა რამდენიმე ამ ვიქტორინაში პრობლემები

366
00:24:40,000 --> 00:24:44,000
უბრალოდ სწრაფად churn მეშვეობით ამ.

367
00:24:44,000 --> 00:24:50,000
მაგალითად, მოდით შევხედოთ პრობლემას 16 რომ მაქვს უფლება აქ ფორუმში.

368
00:24:50,000 --> 00:24:54,000
გვაქვს ამ შემდეგ გაანგარიშება წელს ორობითი,

369
00:24:54,000 --> 00:24:56,000
და გვინდა ვაჩვენოთ ნებისმიერი სამუშაო.

370
00:24:56,000 --> 00:24:59,000
Okay, მე ვაპირებ, რათა გასროლა.

371
00:24:59,000 --> 00:25:01,000
თქვენ ბიჭები უნდა ერთად ქაღალდი,

372
00:25:01,000 --> 00:25:04,000
და ჩვენ ყველაფერს გავაკეთებთ ამ მართლაც სწრაფად.

373
00:25:04,000 --> 00:25:06,000
ჩვენ გვინდა, რომ შეასრულოს შემდეგი გაანგარიშება წელს ორობითი.

374
00:25:06,000 --> 00:25:16,000
მაქვს 00110010.

375
00:25:16,000 --> 00:25:27,000
და მე ვაპირებ დამატებას 00110010.

376
00:25:27,000 --> 00:25:30,000
იყიდება მათემატიკის გენიოსების შემდეგ გასწვრივ სახლში,

377
00:25:30,000 --> 00:25:35,000
ეს ეფექტურად გამრავლებით მიერ 2.

378
00:25:35,000 --> 00:25:37,000
დავიწყოთ.

379
00:25:37,000 --> 00:25:39,000
ჩვენ ვაპირებთ იმავე ამისა ალგორითმი, რასაც ჩვენ ვაკეთებთ

380
00:25:39,000 --> 00:25:43,000
როდესაც ჩვენ დაამატოთ ათობითი ნომრები ერთად.

381
00:25:43,000 --> 00:25:46,000
მართლაც ერთადერთი განსხვავება აქ არის ის, რომ ჩვენ loop უკან გარშემო

382
00:25:46,000 --> 00:25:51,000
ერთხელ ჩვენ გვყავს 1 + 1 ნაცვლად ერთხელ მივიღებთ დან 10.

383
00:25:51,000 --> 00:25:53,000
>> თუ ჩვენ დავიწყებთ, მარჯვენა მართლაც სწრაფად, რა პირველი ციფრი?

384
00:25:53,000 --> 00:25:55,000
[სტუდენტური] 0. >> [Nate ჰ] 0.

385
00:25:55,000 --> 00:25:58,000
დიდი, მეორე ციფრი?

386
00:25:58,000 --> 00:26:00,000
[სტუდენტური] 1.

387
00:26:00,000 --> 00:26:02,000
[Nate ჰ] ეს 1? 1 + 1 არის?

388
00:26:02,000 --> 00:26:04,000
[სტუდენტური] 10.

389
00:26:04,000 --> 00:26:08,000
[Nate ჰ] ზუსტად, მერე რა არის ციფრი, რომ ვწერ უფლება ქვეშ 2 პირობა დასძინა ერთად?

390
00:26:08,000 --> 00:26:11,000
[სტუდენტური] 1, 0, ან 0 და შემდეგ განახორციელოს 1.

391
00:26:11,000 --> 00:26:15,000
[Nate ჰ] 0 ახდენენ 1, ზუსტად.

392
00:26:15,000 --> 00:26:18,000
შემდეგი ერთი გოლი, ბასილ, თქვენ up.

393
00:26:18,000 --> 00:26:20,000
რა არის მესამე? >> [ბასილ] 1.

394
00:26:20,000 --> 00:26:23,000
[Nate ჰ] 1, სრულყოფილი. Kevin?

395
00:26:23,000 --> 00:26:27,000
[Kevin] 0. >> [Nate ჰ] 0, Charlotte?

396
00:26:27,000 --> 00:26:30,000
[Charlotte] 0. >> [Nate ჰ] ჰო, და რა გავაკეთო?

397
00:26:30,000 --> 00:26:32,000
[სტუდენტური] 1.

398
00:26:32,000 --> 00:26:34,000
[Nate ჰ] და რა ვქნათ? და მერე განახორციელოს 1.

399
00:26:34,000 --> 00:26:36,000
სრულყოფილი, Sahb? >> [Sahb] ახლა თქვენ გაქვთ 1.

400
00:26:36,000 --> 00:26:40,000
[Nate ჰ] და ნუ მე არაფერი აქ?

401
00:26:40,000 --> 00:26:43,000
[Sahb] მაშინ მომდევნო ერთი თქვენ გაქვთ 1 იმიტომ, რომ თქვენ განხორციელებული მეტი 1.

402
00:26:43,000 --> 00:26:49,000
[Nate ჰ] დიდი, ასე რომ აქ ჩვენ შეგვიძლია დავამთავროთ ეს up.

403
00:26:49,000 --> 00:26:51,000
ზემოთ.

404
00:26:51,000 --> 00:26:54,000
[სტუდენტური] არა 0 + 0 = 0?

405
00:26:54,000 --> 00:26:56,000
0 + 0 = 0.

406
00:26:56,000 --> 00:27:01,000
1 + 1, ისევე როგორც თქვენ თქვით, არის 10, ან 1, 0, საკმაოდ.

407
00:27:01,000 --> 00:27:07,000
10 არის misnomer რადგან ჩემთვის 10 ნიშნავს ნომერი 10,

408
00:27:07,000 --> 00:27:12,000
და ეს quirk, თუ როგორ ჩვენ წარმოადგენს, როცა ჩვენ წერილობით იგი.

409
00:27:12,000 --> 00:27:20,000
ჩვენ წარმოვადგენთ ნომერი 2 მიერ 1, 0, და ხმების 10 არის ოდნავ განსხვავებული.

410
00:27:20,000 --> 00:27:23,000
>> რა სახის ლამაზი შესახებ ორობითი არის ის, რომ იქ ნამდვილად არ არის, რომ ბევრი

411
00:27:23,000 --> 00:27:25,000
შემთხვევაში უნდა ვისწავლოთ.

412
00:27:25,000 --> 00:27:30,000
არსებობს 0 + 0 = 0, 0 + 1 = 1,

413
00:27:30,000 --> 00:27:34,000
1 + 1 არის 0, ხოლო შემდეგ განახორციელოს 1,

414
00:27:34,000 --> 00:27:37,000
და მაშინ დაინახავ, აქ მესამე სვეტის მარჯვენა

415
00:27:37,000 --> 00:27:40,000
ჩვენ გვქონდა ამ 1, 1, 1.

416
00:27:40,000 --> 00:27:43,000
და 1 + 1 + 1 არის 1,

417
00:27:43,000 --> 00:27:45,000
და თქვენ განახორციელოს სხვა 1.

418
00:27:45,000 --> 00:27:48,000
როდესაც თქვენ აკეთებთ ორობითი ამისა, საკმაოდ მარტივია.

419
00:27:48,000 --> 00:27:51,000
მინდა გავაკეთოთ წყვილი მეტი ასეთი რომ საღი აზრის შეამოწმოს საკუთარი თავი

420
00:27:51,000 --> 00:27:54,000
სანამ წავიდეს, რადგან ეს

421
00:27:54,000 --> 00:28:00,000
ალბათ ის, რასაც ჩვენ დავინახავთ on ვიქტორინა.

422
00:28:00,000 --> 00:28:03,000
ახლა მოდით ეს ერთი ისევე.

423
00:28:03,000 --> 00:28:06,000
მოდით პრობლემა 17.

424
00:28:06,000 --> 00:28:12,000
ჩვენ ვაპირებთ კონვერტირება შემდეგ ორობითი რიცხვის ათობითი.

425
00:28:12,000 --> 00:28:28,000
მაქვს 10100111001.

426
00:28:28,000 --> 00:28:33,000
მახსოვს ორობითი ვიდეო რომ მე

427
00:28:33,000 --> 00:28:36,000
მე ფეხით ისეირნა რამდენიმე მაგალითები, და მე გვიჩვენა, თუ როგორ

428
00:28:36,000 --> 00:28:41,000
ყველაფერი მუშაობს, როდესაც თქვენ აკეთებთ ამას ათობითი.

429
00:28:41,000 --> 00:28:45,000
როდესაც თქვენ მომუშავე ათობითში ვფიქრობ ჩვენ

430
00:28:45,000 --> 00:28:48,000
ამ ეტაპზე ჩვენი ცხოვრება ისე ფლობს, რომ

431
00:28:48,000 --> 00:28:53,000
ეს საკმაოდ ადვილი სიპრიალის მეტი მექანიკის როგორ რეალურად მუშაობს.

432
00:28:53,000 --> 00:28:59,000
>> მაგრამ ამისათვის სწრაფი recap, თუ მაქვს ნომერი 137

433
00:28:59,000 --> 00:29:06,000
ეს ნამდვილად ნიშნავს და ისევ, ეს ათობითში-

434
00:29:06,000 --> 00:29:19,000
ნომერი 137 წელს ათობითი იმას ნიშნავს, რომ მაქვს 1 x 100 + 3 x 10 + 7 x 1.

435
00:29:19,000 --> 00:29:22,000
ეს არის ყველა დარჩენის ეკრანზე.

436
00:29:22,000 --> 00:29:29,000
და შემდეგ თუ თქვენ შეხედეთ ამ ნომრებზე უფლება აქ,

437
00:29:29,000 --> 00:29:34,000
100, 10 და 1, ხედავთ, რომ ისინი პრაქტიკულად ყველა უფლებამოსილება 10.

438
00:29:34,000 --> 00:29:43,000
მაქვს 10 ², 10 ¹ და 10 to ნულოვანი.

439
00:29:43,000 --> 00:29:48,000
ჩვენ გვყავს ანალოგიური სახის რამ ორობითი,

440
00:29:48,000 --> 00:29:55,000
გარდა იმისა, რომ ჩვენი ბაზა, როგორც ჩვენ მას, არის 2 ნაცვლად 10.

441
00:29:55,000 --> 00:29:58,000
ეს 10s რომ დავწერე ქვემოთ აქ ბოლოში,

442
00:29:58,000 --> 00:30:02,000
ამ 10 ², 10 ¹, 10 დან ნულოვანი, 10 არის ჩვენი ბაზა,

443
00:30:02,000 --> 00:30:08,000
და მაჩვენებლებით, 0, 1, ან 2,

444
00:30:08,000 --> 00:30:14,000
იგულისხმება მიერ თანამდებობაზე ციფრი რიცხვი, რომ ჩვენ წერენ.

445
00:30:14,000 --> 00:30:21,000
1, თუ დავაკვირდებით, ეს 1 არის მე -2 პოზიცია.

446
00:30:21,000 --> 00:30:27,000
3 არის 1 პოზიცია და 7 არის 0th პოზიცია.

447
00:30:27,000 --> 00:30:35,000
ასე მივიღებთ სხვადასხვა ექსპონატები ქვემოთ ჩვენი ბაზების.

448
00:30:35,000 --> 00:30:40,000
>> შემდეგ ყველა ამ we'll-ფაქტობრივად, იცით, რა?

449
00:30:40,000 --> 00:30:43,000
ჩვენ ყველაფერს გავაკეთებთ, სადაც არც ჩემი გაუქმება ღილაკს წავიდეთ?

450
00:30:43,000 --> 00:30:45,000
არსებობს მიდის.

451
00:30:45,000 --> 00:30:47,000
მიყვარს ეს გაუქმება რამ.

452
00:30:47,000 --> 00:30:51,000
შემდეგ ამ ვფიქრობ ყოველ შემთხვევაში ჩემთვის

453
00:30:51,000 --> 00:30:54,000
დაწყების უმარტივეს გზას კონვერტაცია ორობითი რიცხვის

454
00:30:54,000 --> 00:30:57,000
ან თექვსმეტობითი ხმების სადაც ბაზა 16

455
00:30:57,000 --> 00:31:02,000
და არა 10 ან 2 არის წავიდეთ წინ და დაწეროთ გარეთ

456
00:31:02,000 --> 00:31:09,000
ბაზებისა და ექსპონატები ყველა ნომრები ჩემი ორობითი რიცხვის ზედა.

457
00:31:09,000 --> 00:31:14,000
თუ ჩვენ დავიწყებთ მარცხნიდან მარჯვნივ ისევ,

458
00:31:14,000 --> 00:31:17,000
რაც სახის counterintuitive,

459
00:31:17,000 --> 00:31:23,000
მე შეიცვალოს თავში შავი აქ, ჩვენ გვაქვს 2 დან 0th პოზიცია,

460
00:31:23,000 --> 00:31:27,000
და მაშინ ჩვენ გვყავს 2 ¹, 2 ²,

461
00:31:27,000 --> 00:31:33,000
და შემდეგ 2 დან 3, 2 დან 4, 2 დან 5, 6,

462
00:31:33,000 --> 00:31:39,000
7, 8, 9, და 10.

463
00:31:39,000 --> 00:31:41,000
ეს ციფრები მე წერილობითი out ყველა ექსპონატი.

464
00:31:41,000 --> 00:31:48,000
მე მხოლოდ წერდა ბაზების აქ პირველი 3 მხოლოდ სივრცეში.

465
00:31:48,000 --> 00:31:50,000
>> ამ ეტაპზე მე ვაპირებ წავიდეთ წინ და მე რეალურად აპირებს წაშალოს

466
00:31:50,000 --> 00:31:53,000
პერსონალის, რომ ჩვენ გააკეთა ათობითი, თუ ეს okay.

467
00:31:53,000 --> 00:31:57,000
თქვენ წასვლამდე რომ.

468
00:31:57,000 --> 00:32:05,000
იმ თქვენ თვალს ონლაინ დარწმუნებული ვარ შეძლებს გადახვევა ჩემთვის თუ მინდა.

469
00:32:05,000 --> 00:32:07,000
გადართვის თავში კალამი.

470
00:32:07,000 --> 00:32:12,000
ახლა, რა შეგვიძლია გავაკეთოთ-თუ ბიჭები არიან სრულიად მდე დაჩქარდეს თქვენს უფლებამოსილება 2,

471
00:32:12,000 --> 00:32:15,000
რომ სრულიად გრილი.

472
00:32:15,000 --> 00:32:18,000
ეს ხდება. მე მესმის.

473
00:32:18,000 --> 00:32:23,000
მე კიდევ ჰქონდა გასაუბრება, სადაც მითხრეს, რომ მე უნდა იცოდეს ყველა ძალაუფლება 2

474
00:32:23,000 --> 00:32:26,000
up მეშვეობით 2 დან 30.

475
00:32:26,000 --> 00:32:29,000
ეს არ იყო სამუშაო მე მივიღე.

476
00:32:29,000 --> 00:32:32,000
ყოველ შემთხვევაში, თქვენ ბიჭები შეიძლება წავიდეთ წინ და ნუ მათემატიკის აქ,

477
00:32:32,000 --> 00:32:35,000
მაგრამ ბინარული ეს ნამდვილად არ აქვს აზრი,

478
00:32:35,000 --> 00:32:38,000
და არც ის აზრი ერთად ათობითი ან თექვსმეტობითი ან,

479
00:32:38,000 --> 00:32:43,000
გავაკეთოთ მათემატიკის, თუ სად გაქვთ zeros.

480
00:32:43,000 --> 00:32:49,000
თქვენ ხედავთ, მაქვს 0 აქ, 0 აქ, 0 აქ, 0 აქ, 0 აქ, 0 აქ.

481
00:32:49,000 --> 00:32:52,000
რატომ შეიძლება ეს არ აქვს აზრი უნდა გააკეთოს რეალურ მათემატიკის

482
00:32:52,000 --> 00:32:56,000
გამოვთვალოთ შესაბამისი ძალა 2 რომ პოზიცია?

483
00:32:56,000 --> 00:32:59,000
სწორედ, ისევე როგორც Charlotte განაცხადა, ეს იქნება 0.

484
00:32:59,000 --> 00:33:05,000
შესაძლოა ასევე გადარჩენა თავის დროს, თუ გაანგარიშების უფლებამოსილება 2 არ არის თქვენი ძლიერი სარჩელი.

485
00:33:05,000 --> 00:33:10,000
ამ შემთხვევაში ჩვენ მხოლოდ უნდა გამოვთვალოთ ეს 2 რომ 0 არის-?

486
00:33:10,000 --> 00:33:12,000
[სტუდენტური] 1.

487
00:33:12,000 --> 00:33:14,000
[Nate ჰ] 1, 2 დან 3 რომელიც-?

488
00:33:14,000 --> 00:33:16,000
[სტუდენტური] 8. >> [Nate ჰ] 8.

489
00:33:16,000 --> 00:33:18,000
2 დან 4?

490
00:33:18,000 --> 00:33:21,000
[სტუდენტური] 2. მე უკაცრავად, 1.

491
00:33:21,000 --> 00:33:26,000
[Nate ჰ] 2 დან 4 არის 16, ზუსტად.

492
00:33:26,000 --> 00:33:28,000
2 დან 5, კევინ? >> 32.

493
00:33:28,000 --> 00:33:32,000
[Nate ჰ] 32, 2 რათა 8?

494
00:33:32,000 --> 00:33:38,000
[სტუდენტური] 32 x 8, 256.

495
00:33:38,000 --> 00:33:41,000
[Nate ჰ] Perfect.

496
00:33:41,000 --> 00:33:43,000
, 2 10?

497
00:33:43,000 --> 00:33:45,000
[სტუდენტური] 1024.

498
00:33:45,000 --> 00:33:49,000
[Nate ჰ] Yeah, 1024.

499
00:33:49,000 --> 00:33:57,000
>> ერთხელ ჩვენ მივიღეთ ამ ნომრებზე შეგვიძლია შევაჯამოთ მათ ყველა up.

500
00:33:57,000 --> 00:34:01,000
და ეს არის, სადაც ეს მართლაც მნიშვნელოვანია გავაკეთოთ რამოდენიმე რამ.

501
00:34:01,000 --> 00:34:07,000
ერთი წასვლა ნელი და შეამოწმოთ თქვენი მუშაობა.

502
00:34:07,000 --> 00:34:10,000
თქვენ შეგიძლიათ თქვათ, რომ არც 1 დასასრულს ეს რიცხვი,

503
00:34:10,000 --> 00:34:15,000
ამიტომ, უნდა მიიღოს კენტი ნომერი, როგორც ჩემი შედეგი,

504
00:34:15,000 --> 00:34:18,000
რადგან ყველა სხვა პირობა ვაპირებთ, რომ ვიყოთ კიდევ ნომრები

505
00:34:18,000 --> 00:34:21,000
იმის გათვალისწინებით, რომ ეს ორობითი რიცხვი.

506
00:34:21,000 --> 00:34:24,000
სხვა რამ უნდა გააკეთოთ, თუ თქვენ მიიღებთ ამ ეტაპზე on ტესტი

507
00:34:24,000 --> 00:34:27,000
და თქვენ წერილობითი იგი out ამ შორს

508
00:34:27,000 --> 00:34:30,000
და თქვენ გაშვებული out of time

509
00:34:30,000 --> 00:34:33,000
შეხედეთ პუნქტების რაოდენობა რომ ეს პრობლემა ღირს.

510
00:34:33,000 --> 00:34:40,000
ეს პრობლემა, როგორც ხედავთ თუ მე Flip თავში ჩემი ლეპტოპი მართლაც სწრაფად-

511
00:34:40,000 --> 00:34:44,000
ამ პრობლემის ღირს 2 ქულა, ასე რომ ეს არ არის ერთგვარი გარდა

512
00:34:44,000 --> 00:34:47,000
თქვენ უნდა გადის თუ თქვენ ნამდვილად დაპრესილი დრო.

513
00:34:47,000 --> 00:34:52,000
მაგრამ ჩვენ გადართოთ თავში iPad, და ჩვენ გავლა მართლაც სწრაფად.

514
00:34:52,000 --> 00:34:54,000
>> მომწონს აკეთებს მცირე რაოდენობით პირველ

515
00:34:54,000 --> 00:34:56,000
რადგან მე, რომ ადვილია.

516
00:34:56,000 --> 00:35:00,000
მომწონს 32 და 8 რადგან ისინი ერთად წავიდეთ საკმაოდ მარტივად, და მივიღებთ 50.

517
00:35:00,000 --> 00:35:03,000
16 და 1 იღებს 17.

518
00:35:03,000 --> 00:35:05,000
არსებობს მივიღებთ 57,

519
00:35:05,000 --> 00:35:14,000
და შემდეგ შეგვიძლია გავაკეთოთ დანარჩენი ამ, ასე რომ ჩვენ შეგვიძლია გავაკეთოთ 57, 156.

520
00:35:14,000 --> 00:35:16,000
Come on.

521
00:35:16,000 --> 00:35:19,000
მამაკაცს, ისევე, ვნახოთ.

522
00:35:19,000 --> 00:35:27,000
ჩვენ გვქონდა 57, 256, და 1024.

523
00:35:27,000 --> 00:35:31,000
ამ ეტაპზე, მე მირჩევნია უბრალოდ გავლა.

524
00:35:31,000 --> 00:35:35,000
მე არ ნახავ. მე ნათლად უნდა წაიკითხონ up ამ.

525
00:35:35,000 --> 00:35:40,000
7, 6, და 4, თქვენ მიიღებთ 17.

526
00:35:40,000 --> 00:35:42,000
1, 5, 5, 2, 13.

527
00:35:42,000 --> 00:35:45,000
მაშინ მივიღებთ 3 და შემდეგ მივიღებთ 1.

528
00:35:45,000 --> 00:35:52,000
1337.

529
00:35:52,000 --> 00:35:55,000
აღდგომის კვერცხი, ვინმე?

530
00:35:55,000 --> 00:35:59,000
ვინმე აღიარებს ამ ნომერი?

531
00:35:59,000 --> 00:36:02,000
კრის აღიარებს ნომერი. რას ნიშნავს, კრის?

532
00:36:02,000 --> 00:36:04,000
[კრის] Leet.

533
00:36:04,000 --> 00:36:11,000
Leet ასე რომ, თუ გადავხედავთ, ეს ჰგავს leet.

534
00:36:11,000 --> 00:36:15,000
Hacker პერსონალი. ფრთხილად, რომ მსგავსი საქმიანობები წლის შუალედური ან ინტელექტუალური, საკმაოდ.

535
00:36:15,000 --> 00:36:19,000
თუ ხედავ, რომ მსგავსი საქმიანობები და თქვენ გაინტერესებთ, "Huh"

536
00:36:19,000 --> 00:36:22,000
რომ შეიძლება რეალურად ნიშნავს რაღაცას.

537
00:36:22,000 --> 00:36:24,000
მე არ ვიცი. დავით მოსწონს ეს აყენებს სისტემაში

538
00:36:24,000 --> 00:36:26,000
ეს კარგი საშუალებაა საღი აზრის შეამოწმეთ იგი.

539
00:36:26,000 --> 00:36:30,000
Like okay, მე ვხედავ, რა ხდება.

540
00:36:30,000 --> 00:36:34,000
>> სწორედ კვირა 0/Week 1 პერსონალის.

541
00:36:34,000 --> 00:36:39,000
თუ ჩვენ გადართოთ უკან ჩვენი ლეპტოპი არის,

542
00:36:39,000 --> 00:36:46,000
zoom out, და რამოდენიმე სხვა რამ.

543
00:36:46,000 --> 00:36:50,000
არსებობს ASCII, რომელიც ჩვენ აკეთებდა ბევრი პრობლემას კომპლექტი.

544
00:36:50,000 --> 00:36:55,000
ეს ცნება კაპიტალური ა რა არის, რომ ნამდვილად?

545
00:36:55,000 --> 00:36:57,000
Knowing ეს ათობითი რიცხვი.

546
00:36:57,000 --> 00:37:00,000
65 არის რასაც ის mapped to in ASCII მაგიდა,

547
00:37:00,000 --> 00:37:03,000
და ეს ამიტომ, თუ როგორ კომპიუტერი წერს იგი,

548
00:37:03,000 --> 00:37:06,000
და ასე ჩვენ ვიღებთ გადაურჩა რეალურად წერა

549
00:37:06,000 --> 00:37:09,000
ხასიათი დედაქალაქში და ხასიათი მხედრულ

550
00:37:09,000 --> 00:37:14,000
ზოგიერთ ამ გადაწყვეტილებებს და პრობლემა კომპლექტი რომ თქვენ უკვე აკეთებს.

551
00:37:14,000 --> 00:37:16,000
რამდენიმე სხვა რამ.

552
00:37:16,000 --> 00:37:25,000
გვაქვს განცხადებებს, ლოგიკური გამოთქმები, პირობები, მარყუჟების, ცვლადები და თემა.

553
00:37:25,000 --> 00:37:29,000
>> იმ ყველა როგორც ჩანს აზრი ამისთვის დიდი ნაწილი?

554
00:37:29,000 --> 00:37:35,000
ზოგიერთი ამ ტერმინოლოგიის არის პატარა ხმაურიანი at ჯერ.

555
00:37:35,000 --> 00:37:46,000
მე მიყვარს ვფიქრობ განაცხადი როგორც საუკეთესო ნაწილი, რომ რაღაც მთავრდება მძიმით.

556
00:37:46,000 --> 00:37:51,000
განცხადებები როგორიცაა x = 7, რომელიც ითვალისწინებს ცვლადი,

557
00:37:51,000 --> 00:37:54,000
სავარაუდოდ მოუწოდა x = 7.

558
00:37:54,000 --> 00:38:01,000
სავარაუდოდ x ასევე ტიპის რომ შენახვა შეუძლია ნომერი 7,

559
00:38:01,000 --> 00:38:05,000
ამიტომ int ან შესაძლოა ათწილადი ან მოკლე ან char,

560
00:38:05,000 --> 00:38:07,000
მსგავსი რამ, რომ.

561
00:38:07,000 --> 00:38:12,000
ლოგიკური გამოხატვის იყენებს ამ ორმაგი შეადგენს

562
00:38:12,000 --> 00:38:17,000
და bang ტოლია ან არ უდრის, ნაკლები, მეტი,

563
00:38:17,000 --> 00:38:22,000
ნაკლებია ან ტოლია, ყველა რომ მსგავსი საქმიანობები.

564
00:38:22,000 --> 00:38:28,000
პირობები მაშინ არის თუ სხვაგან განცხადებებს.

565
00:38:28,000 --> 00:38:32,000
მინდა გვახსოვდეს, რომ შეგიძლიათ არ აქვს სხვაგან გარეშე შესაბამისი თუ.

566
00:38:32,000 --> 00:38:37,000
ანალოგიურად, შეგიძლიათ არ აქვს სხვას თუ გარეშე შესაბამისი თუ.

567
00:38:37,000 --> 00:38:40,000
მარყუჟების, გავიხსენოთ 3 სახის მარყუჟების ჩვენ hammering უყვარხარ

568
00:38:40,000 --> 00:38:43,000
უკანასკნელი რამდენიმე სექციები და პრობლემა კომპლექტი.

569
00:38:43,000 --> 00:38:46,000
გამოყენება არ ხოლო როდესაც თქვენ მიღების მომხმარებლის input,

570
00:38:46,000 --> 00:38:51,000
გამოყენებით, ხოლო მარყუჟების სანამ კონკრეტული მდგომარეობა მართალია,

571
00:38:51,000 --> 00:38:56,000
და შემდეგ გამოყენებით ისინი მარყუჟების თუ საჭიროა

572
00:38:56,000 --> 00:39:01,000
იცით რომელი iteration of loop თქვენ ამჟამად არის, თუ როგორ ვფიქრობ ამის შესახებ.

573
00:39:01,000 --> 00:39:07,000
ან თუ თქვენ აკეთებთ თითოეული პერსონაჟი სიმებიანი მინდა რაღაც,

574
00:39:07,000 --> 00:39:15,000
თითოეული ელემენტი მასივი მინდა რაღაც რომ ელემენტს.

575
00:39:15,000 --> 00:39:18,000
>> Threads და მოვლენები.

576
00:39:18,000 --> 00:39:21,000
ეს ჩვენ არ დაფარული ასე მკაფიოდ დო,

577
00:39:21,000 --> 00:39:23,000
მაგრამ გვახსოვდეს, ამ ნულიდან.

578
00:39:23,000 --> 00:39:26,000
ეს არის ცნება განსხვავებული სკრიპტები.

579
00:39:26,000 --> 00:39:32,000
ეს არის ასევე ამ ცნება მაუწყებლობს ღონისძიება.

580
00:39:32,000 --> 00:39:37,000
ზოგიერთი ადამიანი არ გამოიყენა მაუწყებლობა საკუთარ პროექტებს თავდაპირველად,

581
00:39:37,000 --> 00:39:40,000
რომელიც მთლიანად cool,

582
00:39:40,000 --> 00:39:46,000
მაგრამ ეს არის 2 სხვადასხვა გზები გატარება ამ უფრო დიდი საკითხი მოუწოდა concurrency,

583
00:39:46,000 --> 00:39:49,000
რომელიც როგორ იღებთ პროგრამების განხორციელება

584
00:39:49,000 --> 00:39:54,000
ან შეხედვით შეასრულოს ამავე დროს?

585
00:39:54,000 --> 00:39:59,000
სხვადასხვა ამოცანები გაშვებული ხოლო სხვა ამოცანებს ასევე გაშვებული.

586
00:39:59,000 --> 00:40:01,000
ეს არის, თუ როგორ თქვენი ოპერაციული სისტემა, როგორც ჩანს მუშაობა.

587
00:40:01,000 --> 00:40:04,000
ამიტომ, მიუხედავად იმისა, მაგალითად,

588
00:40:04,000 --> 00:40:10,000
მაქვს ჩემი ბრაუზერის გაშვებული, შემიძლია ასევე ჩართოთ Spotify და ითამაშოს სიმღერა.

589
00:40:10,000 --> 00:40:14,000
სწორედ მეტი კონცეპტუალური უნდა გავითვალისწინოთ.

590
00:40:14,000 --> 00:40:17,000
მინდა შევხედოთ თემა მოკლე

591
00:40:17,000 --> 00:40:21,000
თუ გსურთ შეიტყოთ უფრო მეტი რომ.

592
00:40:21,000 --> 00:40:26,000
>> ვნახოთ, მე მჯერა, შეიძლება ყოფილიყო

593
00:40:26,000 --> 00:40:31,000
პრობლემა ამ ერთ ამ.

594
00:40:31,000 --> 00:40:35,000
ისევ და ისევ, მე ვფიქრობ, თემა და თარიღები არ არის ის, რასაც ჩვენ დაფარავს in C

595
00:40:35,000 --> 00:40:41,000
მხოლოდ იმიტომ, რომ ის მნიშვნელოვნად უფრო რთული, ვიდრე Scratch.

596
00:40:41,000 --> 00:40:44,000
თქვენ არ უნდა ფიქრი მას იქ, მაგრამ ნამდვილად მესმის ცნებები,

597
00:40:44,000 --> 00:40:47,000
მესმის რა ხდება.

598
00:40:47,000 --> 00:40:52,000
სანამ ჩვენ გადასვლა, რაიმე შეკითხვა კვირა 0 მატერიალური?

599
00:40:52,000 --> 00:40:55,000
ყველას შეგრძნება საკმაოდ კარგი?

600
00:40:55,000 --> 00:41:03,000
მემორანდუმი ცვლადები და რა ცვლადი არის?

601
00:41:03,000 --> 00:41:08,000
>> მოძრავი. კვირა 1.

602
00:41:08,000 --> 00:41:12,000
რამდენიმე რამ აქ რომ არ იყო განსაკუთრებით დაფარული

603
00:41:12,000 --> 00:41:21,000
in ინტელექტუალური მიმოხილვა აუცილებლად და ასევე უფრო კონცეპტუალური რამ ფიქრი.

604
00:41:21,000 --> 00:41:30,000
პირველი არის ამ ცნება რა კოდებს, Compilers და ობიექტის კოდი.

605
00:41:30,000 --> 00:41:32,000
ვინმეს? ბასილი.

606
00:41:32,000 --> 00:41:37,000
არის ობიექტის კოდი-ვგულისხმობ კოდის არის ის, რაც თქვენ შევიდა clang,

607
00:41:37,000 --> 00:41:42,000
და ობიექტის კოდი არის რა clang აყენებს გარეთ ისე, რომ თქვენი კომპიუტერი არ აქვს უფლება წაიკითხოს პროგრამა.

608
00:41:42,000 --> 00:41:44,000
სწორედ.

609
00:41:44,000 --> 00:41:47,000
კოდის არის C კოდი, რომ თქვენ რეალურად აკრიფოთ up.

610
00:41:47,000 --> 00:41:50,000
ობიექტის კოდი არის ის, რაც თქვენ გავიდნენ clang.

611
00:41:50,000 --> 00:41:54,000
ეს 0S და 1s ამ ორობითი ფორმატის.

612
00:41:54,000 --> 00:41:59,000
მაშინ რა ხდება, როდესაც თქვენ გაქვთ bunch of ობიექტი ფაილი

613
00:41:59,000 --> 00:42:04,000
ამბობენ თქვენ შედგენა პროექტის ან პროგრამა რომელიც იყენებს მრავალი კოდის ფაილი

614
00:42:04,000 --> 00:42:09,000
რომელიც კონვენციის მოცემულია. გ ფაილის გაფართოება.

615
00:42:09,000 --> 00:42:13,000
ამიტომ ჩვენ გვაქვს caesar.c, vigenère.c.

616
00:42:13,000 --> 00:42:18,000
თუ თქვენ წერა Java პროგრამების თქვენ მივცეთ გაფართოება. Java.

617
00:42:18,000 --> 00:42:24,000
პითონის პროგრამების აქვს გაფართოება. Py ხშირად.

618
00:42:24,000 --> 00:42:26,000
>> მას შემდეგ რაც მრავალი. C ფაილი თქვენ კომპილაციის მათ.

619
00:42:26,000 --> 00:42:29,000
Clang SpitS ყველა ამ ორობითი უსარგებლო.

620
00:42:29,000 --> 00:42:33,000
მაშინ, რადგან თქვენ მხოლოდ მინდა 1 პროგრამის

621
00:42:33,000 --> 00:42:37,000
თქვენ გაქვთ linker ლინკები ყველა ამ ობიექტს ფაილი ერთად

622
00:42:37,000 --> 00:42:40,000
შევიდა 1 შესრულებად ფაილს.

623
00:42:40,000 --> 00:42:45,000
ეს არის ასევე რა ხდება მაშინ, როდესაც თქვენ იყენებთ CS50 ბიბლიოთეკა, მაგალითად.

624
00:42:45,000 --> 00:42:50,000
CS50 ბიბლიოთეკა ორივე რომ. თ header ფაილი

625
00:42:50,000 --> 00:42:53,000
რომ წაიკითხავთ, რომ # includecs50.h.

626
00:42:53,000 --> 00:42:58,000
და მერე ასევე სპეციალური ორობითი ბიბლიოთეკა ფაილი

627
00:42:58,000 --> 00:43:02,000
რომ უკვე შედგენილი, რომ არის 0S და 1s,

628
00:43:02,000 --> 00:43:08,000
და რომ-L დროშა ასე რომ, თუ ჩვენ დავუბრუნდებით ჩვენი სივრცეები და გადავხედავთ ნამდვილად სწრაფად

629
00:43:08,000 --> 00:43:11,000
რა ხდება აქ შევხედოთ ჩვენი clang ბრძანება,

630
00:43:11,000 --> 00:43:15,000
რა გვაქვს ეს არის ჩვენი კოდის ფაილი უფლება აქ.

631
00:43:15,000 --> 00:43:18,000
ეს არის bunch of შემდგენელი დროშები.

632
00:43:18,000 --> 00:43:22,000
ხოლო შემდეგ ბოლომდე, ამ-L დროშები ბმულზე

633
00:43:22,000 --> 00:43:30,000
ფაქტობრივი ორობითი ფაილი ამ 2 ბიბლიოთეკა, CS50 ბიბლიოთეკა და შემდეგ მათემატიკის ბიბლიოთეკაში.

634
00:43:30,000 --> 00:43:35,000
>> გააზრება თითოეული სახის ფაილები 'მიზნით

635
00:43:35,000 --> 00:43:38,000
ასევე შეადგინა პროცესში არის რაღაც თქვენ გსურთ შეძლებს

636
00:43:38,000 --> 00:43:43,000
მივცეთ მინიმუმ მაღალ დონეზე მიმოხილვა.

637
00:43:43,000 --> 00:43:46,000
კოდის მოდის შემოსული ობიექტის კოდი გამოდის.

638
00:43:46,000 --> 00:43:53,000
ობიექტის კოდი ფაილები დაუკავშირონ ერთად, და თქვენ ლამაზი, შესრულებადი ფაილი.

639
00:43:53,000 --> 00:43:55,000
ზემოთ.

640
00:43:55,000 --> 00:43:58,000
ეს არის ასევე სადაც შეგიძლიათ მიიღოთ შეცდომები დროს მრავალჯერადი რაოდენობა

641
00:43:58,000 --> 00:44:00,000
ასევე შეადგინა პროცესში.

642
00:44:00,000 --> 00:44:04,000
ეს არის სადაც, მაგალითად, თუ თქვენ აიღეთ ამ დამაკავშირებელ დროშა,

643
00:44:04,000 --> 00:44:10,000
CS50 დროშა და გამომრჩეს ეს სივრცეები ან როდესაც თქვენ გაშვებული თქვენი კოდი,

644
00:44:10,000 --> 00:44:13,000
ეს არის, სადაც თქვენ მიიღებთ შეცდომა აკავშირებს ფაზაში,

645
00:44:13,000 --> 00:44:18,000
და linker იტყვის, "Hey, თქვენ მოუწოდა ფუნქცია GetString

646
00:44:18,000 --> 00:44:20,000
რომ წელს CS50 ბიბლიოთეკა. "

647
00:44:20,000 --> 00:44:25,000
"თქვენ მითხრა იყო CS50 ბიბლიოთეკაში და ვერ ვპოულობ კოდი იგი."

648
00:44:25,000 --> 00:44:28,000
სწორედ სადაც თქვენ უნდა დაუკავშირონ ის, და ეს ცალკე

649
00:44:28,000 --> 00:44:33,000
საწყისი შემდგენელი შეცდომა რადგან შემდგენელი ეძებს სინტაქსი და რომ მსგავსი საქმიანობები.

650
00:44:33,000 --> 00:44:38,000
კარგია, თუ რა ხდება, როდესაც.

651
00:44:38,000 --> 00:44:42,000
>> სხვა რამ იცოდეთ.

652
00:44:42,000 --> 00:44:49,000
მე ვიტყოდი, თქვენ აუცილებლად გვინდა შევხედოთ მოკლე on typecasting კეთდება იორდანიის

653
00:44:49,000 --> 00:44:55,000
გვესმოდეს რა ints ქვეშ hood,

654
00:44:55,000 --> 00:44:58,000
რა სიმბოლო ქვეშ hood.

655
00:44:58,000 --> 00:45:02,000
როდესაც ვსაუბრობთ ASCII და ჩვენ რეალურად შევხედოთ ASCII მაგიდა,

656
00:45:02,000 --> 00:45:07,000
რა რომ აკეთებს გვაძლევს ქვეშ hood ნახვა

657
00:45:07,000 --> 00:45:13,000
როგორ კომპიუტერი რეალურად წარმოადგენს კაპიტალის და ციფრი 7

658
00:45:13,000 --> 00:45:17,000
და მძიმით და კითხვის ნიშნის.

659
00:45:17,000 --> 00:45:20,000
კომპიუტერი ასევე აქვს სპეციალური გზები წარმოადგენს

660
00:45:20,000 --> 00:45:23,000
ნომერი 7 როგორც მთელი რიცხვი.

661
00:45:23,000 --> 00:45:27,000
მას აქვს სპეციალური გზა წარმოადგენს რაოდენობა 7 როგორც მცურავი პუნქტიანი ნომერი,

662
00:45:27,000 --> 00:45:29,000
და იმ ძალიან განსხვავებული.

663
00:45:29,000 --> 00:45:32,000
Typecasting ასე გითხრათ კომპიუტერი "Hey, მინდა გადაიყვანოთ

664
00:45:32,000 --> 00:45:37,000
ერთი წარმომადგენლობის კიდევ ერთი წარმომადგენლობა. "

665
00:45:37,000 --> 00:45:40,000
რატომ არ გვაქვს შევხედოთ, რომ.

666
00:45:40,000 --> 00:45:44,000
>> მინდა ასევე შევხედოთ მოკლე on ბიბლიოთეკების და მოკლე on compilers.

667
00:45:44,000 --> 00:45:47,000
იმ საუბარი პროცესში შედგენაში,

668
00:45:47,000 --> 00:45:53,000
რა ბიბლიოთეკა, და წავიდეთ მეტი ზოგიერთ ამ შეკითხვაზე, რომ თქვენ შეიძლება სთხოვა.

669
00:45:53,000 --> 00:45:55,000
კითხვები on კვირა 1 მატერიალური?

670
00:45:55,000 --> 00:46:03,000
არსებობს რაიმე თემა აქ რომ ჩანს daunting გსურთ დაფარავს?

671
00:46:03,000 --> 00:46:07,000
ვცდილობ აფეთქება მეშვეობით ყველაზე ამ ადრე თემები ისე, რომ ჩვენ შეგვიძლია მისაღებად

672
00:46:07,000 --> 00:46:13,000
პოინტერები და ნუ ცოტა უკან.

673
00:46:13,000 --> 00:46:15,000
ფიქრები?

674
00:46:15,000 --> 00:46:19,000
არაფერი დაფარავს?

675
00:46:19,000 --> 00:46:21,000
ახლა ზოგიერთი შოკოლადის იქნებ?

676
00:46:21,000 --> 00:46:23,000
თქვენ ბიჭები მუშაობენ მეშვეობით.

677
00:46:23,000 --> 00:46:26,000
მე ვაპირებ შენარჩუნება sipping ჩემს ყავა.

678
00:46:26,000 --> 00:46:31,000
კვირა 2.

679
00:46:31,000 --> 00:46:34,000
კარგი ზარი, კარგი ზარი.

680
00:46:34,000 --> 00:46:38,000
In კვირა 2 ჩვენ ვისაუბრეთ ცოტა მეტი ფუნქციები.

681
00:46:38,000 --> 00:46:43,000
>> პირველ რამდენიმე პრობლემა კომპლექტი ჩვენ არ ნამდვილად წერენ ნებისმიერი ფუნქციების ყველა

682
00:46:43,000 --> 00:46:45,000
გარდა რომელიც ფუნქციას?

683
00:46:45,000 --> 00:46:47,000
[სტუდენტური] მთავარი. >> მთავარი, ზუსტად.

684
00:46:47,000 --> 00:46:51,000
ასე რომ, ჩვენ ვხედავთ სხვადასხვა კოსტიუმები, რომ ძირითადი ატარებს.

685
00:46:51,000 --> 00:46:54,000
არსებობს ერთი, რომელიც მას სჭირდება არანაირი არგუმენტი,

686
00:46:54,000 --> 00:46:58,000
და ჩვენ უბრალოდ, ვამბობთ ბათილად შორის ფრჩხილებში,

687
00:46:58,000 --> 00:47:01,000
და შემდეგ იქ სხვა, სადაც ჩვენ გვინდა, რომ მიიღოს ბრძანება ხაზი არგუმენტები,

688
00:47:01,000 --> 00:47:08,000
და როგორც ჩვენ ვნახეთ, რომ სადაც თქვენ int argc და სიმებიანი argv მასივი

689
00:47:08,000 --> 00:47:13,000
ან არის, რომ ჩვენ ფაქტობრივად დაუცველი string to be char *, რომ ეს არის

690
00:47:13,000 --> 00:47:20,000
ჩვენ ვაპირებთ დავიწყოთ წერა, როგორც char * argv და შემდეგ ფრჩხილებში.

691
00:47:20,000 --> 00:47:22,000
პრობლემების Set 3, თქვენ ბიჭები დაინახა bunch of ფუნქციები,

692
00:47:22,000 --> 00:47:27,000
და თქვენ განხორციელებული bunch of ფუნქციები, გავამახვილო, ეძებოთ, scramble.

693
00:47:27,000 --> 00:47:31,000
პროტოტიპები იყო ყველა წერილობითი არსებობს თქვენთვის.

694
00:47:31,000 --> 00:47:33,000
>> რა მინდოდა ლაპარაკი აქ ფუნქციებს მართლაც სწრაფად

695
00:47:33,000 --> 00:47:38,000
ის არის, რომ არსებობს 3 ნაწილები მათ როდესაც ვწერთ ფუნქციას.

696
00:47:38,000 --> 00:47:43,000
თქვენ უნდა მიუთითოთ დაბრუნების ტიპის ფუნქცია.

697
00:47:43,000 --> 00:47:46,000
თქვენ უნდა მიუთითოთ სახელი ფუნქცია, და შემდეგ თქვენ უნდა მიუთითოთ

698
00:47:46,000 --> 00:47:51,000
არგუმენტი სიაში ან პარამეტრის სია.

699
00:47:51,000 --> 00:47:57,000
მაგალითად, მე რომ დაწერა ფუნქცია შეაჯამებს bunch of რიცხვებით

700
00:47:57,000 --> 00:48:03,000
და შემდეგ დაბრუნდება ჩემთან თანხა რა იქნება ჩემი დაბრუნების ტიპის

701
00:48:03,000 --> 00:48:06,000
თუ მინდოდა მთლიანობაში რიცხვებით და შემდეგ დაბრუნდნენ თანხა?

702
00:48:06,000 --> 00:48:12,000
მაშინ სახელით ფუნქციონირებს.

703
00:48:12,000 --> 00:48:27,000
თუ მე წავიდეთ წინ და ჩაიწეროს, მწვანე, ეს ნაწილი დაბრუნების ტიპის.

704
00:48:27,000 --> 00:48:34,000
ეს ნაწილი სახელი.

705
00:48:34,000 --> 00:48:40,000
ხოლო შემდეგ შორის ფრჩხილებში

706
00:48:40,000 --> 00:48:46,000
სადაც მე ვაძლევ არგუმენტები,

707
00:48:46,000 --> 00:48:56,000
ხშირად განუხრელად როგორც args, ხშირად წოდებული params for პარამეტრებს.

708
00:48:56,000 --> 00:49:00,000
და თუ თქვენ გაქვთ ერთი, თქვენ უბრალოდ მიუთითოთ ერთი.

709
00:49:00,000 --> 00:49:06,000
თუ თქვენ გაქვთ მრავალჯერადი თქვენ გამოყოფთ ყოველი ერთი მძიმით.

710
00:49:06,000 --> 00:49:13,000
და თითოეული არგუმენტი თქვენ მისცეს მას 2, რასაც ახლა-Kevin?

711
00:49:13,000 --> 00:49:18,000
[Kevin] თქვენ უნდა მისცეს პირობა და შემდეგ სახელი.

712
00:49:18,000 --> 00:49:21,000
და მერე სახელი და გვარი არის სახელი, რომ თქვენ აპირებთ მის გამოყენებას

713
00:49:21,000 --> 00:49:25,000
მიმართოს, რომ არგუმენტი ფარგლებში თანხა ფუნქცია,

714
00:49:25,000 --> 00:49:27,000
ფარგლებში ფუნქცია, რომ თქვენ გაკეთებული წერილობით.

715
00:49:27,000 --> 00:49:32,000
>> თქვენ არ უნდა, მაგალითად, თუ მე ვაპირებ შეაჯამებს,

716
00:49:32,000 --> 00:49:41,000
ამბობენ, მასივი რიცხვებით-we'll do int array,

717
00:49:41,000 --> 00:49:46,000
და მე მივცემ თავს ზოგიერთი Curly braces იქ-

718
00:49:46,000 --> 00:49:51,000
მაშინ როდესაც მე გაივლის მასივი თანხის ფუნქცია

719
00:49:51,000 --> 00:49:55,000
მე მსგავ პირველ პოზიციაზე არგუმენტი სიაში.

720
00:49:55,000 --> 00:49:59,000
მაგრამ array რომ მე კორიდორი არ უნდა ჰქონდეს სახელი arr.

721
00:49:59,000 --> 00:50:07,000
Arr იქნება როგორ ეხება ეს არგუმენტი ფარგლებში ორგანოს ფუნქცია.

722
00:50:07,000 --> 00:50:10,000
სხვა საქმეა, რომ ჩვენ გვჭირდება გაითვალისწინოს,

723
00:50:10,000 --> 00:50:14,000
და ეს არის ოდნავ განსხვავებული ფუნქციები, მაგრამ მე ვფიქრობ, რომ მნიშვნელოვანი,

724
00:50:14,000 --> 00:50:20,000
ის არის, რომ C როდესაც მე წერილობით ფუნქცია მოსწონს

725
00:50:20,000 --> 00:50:29,000
როგორ გავიგო რამდენი ელემენტია ამ მასივი?

726
00:50:29,000 --> 00:50:31,000
ეს არის გარკვეულწილად of შეასრულა კითხვაზე.

727
00:50:31,000 --> 00:50:35,000
ჩვენ ვისაუბრეთ ამ ცოტა გასულ კვირას მონაკვეთზე.

728
00:50:35,000 --> 00:50:40,000
როგორ გავიგო რაოდენობის ელემენტების შიგნით მასივი დო?

729
00:50:40,000 --> 00:50:44,000
არის გზა?

730
00:50:44,000 --> 00:50:49,000
>> თურმე არ გზა ვიცი.

731
00:50:49,000 --> 00:50:52,000
თქვენ უნდა გაიაროს ეს ცალკე.

732
00:50:52,000 --> 00:50:55,000
არსებობს შეასრულა, რომ შეგიძლიათ გააკეთოთ

733
00:50:55,000 --> 00:51:00,000
თუ თქვენ ამავე ფუნქციას, რომელშიც მასივი გამოცხადდა,

734
00:51:00,000 --> 00:51:04,000
და თქვენ მუშაობის დასტის მასივი.

735
00:51:04,000 --> 00:51:06,000
მაგრამ რომ მუშაობს მხოლოდ იმ შემთხვევაში, თუ თქვენ იგივე ფუნქცია.

736
00:51:06,000 --> 00:51:09,000
ერთხელ თქვენ გაივლის მასივი სხვა ფუნქცია ან თუ თქვენ განაცხადა მასივი

737
00:51:09,000 --> 00:51:12,000
და თქვენ დააყენა, რომ მასივი შესახებ ბევრი, თქვენ გამოყენებული malloc

738
00:51:12,000 --> 00:51:15,000
 და რომ მსგავსი საქმიანობები, მაშინ ყველა ფსონი off.

739
00:51:15,000 --> 00:51:18,000
მაშინ თქვენ ნამდვილად უნდა გაიარონ გარშემო

740
00:51:18,000 --> 00:51:21,000
სპეციალური არგუმენტი ან სხვა პარამეტრების

741
00:51:21,000 --> 00:51:23,000
გეუბნებოდით რამდენად დიდი მასივი არის.

742
00:51:23,000 --> 00:51:28,000
ამ შემთხვევაში, მე მინდა გინდათ გამოიყენოთ მძიმით-I'm sorry, ის აპირებს off ეკრანზე აქ-

743
00:51:28,000 --> 00:51:32,000
და მინდა გაივლის სხვა არგუმენტი

744
00:51:32,000 --> 00:51:40,000
 და ეძახით int len ​​ამისთვის სიგრძე.

745
00:51:40,000 --> 00:51:44,000
>> ერთი რამ, რომ შეიძლება ამუშავება on ვიქტორინა

746
00:51:44,000 --> 00:51:49,000
ითხოვს ჩემზე ან შესრულების კონკრეტული ფუნქცია მოუწოდა რაღაც.

747
00:51:49,000 --> 00:51:54,000
თუ ჩვენ არ მოგცემთ პროტოტიპი, ამიტომ ამ მთელი რამ აქ,

748
00:51:54,000 --> 00:51:58,000
ეს მთელი სასადილო ეწოდება ფუნქციის დეკლარაციის ან ფუნქციის პროტოტიპი,

749
00:51:58,000 --> 00:52:01,000
ეს არის ერთ ერთი პირველი რამ, რომ თქვენ გსურთ ფრჩხილის ქვემოთ თუ ეს არ აძლევენ

750
00:52:01,000 --> 00:52:03,000
თქვენ დაუყოვნებლივ on ვიქტორინა.

751
00:52:03,000 --> 00:52:06,000
სხვა ხრიკი მე გავიგე ის არის, რომ

752
00:52:06,000 --> 00:52:11,000
ამბობენ ვაკეთებთ მოგცემთ პროტოტიპი for ფუნქცია და ვამბობთ, "ეი, თქვენ მოხვდით დაწერა."

753
00:52:11,000 --> 00:52:16,000
Inside Curly braces რომ თქვენ შესახებ Quiz

754
00:52:16,000 --> 00:52:20,000
თუ თქვენ შეამჩნევთ, რომ არსებობს დაბრუნების ტიპი და თქვენ შეამჩნევთ, რომ დაბრუნების ტიპის

755
00:52:20,000 --> 00:52:25,000
არის რაღაც გარდა ბათილად, რაც იმას ნიშნავს, რომ ფუნქცია არ დააბრუნებს არაფერი,

756
00:52:25,000 --> 00:52:28,000
მაშინ ერთი რამ თქვენ აუცილებლად ჩვენ უნდა დაწეროს

757
00:52:28,000 --> 00:52:33,000
გარკვეული დაბრუნების განცხადება ძალიან ბოლომდე ფუნქცია.

758
00:52:33,000 --> 00:52:40,000
დაბრუნება, და ამ შემთხვევაში, ჩვენ დააყენა ცარიელი რადგან ჩვენ გვინდა შეავსოთ ცარიელი.

759
00:52:40,000 --> 00:52:44,000
მაგრამ ეს იღებს თქვენ მხედველობაში სწორი გზა, თუ როგორ ვარ მე აპირებს მივუდგეთ ამ პრობლემას?

760
00:52:44,000 --> 00:52:49,000
და ეს შეახსენებს თქვენ აპირებთ უნდა დაბრუნდეს ღირებულება

761
00:52:49,000 --> 00:52:51,000
to Caller ფუნქციის.

762
00:52:51,000 --> 00:52:54,000
>> Yeah. >> [სტუდენტური] არა სტილის ვრცელდება როდესაც ჩვენ წერილობით კოდი ვიქტორინა?

763
00:52:54,000 --> 00:52:58,000
როგორიცაა წანაცვლება და რომ მსგავსი საქმიანობები? >> [სტუდენტური] Yeah.

764
00:52:58,000 --> 00:53:00,000
არა, არა როგორც ბევრი.

765
00:53:00,000 --> 00:53:09,000
ვფიქრობ ბევრი-ეს არის რაღაც ჩვენ გაერკვია on ვიქტორინა on დღეს,

766
00:53:09,000 --> 00:53:15,000
მაგრამ, როგორც წესი, შემაშფოთებელია შესახებ # მოიცავს და რომ მსგავსი საქმიანობები, ეს სახის გარეთ.

767
00:53:15,000 --> 00:53:17,000
[სტუდენტური] არის საჭირო კომენტარი თქვენი ხელნაწერი კოდი?

768
00:53:17,000 --> 00:53:19,000
გჭირდებათ, რათა კომენტარი თქვენი ხელნაწერი კოდი?

769
00:53:19,000 --> 00:53:24,000
კომენტირებისას ყოველთვის კარგია, თუ თქვენ აწუხებს ნაწილობრივი საკრედიტო

770
00:53:24,000 --> 00:53:29,000
ან გსურთ დაუკავშირდეს თქვენი განზრახვა კლასის მოსწავლე.

771
00:53:29,000 --> 00:53:33,000
მაგრამ მე, კიდევ ერთხელ, იქნება განვმარტო on ვიქტორინა თავად და ინტელექტუალური დღეს,

772
00:53:33,000 --> 00:53:39,000
მაგრამ მე არ მჯერა, რომ თქვენ უნდა კომენტარის დაწერა, არ.

773
00:53:39,000 --> 00:53:42,000
როგორც წესი არა, მაგრამ ეს აუცილებლად სახის რამ, სადაც

774
00:53:42,000 --> 00:53:45,000
შეგიძლიათ თქვენი განზრახვა, როგორიცაა "Hey, ეს არის სადაც მე ვაპირებ მასთან."

775
00:53:45,000 --> 00:53:49,000
და ზოგჯერ, რაც დაგეხმარებათ ნაწილობრივი საკრედიტო.

776
00:53:49,000 --> 00:53:51,000
ზემოთ.

777
00:53:51,000 --> 00:53:53,000
>> ბასილი.

778
00:53:53,000 --> 00:53:56,000
[ბასილ] რა სხვაობაა გამოცხადების, ვთქვათ, int lang

779
00:53:56,000 --> 00:54:03,000
წელს არგუმენტები ან პარამეტრების წინააღმდეგ გამოცხადების ცვლადი ფარგლებში ფუნქცია?

780
00:54:03,000 --> 00:54:05,000
Wow, ყავა ჩამოიწია windpipe.

781
00:54:05,000 --> 00:54:07,000
[ბასილ] მსგავსად, რომელიც რამ გვინდა დასვა არგუმენტები.

782
00:54:07,000 --> 00:54:09,000
ჰო, დიდი კითხვა.

783
00:54:09,000 --> 00:54:11,000
როგორ აირჩიოს რა რამ გსურთ დასვა არგუმენტები

784
00:54:11,000 --> 00:54:17,000
წინააღმდეგ რა რამ, რაც უნდა გავაკეთოთ შიგნით ფუნქცია?

785
00:54:17,000 --> 00:54:24,000
ამ შემთხვევაში ჩვენ შედის ორივე როგორც არგუმენტები

786
00:54:24,000 --> 00:54:29,000
რადგან ისინი რაღაც რომ ვინც აპირებს გამოიყენოს თანხა ფუნქცია

787
00:54:29,000 --> 00:54:32,000
სჭირდება დაზუსტება იმ რამ.

788
00:54:32,000 --> 00:54:35,000
>> თანხა ფუნქცია, როგორც ჩვენ ვისაუბრეთ, აქვს არანაირად არ იცის

789
00:54:35,000 --> 00:54:40,000
რამდენად დიდი მასივი არის იგი იღებს მისი Caller ან ვინც იყენებს თანხა ფუნქცია.

790
00:54:40,000 --> 00:54:44,000
მას არანაირად არ იცის რამდენად დიდი რომ მასივი არის.

791
00:54:44,000 --> 00:54:48,000
მიზეზი ჩვენ გაივლის ამ სიგრძე უფლება აქ როგორც არგუმენტი

792
00:54:48,000 --> 00:54:51,000
ეს იმიტომ, რომ რაღაც რომ ჩვენ ძირითადად ვეუბნებოდი Caller ფუნქციის,

793
00:54:51,000 --> 00:54:55,000
ვინც აპირებს გამოიყენოს თანხა ფუნქცია, "Hey, არა მხოლოდ გაქვთ მოგვცეს მასივი

794
00:54:55,000 --> 00:54:59,000
საქართველოს ints, თქვენ ასევე უნდა გვითხრან რამდენად დიდი მასივი, რომ თქვენ მოცემულია ჩვენთვის. "

795
00:54:59,000 --> 00:55:03,000
[ბასილ] ის იქნება ორივე იყოს command line არგუმენტები?

796
00:55:03,000 --> 00:55:06,000
არა, ეს არის ფაქტობრივი არგუმენტები, რომ თქვენ გაივლის, რათა ფუნქცია.

797
00:55:06,000 --> 00:55:10,000
>> ნება მომეცით გავაკეთოთ ახალი გვერდი აქ.

798
00:55:10,000 --> 00:55:13,000
[ბასილ] მსგავსად სახელი იქნებოდა გაივლის-

799
00:55:13,000 --> 00:55:24,000
[Nate ჰ] თუ მაქვს int ძირითადი (void),

800
00:55:24,000 --> 00:55:27,000
და მე ვაპირებ დააყენა ჩემი დაბრუნების 0 ქვევით აქ ბოლოში,

801
00:55:27,000 --> 00:55:31,000
და ვთქვათ მინდა მოვუწოდო თანხა ფუნქცია.

802
00:55:31,000 --> 00:55:42,000
მინდა ვთქვა, int x = თანხა ();

803
00:55:42,000 --> 00:55:46,000
იმისათვის, რომ გამოიყენოთ თანხა ფუნქცია უნდა გაიაროს ორივე მასივი რომ მინდა შეაჯამებს

804
00:55:46,000 --> 00:55:51,000
და სიგრძით მასივი, ასე რომ ეს არის სადაც

805
00:55:51,000 --> 00:55:54,000
თუ, რა თქმა მქონდა მასივი ints,

806
00:55:54,000 --> 00:56:12,000
ვთქვა ჰქონდა int numbaz [] = 1, 2, 3,

807
00:56:12,000 --> 00:56:16,000
სახის გამოყენების რომ კალენდარი up სინტაქსის უფლება არსებობს,

808
00:56:16,000 --> 00:56:21,000
მაშინ რა იქნებოდა ეს თანხა მე სურს კორიდორი

809
00:56:21,000 --> 00:56:27,000
ორივე numbaz და ნომერი 3

810
00:56:27,000 --> 00:56:30,000
ვუთხრა თანხა ფუნქცია "Okay, აქ მასივი მინდა თანხა."

811
00:56:30,000 --> 00:56:34,000
"აქ თავისი ზომა."

812
00:56:34,000 --> 00:56:39,000
ამჯამად რომ აზრი? ამჯამად რომ უპასუხოს თქვენს კითხვაზე?

813
00:56:39,000 --> 00:56:42,000
>> ბევრი თვალსაზრისით ეს იმას პარალელურად იმას თუ რას ვაკეთებთ ძირითადი

814
00:56:42,000 --> 00:56:44,000
როდესაც გვაქვს ბრძანება ხაზი არგუმენტები.

815
00:56:44,000 --> 00:56:47,000
პროგრამა მოსწონს კეისრის კოდი, მაგალითად, რომ საჭიროა

816
00:56:47,000 --> 00:56:53,000
ბრძანება ხაზი არგუმენტები არ იქნება ვერაფერს ვერ გააკეთებს.

817
00:56:53,000 --> 00:56:57,000
ეს არ ვიცი როგორ გაშიფრავს თუ არ ვუთხრა ის, თუ რა გასაღები გამოიყენოს

818
00:56:57,000 --> 00:57:03,000
ან თუ არ ვუთხრა ის, თუ რა string თქვენ სურდა დაშიფვრა.

819
00:57:03,000 --> 00:57:08,000
რითაც ამისთვის შეყვანის, ეს არის სადაც ჩვენ მივიღეთ 2 სხვადასხვა მექანიზმების

820
00:57:08,000 --> 00:57:14,000
აღების შეყვანის in საწყისი მომხმარებელი, აღების ინფორმაციის საწყისი მომხმარებელს.

821
00:57:14,000 --> 00:57:19,000
პრობლემის უცნობია 1 დავინახეთ ამ GetInt, GetString, GetFloat გზა

822
00:57:19,000 --> 00:57:26,000
საქართველოს რითაც ამისთვის შეყვანის და რომ ე.წ. გამოყენებით სტანდარტული input stream.

823
00:57:26,000 --> 00:57:28,000
ეს ოდნავ განსხვავებული.

824
00:57:28,000 --> 00:57:31,000
ეს რაღაც, რაც შეგიძლიათ გააკეთოთ, ერთ დროს ნაცვლად

825
00:57:31,000 --> 00:57:35,000
როდესაც თქვენ იძახებთ პროგრამა, როდის გავუშვით პროგრამა გაშვებული.

826
00:57:35,000 --> 00:57:41,000
ბრძანების ხაზი არგუმენტები ყველა არის მითითებული როდის გავუშვით პროგრამა გაშვებული.

827
00:57:41,000 --> 00:57:47,000
ჩვენ ბევრი შერევით ორი იმ.

828
00:57:47,000 --> 00:57:52,000
როდესაც ჩვენ ვიყენებთ არგუმენტები ფუნქცია, ეს ჰგავს ბრძანების ხაზი არგუმენტები ძირითადი.

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

830
00:57:56,000 --> 00:58:05,000
რას მას სჭირდება, რათა შეასრულოს თავისი ამოცანები.

831
00:58:05,000 --> 00:58:08,000
კიდევ ერთი კარგი რამ შევხედოთ და მე მოგცემთ შეხედოთ იგი თქვენს თავისუფალ დროს,

832
00:58:08,000 --> 00:58:11,000
და ეს იყო დაფარული ინტელექტუალური იყო ამ ცნება ფარგლებს

833
00:58:11,000 --> 00:58:15,000
და ადგილობრივი ცვლადები წინააღმდეგ გლობალური ცვლადები.

834
00:58:15,000 --> 00:58:18,000
Do ყურადღება მიაქციონ, რომ.

835
00:58:18,000 --> 00:58:23,000
>> ახლა, როდესაც ჩვენ ვიღებთ შესახებ, რომ ამ სხვა პერსონალი,

836
00:58:23,000 --> 00:58:27,000
წელს კვირა 3 დავიწყეთ ლაპარაკი ძებნას და დახარისხება.

837
00:58:27,000 --> 00:58:32,000
Searching და დახარისხება მაინც, CS50,

838
00:58:32,000 --> 00:58:39,000
არის ძალიან შესავალი ზოგიერთი უფრო თეორიული ნაწილები კომპიუტერული მეცნიერებების.

839
00:58:39,000 --> 00:58:42,000
პრობლემა ძებნა პრობლემა დახარისხება

840
00:58:42,000 --> 00:58:46,000
დიდი, კანონიკური პრობლემები.

841
00:58:46,000 --> 00:58:52,000
როგორ მოვძებნოთ კერძოდ ნომერი მასივი მილიარდობით რიცხვებით?

842
00:58:52,000 --> 00:58:55,000
როგორ მოვძებნოთ კერძოდ სახელი შიგნით სატელეფონო წიგნაკი

843
00:58:55,000 --> 00:58:59,000
რომ ინახება თქვენს ლეპტოპი?

844
00:58:59,000 --> 00:59:04,000
ასე რომ, ჩვენ ამ თანამედროვე ცნება asymptotic პერსპექტივაში ჯერ

845
00:59:04,000 --> 00:59:11,000
ნამდვილად quantify რამდენ ხანს, რა მძიმე ეს პრობლემა არის,

846
00:59:11,000 --> 00:59:14,000
რამდენ ხანს ისინი მოსაგვარებლად.

847
00:59:14,000 --> 00:59:20,000
In, მე მჯერა, 2011 ს ვიქტორინა არსებობს პრობლემა, რომ ვფიქრობ დამსახურებისთვის

848
00:59:20,000 --> 00:59:27,000
დაფარვის ძალიან სწრაფად, რაც ამ ერთი, პრობლემა 12.

849
00:59:27,000 --> 00:59:32,000
O არა, ეს ომეგა.

850
00:59:32,000 --> 00:59:41,000
>> აქ ჩვენ ვსაუბრობთ უსწრაფესად პერსპექტივაში დრო

851
00:59:41,000 --> 00:59:46,000
კონკრეტული ალგორითმი და შემდეგ ნელი შესაძლებელია პერსპექტივაში დრო.

852
00:59:46,000 --> 00:59:52,000
ეს ომეგა და O მართლაც მხოლოდ კომბინაციები.

853
00:59:52,000 --> 00:59:55,000
ისინი notational კომბინაციები ამისთვის ამბობდა

854
00:59:55,000 --> 00:59:59,000
როგორ სწრაფად საუკეთესო შესაძლებელი საქმეს ჩვენი ალგორითმი პერსპექტივაში,

855
00:59:59,000 --> 01:00:06,000
და როგორ ნელა ყველაზე ცუდ შესაძლო საქმეს ჩვენი ალგორითმი აწარმოებს?

856
01:00:06,000 --> 01:00:10,000
მოდით რამდენიმე ამ, და ეს ასევე დაფარული

857
01:00:10,000 --> 01:00:13,000
მოკლე on asymptotic ნოტაცია, რომელიც უაღრესად რეკომენდაციას.

858
01:00:13,000 --> 01:00:17,000
ჯექსონის გააკეთა ნამდვილად კარგ საქმეს.

859
01:00:17,000 --> 01:00:23,000
ერთად ორობითი ძებნა, ვსაუბრობთ ორობითი ძებნა როგორც ალგორითმი,

860
01:00:23,000 --> 01:00:28,000
და ჩვენ, როგორც წესი, ამაზე თვალსაზრისით დიდი ო

861
01:00:28,000 --> 01:00:30,000
რა არის დიდი O?

862
01:00:30,000 --> 01:00:34,000
რა არის ყველაზე ნელი შესაძლებელია პერსპექტივაში დრო ორობითი ძებნა?

863
01:00:34,000 --> 01:00:36,000
[სტუდენტური] N ²?

864
01:00:36,000 --> 01:00:41,000
დახურვა, ვფიქრობ მსგავსი.

865
01:00:41,000 --> 01:00:43,000
ეს ბევრი უფრო სწრაფად, ვიდრე, რომ.

866
01:00:43,000 --> 01:00:45,000
[სტუდენტური] ორობითი? >> Yeah, ორობითი ძებნა.

867
01:00:45,000 --> 01:00:47,000
[სტუდენტური] ეს log N.

868
01:00:47,000 --> 01:00:49,000
შესვლა N, რას შეხვიდეთ n ნიშნავს?

869
01:00:49,000 --> 01:00:51,000
ეს halves იგი ყოველ iteration.

870
01:00:51,000 --> 01:00:56,000
სწორედ ასე ნელი შესაძლო შემთხვევაში,

871
01:00:56,000 --> 01:01:00,000
ამბობენ, თუ თქვენ გაქვთ დახარისხებული მასივი

872
01:01:00,000 --> 01:01:08,000
საქართველოს მილიონ რიცხვებით და ნომერი ვეძებთ

873
01:01:08,000 --> 01:01:14,000
არის ან ძალიან პირველი ელემენტია მასივი ან ძალიან ბოლო ელემენტია მასივი.

874
01:01:14,000 --> 01:01:18,000
გახსოვდეთ, ორობითი ძებნა ალგორითმი მუშაობს ეძებს ახლო ელემენტს,

875
01:01:18,000 --> 01:01:21,000
ხედავს თუ ეს მატჩი, რომ თქვენ ეძებს.

876
01:01:21,000 --> 01:01:23,000
თუ ეს, მაშინ დიდი, თქვენ ი იგი.

877
01:01:23,000 --> 01:01:27,000
>> საუკეთესო შესაძლო შემთხვევაში, თუ რამდენად სწრაფად აკეთებს ორობითი ძებნა პერსპექტივაში?

878
01:01:27,000 --> 01:01:29,000
[სტუდენტთა] 1.

879
01:01:29,000 --> 01:01:32,000
1, ეს მუდმივი დროს, დიდი O 1. Yeah.

880
01:01:32,000 --> 01:01:36,000
[სტუდენტური] მე მაქვს შეკითხვა. როცა ამბობენ, შეხვიდეთ of N, გულისხმობთ მიმართ ბაზის 2, არა?

881
01:01:36,000 --> 01:01:40,000
დიახ, ასე რომ სხვა რამ.

882
01:01:40,000 --> 01:01:44,000
ჩვენ ვამბობთ შესვლა N და, ალბათ, როდესაც მე ვიყავი საშუალო სკოლა

883
01:01:44,000 --> 01:01:48,000
მე ყოველთვის ვივარაუდოთ, რომ ჩანაწერი იყო ბაზა 10.

884
01:01:48,000 --> 01:01:57,000
ჰო, ასე რომ დიახ, შეხვიდეთ ბაზის 2 ტიპიურად არის ის, რაც ჩვენ ვიყენებთ.

885
01:01:57,000 --> 01:02:02,000
ერთხელ, ბრუნდება ორობითი ძებნა, თუ თქვენ ეძებს ან

886
01:02:02,000 --> 01:02:05,000
ელემენტს დროს ბოლომდე ან ელემენტს დასაწყისშივე,

887
01:02:05,000 --> 01:02:08,000
იმიტომ, რომ თქვენ დაიწყოს შუა და მერე გაუქმება

888
01:02:08,000 --> 01:02:13,000
რომელი ნახევარი არ აკმაყოფილებს კრიტერიუმებს, რომ თქვენ ეძებს,

889
01:02:13,000 --> 01:02:15,000
და თქვენ გადასვლა შემდეგ ნახევარი და შემდეგი ნახევარი და შემდეგი ნახევარი.

890
01:02:15,000 --> 01:02:19,000
თუ მე ეძებს უმსხვილესი ელემენტია მილიონი რიცხვი მასივი

891
01:02:19,000 --> 01:02:25,000
მე ვაპირებ HALVE იგი საუკეთესო შესვლა 1 მლნ ჯერ

892
01:02:25,000 --> 01:02:28,000
სანამ საბოლოოდ გამოცდა და ვხედავ, რომ ელემენტს ვეძებ

893
01:02:28,000 --> 01:02:33,000
არის ყველაზე დიდი ან უმაღლესი მაჩვენებელი მასივი,

894
01:02:33,000 --> 01:02:38,000
და რომ მიიღებს შესვლა of n, log 1 მლნ ჯერ.

895
01:02:38,000 --> 01:02:40,000
>> Bubble ჯიშია.

896
01:02:40,000 --> 01:02:43,000
მიგაჩნიათ თუ არა ბიჭები გახსოვთ ბუშტი დახარისხების ალგორითმი?

897
01:02:43,000 --> 01:02:47,000
კევინ, შეგიძლიათ მომეცი სწრაფი recap, თუ რა მოხდა ბუშტი დახარისხების ალგორითმი?

898
01:02:47,000 --> 01:02:50,000
[Kevin] ძირითადად იგი გადის ყველაფერი სიაში.

899
01:02:50,000 --> 01:02:52,000
იგი უყურებს პირველი ორი.

900
01:02:52,000 --> 01:02:55,000
თუ პირველი ერთი მეტია ვიდრე მეორე ეს სვოპების მათ.

901
01:02:55,000 --> 01:02:58,000
მერე ადარებს მეორე და მესამე, იგივე, სვოპების,

902
01:02:58,000 --> 01:03:00,000
მესამე და მეოთხე, ყველა გზა down.

903
01:03:00,000 --> 01:03:03,000
Bigger ნომრები მოჰყვება ბოლომდე.

904
01:03:03,000 --> 01:03:07,000
ხოლო მას შემდეგ, თუმცა ბევრი მარყუჟების თქვენ გაკეთდეს.

905
01:03:07,000 --> 01:03:11,000
სწორედ, ასე რომ კევინ განაცხადა არის ის, რომ ჩვენ უყუროთ უფრო დიდი ციფრები

906
01:03:11,000 --> 01:03:15,000
ბუშტი მდე ბოლოს მასივი.

907
01:03:15,000 --> 01:03:19,000
მაგალითად, თუ თქვენ იბადება ფეხით ჩვენს მეშვეობით მაგალითი თუ ეს ჩვენი მასივი?

908
01:03:19,000 --> 01:03:21,000
[Kevin] თქვენ მიიღოს 2 და 3.

909
01:03:21,000 --> 01:03:23,000
3 მეტია, ვიდრე 2, ასე რომ თქვენ სვოპ მათ.

910
01:03:23,000 --> 01:03:29,000
[Nate ჰ] მარჯვენა, ამიტომ ჩვენ ამ სვოპ, ამიტომ ჩვენ კიდევ 2, 3, 6, 4, და 9.

911
01:03:29,000 --> 01:03:31,000
[Kevin] მაშინ შედარების 3 და 6.

912
01:03:31,000 --> 01:03:33,000
3 მცირეა 6, ასე რომ თქვენ დატოვეთ,

913
01:03:33,000 --> 01:03:37,000
და 6 და 4, ნეტავ სვოპ მათ რადგან 4 მცირეა 6.

914
01:03:37,000 --> 01:03:42,000
[Nate ჰ] მარჯვენა, ასე რომ კიდევ 2, 3, 4, 6, 9.

915
01:03:42,000 --> 01:03:46,000
[Kevin] და 9 მეტია, ვიდრე 6, ასე რომ თქვენ დატოვეთ.

916
01:03:46,000 --> 01:03:48,000
და ნეტავ დაბრუნდეს მეშვეობით კიდევ ერთხელ.

917
01:03:48,000 --> 01:03:50,000
>> [Nate ჰ] მე გაკეთდეს ამ ეტაპზე? >> [Kevin] ჯგუფი

918
01:03:50,000 --> 01:03:52,000
და რატომ ვარ მე არ კეთდება ამ ეტაპზე?

919
01:03:52,000 --> 01:03:54,000
იმის გამო, რომ გამოიყურება ჩემი მასივი დალაგებულია. მე ეძებს მას.

920
01:03:54,000 --> 01:03:57,000
[Kevin] გავლა კიდევ ერთხელ და დარწმუნდით რომ არ არსებობს უფრო სვოპების

921
01:03:57,000 --> 01:04:00,000
სანამ შეგიძლიათ სრულად შეწყვიტოს.

922
01:04:00,000 --> 01:04:04,000
სწორედ, ასე რომ თქვენ უნდა შევინარჩუნოთ გადის და დარწმუნდით, რომ არ არსებობს სვოპების

923
01:04:04,000 --> 01:04:06,000
რომ შეგიძლიათ ამ ეტაპზე.

924
01:04:06,000 --> 01:04:08,000
ეს იყო ნამდვილად უბრალოდ გაუმართლა, ისევე როგორც თქვენ თქვით, რომ ჩვენ დასრულდა

925
01:04:08,000 --> 01:04:12,000
მხოლოდ მქონე რათა 1 გადის და ჩვენ დახარისხებული.

926
01:04:12,000 --> 01:04:16,000
მაგრამ ამის გაკეთება ზოგად შემთხვევაში ჩვენ რეალურად უნდა გავაკეთოთ ეს უსასრულოდ.

927
01:04:16,000 --> 01:04:20,000
და ფაქტობრივად, ეს იყო მაგალითი მაქსიმალურად შემთხვევაში,

928
01:04:20,000 --> 01:04:24,000
მოსწონს ვნახეთ პრობლემა.

929
01:04:24,000 --> 01:04:28,000
ჩვენ ვნახეთ, რომ მაქსიმალურად საქმე n.

930
01:04:28,000 --> 01:04:32,000
ჩვენ გამოვიარეთ მასივი 1 დრო.

931
01:04:32,000 --> 01:04:35,000
რა არის ყველაზე უარესი შემთხვევაში ამ ალგორითმი?

932
01:04:35,000 --> 01:04:37,000
[Kevin] N ².

933
01:04:37,000 --> 01:04:41,000
და რას ჰგავს? რა მასივი გამოიყურება ასე, რომ მიიღებს n ² დრო?

934
01:04:41,000 --> 01:04:43,000
[Kevin] [inaudible] დახარისხებული.

935
01:04:43,000 --> 01:04:51,000
სწორედ ასე რომ, თუ მქონდა მასივი 9, 7, 6, 5, 2,

936
01:04:51,000 --> 01:04:54,000
პირველი 9 დაუჭერთ ბუშტი ყველა გზა მდე.

937
01:04:54,000 --> 01:04:59,000
შემდეგ 1 iteration ჩვენ ავღნიშნო აქვს 7, 6, 5, 2, 9.

938
01:04:59,000 --> 01:05:07,000
მაშინ 7 დაუჭერთ ბუშტი up, 6, 5, 2, 7, 9, და ა.შ. და ა.შ..

939
01:05:07,000 --> 01:05:13,000
>> მე მინდა უნდა გაიაროს მთელი მასივი N ჯერ,

940
01:05:13,000 --> 01:05:16,000
და თქვენ შეგიძლიათ რეალურად მიიღოთ ოდნავ უფრო ზუსტი, ვიდრე ეს

941
01:05:16,000 --> 01:05:23,000
იმიტომ, რომ ერთხელ ჩვენ გადავიდა 9 ყველა გზა მდე თავის ბოლო შესაძლო პოზიცია

942
01:05:23,000 --> 01:05:26,000
ჩვენ ვიცით, რომ ჩვენ არასოდეს არ შეადაროთ წინააღმდეგ რომ ელემენტს ერთხელ.

943
01:05:26,000 --> 01:05:29,000
ერთხელ ჩვენ ვიწყებთ bubbling 7 up

944
01:05:29,000 --> 01:05:35,000
ჩვენ ვიცით, რომ ჩვენ შეგვიძლია შეწყვიტოს ერთხელ 7 არის სწორი, სანამ 9

945
01:05:35,000 --> 01:05:37,000
მას შემდეგ, რაც ჩვენ უკვე შედარებით 9 მას.

946
01:05:37,000 --> 01:05:46,000
თუ თქვენ ამ წელს გონივრული გზა ეს არ ნამდვილად, ვფიქრობ, რომ დიდი დრო.

947
01:05:46,000 --> 01:05:49,000
თქვენ არ ვაპირებთ შედარების ყველა შესაძლო [inaudible] კომბინაციები

948
01:05:49,000 --> 01:05:55,000
თითოეული დროს თქვენ გავლა თითოეულ iteration.

949
01:05:55,000 --> 01:05:59,000
მაგრამ მაინც, როდესაც ვსაუბრობთ ამ ზედა შეკრული ჩვენ ვამბობთ, რომ

950
01:05:59,000 --> 01:06:04,000
რომლებსაც თქვენ ახლა ეცნობით n ² შედარებები ყველა გზას.

951
01:06:04,000 --> 01:06:12,000
>> მოდით დავუბრუნდეთ, და რადგან ჩვენ დაწყებული მისაღებად პატარა მოკლე დროში

952
01:06:12,000 --> 01:06:15,000
მე ვიტყოდი, თქვენ უნდა აუცილებლად გავლა დანარჩენი ამ მაგიდასთან,

953
01:06:15,000 --> 01:06:17,000
შეავსოთ ეს ყველაფერი გარეთ.

954
01:06:17,000 --> 01:06:20,000
იფიქრეთ მაგალითები. იფიქრეთ კონკრეტული მაგალითები.

955
01:06:20,000 --> 01:06:22,000
რომ მართლაც მოსახერხებელი და სასარგებლო უნდა გააკეთოს.

956
01:06:22,000 --> 01:06:25,000
დახაზეთ იგი out.

957
01:06:25,000 --> 01:06:28,000
ეს არის ერთგვარი მაგიდასთან რომ, როგორც თქვენ გავლით კომპიუტერულ მეცნიერებაში

958
01:06:28,000 --> 01:06:32,000
თქვენ უნდა ნამდვილად დაიწყება იცოდეს ამ ზეპირად.

959
01:06:32,000 --> 01:06:34,000
ეს არის სახის კითხვებით თქვენ მიიღონ გასაუბრება.

960
01:06:34,000 --> 01:06:36,000
ეს არის სახის რამ, რომ კარგი იცოდეს,

961
01:06:36,000 --> 01:06:41,000
და ვიფიქროთ იმ ზღვარზე შემთხვევაში, ნამდვილად მჭიდროდაა თუ როგორ ვიფიქროთ

962
01:06:41,000 --> 01:06:45,000
იცოდა, რომ ბუშტი დასალაგებლად ყველაზე უარესი მასივი

963
01:06:45,000 --> 01:06:52,000
დასალაგებლად, რომ არის ერთი რომ წელს საპირისპირო მიზნით.

964
01:06:52,000 --> 01:06:58,000
>> პოინტერები. ვისაუბროთ ცოტა შესახებ მითითებას.

965
01:06:58,000 --> 01:07:03,000
ბოლო რამდენიმე წუთის გვაქვს აქ

966
01:07:03,000 --> 01:07:11,000
მე ვიცი, ეს არის ის ერთად ფაილის I / O, რომ საკმაოდ ახალი.

967
01:07:11,000 --> 01:07:19,000
როდესაც ვსაუბრობთ პოინტერები მიზეზი გვინდა ვისაუბროთ პოინტერები

968
01:07:19,000 --> 01:07:24,000
ეს იმიტომ, ერთი, როდესაც ჩვენ ვმუშაობთ in C

969
01:07:24,000 --> 01:07:33,000
ჩვენ ნამდვილად დროს საკმაოდ დაბალი დონე შედარებით ყველაზე თანამედროვე პროგრამირების ენები.

970
01:07:33,000 --> 01:07:38,000
ჩვენ რეალურად შეუძლია მანიპულირება ცვლადები მეხსიერებაში,

971
01:07:38,000 --> 01:07:43,000
გაერკვნენ, სადაც ისინი რეალურად ფარგლებში მდებარე ჩვენი RAM.

972
01:07:43,000 --> 01:07:46,000
ერთხელ თქვენ ხმარდება მიიღოს ოპერაციული სისტემა კლასების დაინახავთ

973
01:07:46,000 --> 01:07:48,000
რომ ეს არის ის, კიდევ ერთხელ, სახის აბსტრაქცია.

974
01:07:48,000 --> 01:07:50,000
ეს არ არის რეალურად საქმე.

975
01:07:50,000 --> 01:07:52,000
გვაქვს ვირტუალური მეხსიერება, რომელიც იმალებოდა იმ დეტალებს ჩვენთან.

976
01:07:52,000 --> 01:07:58,000
>> მაგრამ ახლა თქვენ შეიძლება ვივარაუდოთ, რომ როდესაც თქვენ პროგრამას,

977
01:07:58,000 --> 01:08:02,000
მაგალითად, როდესაც თქვენ დავიწყოთ გაშვებული თქვენი კეისრის კოდი პროგრამა

978
01:08:02,000 --> 01:08:06,000
მე გადართოთ თავში ჩემი iPad მართლაც სწრაფად-

979
01:08:06,000 --> 01:08:12,000
რომ თავიდანვე თქვენი პროგრამა, თუ გაქვთ, ვთქვათ,

980
01:08:12,000 --> 01:08:15,000
4 გბ მეხსიერება თქვენი ლეპტოპი,

981
01:08:15,000 --> 01:08:21,000
თქვენ მიიღებთ გათვალისწინებულია ამ ბლოკი, და ჩვენ მოვუწოდებთ ამ RAM.

982
01:08:21,000 --> 01:08:25,000
და ეს იწყება ადგილი ჩვენ ვაპირებთ მოვუწოდებთ 0,

983
01:08:25,000 --> 01:08:30,000
და ეს დამთავრდა ადგილზე რომ ჩვენ მოვუწოდებთ 4 გბ.

984
01:08:30,000 --> 01:08:37,000
მე ნამდვილად ვერ წერენ. მამაკაცს, რომ კალენდარი.

985
01:08:37,000 --> 01:08:40,000
როდესაც თქვენი პროგრამა ახორციელებს

986
01:08:40,000 --> 01:08:44,000
ოპერაციული სისტემა carves up RAM,

987
01:08:44,000 --> 01:08:51,000
და ეს მიუთითებს სხვადასხვა სეგმენტების სხვადასხვა ნაწილების თქვენი პროგრამის ცხოვრება შემოსული

988
01:08:51,000 --> 01:08:58,000
Down აქ ამ სფეროში არის სახის არავინ სახმელეთო.

989
01:08:58,000 --> 01:09:02,000
როდესაც თქვენ ახვიდეთ ოდნავ მოშორებით აქ

990
01:09:02,000 --> 01:09:05,000
თქვენ მოხვდით რეალურად ადგილი, სადაც

991
01:09:05,000 --> 01:09:09,000
კოდი თქვენი პროგრამის ცხოვრებაში.

992
01:09:09,000 --> 01:09:13,000
რომ ფაქტობრივი ორობითი კოდი, რომ შესრულებადი ფაილი რეალურად იღებს დატვირთული მეხსიერებაში

993
01:09:13,000 --> 01:09:17,000
როდესაც თქვენ აწარმოებს პროგრამა, და ეს ცხოვრობს კოდი სეგმენტი.

994
01:09:17,000 --> 01:09:22,000
და როგორც შენი პროგრამა ახორციელებს პროცესორი უყურებს ამ კოდექსით სეგმენტი

995
01:09:22,000 --> 01:09:24,000
გაერკვნენ, თუ რა არის შემდეგი ინსტრუქციის?

996
01:09:24,000 --> 01:09:27,000
რა არის შემდეგი ხაზი კოდი უნდა შეასრულოს?

997
01:09:27,000 --> 01:09:31,000
>> არსებობს ასევე მონაცემები სეგმენტის, და ეს არის სადაც სიმებიანი მუდმივები

998
01:09:31,000 --> 01:09:34,000
მისაღებად ინახება, რომ თქვენ უკვე გამოყენებით.

999
01:09:34,000 --> 01:09:42,000
და მაშინ შორს არ არის ეს ადგილი მოუწოდა ბევრი.

1000
01:09:42,000 --> 01:09:46,000
ჩვენ შედიხართ მეხსიერების იქ გამოყენებით malloc,

1001
01:09:46,000 --> 01:09:49,000
და მაშინ მიმართ ძალიან ზევით თქვენი პროგრამა

1002
01:09:49,000 --> 01:09:52,000
არსებობს დასტის,

1003
01:09:52,000 --> 01:09:57,000
და რომ სადაც ჩვენ ვთამაშობდი უმრავლესობა დასაწყისია.

1004
01:09:57,000 --> 01:09:59,000
ეს არ არის მასშტაბის ან არაფერი.

1005
01:09:59,000 --> 01:10:03,000
ბევრი ეს ძალიან მანქანა დამოკიდებული,

1006
01:10:03,000 --> 01:10:10,000
ოპერაციული სისტემის დამოკიდებული, მაგრამ ეს შედარებით, თუ როგორ მიიღოთ chunked up.

1007
01:10:10,000 --> 01:10:17,000
როდესაც თქვენ აწარმოებს პროგრამა და თქვენ განაცხადოს ცვლადში X-

1008
01:10:17,000 --> 01:10:27,000
მე ვაპირებ დახაზეთ მეორე ყუთი ქვემოთ ქვემოთ და ეს იქნება RAM ისევე.

1009
01:10:27,000 --> 01:10:29,000
და მე ვაპირებ გამოიყურება.

1010
01:10:29,000 --> 01:10:34,000
ჩვენ მიაპყროს Jagged ხაზების მიუთითოს ეს მხოლოდ მცირე მონაკვეთის RAM

1011
01:10:34,000 --> 01:10:38,000
და არა ყველა, როგორც ჩვენ მიაპყროს ზედა.

1012
01:10:38,000 --> 01:10:43,000
>> თუ ვაცხადებ მთელი ცვლადში x,

1013
01:10:43,000 --> 01:10:49,000
მაშინ რა რეალურად კიდევ არის რუკების

1014
01:10:49,000 --> 01:10:54,000
რომ ინახება სიმბოლო მაგიდასთან ჩემი პროგრამა

1015
01:10:54,000 --> 01:11:00,000
რომ აკავშირებს სახელი x ამ რეგიონში მეხსიერება, რომ მე შედგენილი

1016
01:11:00,000 --> 01:11:03,000
სწორედ აქ შორის ვერტიკალური ბარები.

1017
01:11:03,000 --> 01:11:08,000
თუ მაქვს ხაზი კოდი ჩემი პროგრამა, რომელიც ამბობს x = 7

1018
01:11:08,000 --> 01:11:15,000
პროცესორი იცის "ოჰ, okay, მე ვიცი, რომ x ცხოვრობს ამ ადგილას მეხსიერებაში."

1019
01:11:15,000 --> 01:11:25,000
"მე ვაპირებ წავიდეთ წინ და დაწეროთ 7 არსებობს."

1020
01:11:25,000 --> 01:11:28,000
როგორ ვიცით რა საიდან ეს მეხსიერებაში?

1021
01:11:28,000 --> 01:11:30,000
ისე, რომ ყველა კეთდება კომპილირების დროს.

1022
01:11:30,000 --> 01:11:34,000
შემდგენელი ზრუნავს გამოყოფის სადაც თითოეულ ცვლადების აპირებს

1023
01:11:34,000 --> 01:11:40,000
და შექმნა სპეციალური რუკების ან საკმაოდ დამაკავშირებელი წერტილების

1024
01:11:40,000 --> 01:11:43,000
შორის სიმბოლო და სადაც ეს ხდება, ცვლადი სახელი

1025
01:11:43,000 --> 01:11:46,000
და სად ხდება ცხოვრება მეხსიერება.

1026
01:11:46,000 --> 01:11:50,000
მაგრამ აღმოჩნდება, რომ ჩვენ შეგვიძლია რეალურად ვებგვერდზე ჩვენს პროგრამებს ისევე.

1027
01:11:50,000 --> 01:11:55,000
ეს იღებს მნიშვნელოვანია, როდესაც ჩვენ ვიწყებთ საუბარს ზოგიერთი მონაცემები სტრუქტურების,

1028
01:11:55,000 --> 01:11:58,000
რომელიც კონცეფციას, რომ ჩვენ ვაპირებთ დანერგვა შემდგომში.

1029
01:11:58,000 --> 01:12:09,000
>> მაგრამ ახლა, თუ რა შეგიძლიათ ვიცი ის არის, რომ მე შეგიძლიათ შექმნათ კურსორი ამ ადგილას, x.

1030
01:12:09,000 --> 01:12:12,000
მაგალითად, მე შეიძლება შექმნათ კურსორი ცვლადი.

1031
01:12:12,000 --> 01:12:16,000
როდესაც ჩვენ შევქმნით მაჩვენებელი ცვლადი ვიყენებთ ვარსკვლავი ნოტაცია.

1032
01:12:16,000 --> 01:12:21,000
ამ შემთხვევაში, ეს ამბობს მე ვაპირებ შექმნას მომცეთ int.

1033
01:12:21,000 --> 01:12:24,000
ეს ტიპი, ისევე, როგორც ნებისმიერი სხვა.

1034
01:12:24,000 --> 01:12:27,000
ჩვენ ეს ცვლადი, როგორიცაა Y,

1035
01:12:27,000 --> 01:12:32,000
და მაშინ ჩვენ ვაყენებთ მას ტოლი მისამართი, რათა მისამართზე.

1036
01:12:32,000 --> 01:12:38,000
ამ შემთხვევაში, ჩვენ შეგვიძლია მითითებული Y აღვნიშნო, X

1037
01:12:38,000 --> 01:12:43,000
აღებით მისამართი x, რომელსაც ჩვენ გავაკეთებთ ამ ampersand,

1038
01:12:43,000 --> 01:12:55,000
და მაშინ ჩვენ დავსახეთ Y აღვნიშნო მას.

1039
01:12:55,000 --> 01:12:59,000
რა ამ არსებითად ამჯამად არის თუ შევხედავთ ჩვენი RAM

1040
01:12:59,000 --> 01:13:02,000
ამ ქმნის ცალკე ცვლადი.

1041
01:13:02,000 --> 01:13:04,000
იგი აპირებს ეძახით Y,

1042
01:13:04,000 --> 01:13:06,000
და როდესაც ამ ხაზი კოდი ახორციელებს

1043
01:13:06,000 --> 01:13:13,000
სინამდვილეში აპირებს შექმნას პატარა მაჩვენებელი, რომელიც ჩვენ, როგორც წესი, მიაპყროს როგორც arrow,

1044
01:13:13,000 --> 01:13:15,000
და ის ისეთ Y აღვნიშნო, რომ x.

1045
01:13:15,000 --> 01:13:17,000
დიახ.

1046
01:13:17,000 --> 01:13:19,000
[სტუდენტური] თუ x არის უკვე მაჩვენებელი, რომ თქვენ უბრალოდ

1047
01:13:19,000 --> 01:13:22,000
int * y = x ნაცვლად, რომელმაც ampersand?

1048
01:13:22,000 --> 01:13:24,000
დიახ.

1049
01:13:24,000 --> 01:13:27,000
თუ x არის უკვე კურსორი, მაშინ როდესაც თქვენ დააჭერთ 2 პოინტერები თანაბარი ერთმანეთს,

1050
01:13:27,000 --> 01:13:30,000
ამ შემთხვევაში Y არ აღვნიშნო, რომ X,

1051
01:13:30,000 --> 01:13:34,000
მაგრამ ეს არ აღვნიშნო, რომ რაც არ უნდა X-ის მიუთითებს.

1052
01:13:34,000 --> 01:13:37,000
სამწუხაროდ, ჩვენ გარეთ დრო.

1053
01:13:37,000 --> 01:13:44,000
>> მე ვიტყოდი, ამ ეტაპზე, ჩვენ შეგვიძლია ვისაუბროთ ამ ფორუმზე,

1054
01:13:44,000 --> 01:13:49,000
მაგრამ მე ვიტყოდი, დაიწყოს მუშაობა ამ პრობლემის, # 14.

1055
01:13:49,000 --> 01:13:53,000
ხედავთ უკვე ცოტა შევსებული თქვენთვის აქ.

1056
01:13:53,000 --> 01:13:57,000
თქვენ ხედავთ, რომ როდესაც ვაცხადებთ, 2 პოინტერები, int * x და * Y,

1057
01:13:57,000 --> 01:14:01,000
და გაითვალისწინოთ, რომ მიანიშნა * შემდეგ ცვლადი იყო რაღაც, რომ გაკეთდა შარშან.

1058
01:14:01,000 --> 01:14:05,000
თურმე ეს მსგავსი იმას თუ რას ვაკეთებთ წელს.

1059
01:14:05,000 --> 01:14:11,000
არ აქვს მნიშვნელობა, სადაც თქვენ დაწერეთ * როცა თქვენ გამოცხადების მაჩვენებელი.

1060
01:14:11,000 --> 01:14:17,000
მაგრამ ჩვენ კარგად გვაქვს წერილობითი * შემდეგი ტიპის

1061
01:14:17,000 --> 01:14:24,000
იმიტომ, რომ ხდის ძალიან მკაფიო, რომ თქვენ გამოცხადების მაჩვენებელი ცვლადი.

1062
01:14:24,000 --> 01:14:27,000
თქვენ ხედავთ, რომ გამოცხადების 2 პოინტერები გვაძლევს 2 ყუთები.

1063
01:14:27,000 --> 01:14:31,000
აქ, როცა ჩვენ დავსახეთ x ტოლია malloc

1064
01:14:31,000 --> 01:14:34,000
რა ამ ამბობს განსაზღვრავს განზე მეხსიერება ბევრი.

1065
01:14:34,000 --> 01:14:41,000
ეს პატარა ყუთი უფლება აქ, ამ წრის, მდებარეობს ბევრი.

1066
01:14:41,000 --> 01:14:43,000
X-ის მიუთითებს მას.

1067
01:14:43,000 --> 01:14:46,000
გაითვალისწინეთ, რომ Y კვლავ არ მიუთითებს არაფერი.

1068
01:14:46,000 --> 01:14:50,000
იმისათვის რომ მეხსიერების შესანახად ხმების 42 შევიდა x

1069
01:14:50,000 --> 01:14:55,000
ჩვენ ვიყენებთ რა ნოტაცია?

1070
01:14:55,000 --> 01:14:59,000
[სტუდენტური] * x = 42.

1071
01:14:59,000 --> 01:15:01,000
სწორედ * x = 42.

1072
01:15:01,000 --> 01:15:06,000
ეს იმას ნიშნავს, დაიცვას arrow და გადაყარეთ 42 იქ.

1073
01:15:06,000 --> 01:15:09,000
აქ, სადაც ჩვენ მითითებული Y-სა და x ჩვენ Y მიუთითებს x.

1074
01:15:09,000 --> 01:15:13,000
ისევ და ისევ, ეს მხოლოდ მსგავსი იმისა, კევინ განაცხადა, სადაც ჩვენ მითითებული Y ტოლია x.

1075
01:15:13,000 --> 01:15:15,000
Y არ არის მიუთითებს x.

1076
01:15:15,000 --> 01:15:19,000
უფრო მეტიც, ის მიუთითებს, რა X-ის მიუთითებს ასევე.

1077
01:15:19,000 --> 01:15:24,000
>> და მაშინ საბოლოოდ ამ ბოლო ყუთში არსებობს 2 შესაძლო რამ, რომ ჩვენ შეგვიძლია გავაკეთოთ.

1078
01:15:24,000 --> 01:15:28,000
ერთი შეიძლება ითქვას * x = 13.

1079
01:15:28,000 --> 01:15:33,000
სხვა რამ არის შეიძლება ითქვას-Alex, იცით, რაც ჩვენ შეიძლება არ აქ?

1080
01:15:33,000 --> 01:15:37,000
თქვენ შეიძლება ითქვას * x = 13 ან-

1081
01:15:37,000 --> 01:15:41,000
[სტუდენტური] თქვენ შეიძლება ითქვას, int რასაც.

1082
01:15:41,000 --> 01:15:45,000
[Nate ჰ] თუ ეს იყო მოხსენიებული, როგორც int ცვლადი, ჩვენ შეგვიძლია გავაკეთოთ, რომ.

1083
01:15:45,000 --> 01:15:49,000
ჩვენ შეგვიძლია აგრეთვე ამბობენ * Y = 13 რადგან ისინი ორივე მიუთითებს იმ ადგილას,

1084
01:15:49,000 --> 01:15:51,000
ამიტომ ვერ გამოიყენოთ ცვლადი მისაღებად არსებობს.

1085
01:15:51,000 --> 01:15:56,000
Yeah. >> [სტუდენტური] რას უნდა გამოიყურებოდეს თუ ჩვენ უბრალოდ, ვამბობთ int x არის 13?

1086
01:15:56,000 --> 01:16:00,000
იქნებოდა გამოცხადების ახალი ცვლადში x, რომელიც არ მუშაობს.

1087
01:16:00,000 --> 01:16:04,000
გვსურს აქვს შეჯახება, რადგან ჩვენ განაცხადა x იყოს მაჩვენებელი აქ.

1088
01:16:04,000 --> 01:16:10,000
[სტუდენტური] თუ ჩვენ უბრალოდ ჰქონდა, რომ განცხადება თავად რას უნდა გამოიყურებოდეს თვალსაზრისით წრე?

1089
01:16:10,000 --> 01:16:14,000
თუ ჩვენ გვქონდა x = 13 მაშინ ჩვენ ავღნიშნო აქვს ყუთი, და ვიდრე მქონე arrow

1090
01:16:14,000 --> 01:16:16,000
გამოდის ყუთი მინდა შევაჩერო ის როგორც მხოლოდ 13.

1091
01:16:16,000 --> 01:16:19,000
[სტუდენტური] ყუთში. Okay.

1092
01:16:19,000 --> 01:16:24,000
>> გმადლობთ თვალს, და გისურვებთ წარმატებას Quiz 0.

1093
01:16:24,000 --> 01:16:28,000
[CS50.TV]