1
00:00:00,000 --> 00:00:02,860
[Powered by Google Translate] [კვირა 5]

2
00:00:02,860 --> 00:00:04,860
[დევიდ ჯ Malan - ჰარვარდის უნივერსიტეტი]

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

4
00:00:07,260 --> 00:00:09,740
>> ეს არის CS50, კვირა 5.

5
00:00:09,740 --> 00:00:12,900
დღეს და ამ კვირაში, ჩვენ წარმოგიდგინოთ ცოტა სამყაროში სასამართლო ექსპერტიზის

6
00:00:12,900 --> 00:00:14,850
კონტექსტში პრობლემა უცნობია 4.

7
00:00:14,850 --> 00:00:18,480
დღეს იქნება შემოკლებით ლექცია რადგან არსებობს სპეციალური ღონისძიება აქ შემდგომ.

8
00:00:18,480 --> 00:00:21,940
ამიტომ ჩვენ მიიღოს peek და აჯავრებენ ორივე სტუდენტებისა და მშობლების მსგავსად დღეს

9
00:00:21,940 --> 00:00:24,600
ზოგიერთ რამ, რომლებიც ჰორიზონტზე.

10
00:00:24,600 --> 00:00:29,050
>> მათ შორის, როგორც ორშაბათს, ჩვენ კიდევ რამდენიმე თანაკლასელები.

11
00:00:29,050 --> 00:00:32,980
EDX, ჰარვარდის და MIT-ის ახალი ონლაინ ინიციატივას OpenCourseWare და მეტი,

12
00:00:32,980 --> 00:00:36,730
იწყებს on ჰარვარდის ს კამპუსში ორშაბათს, ე.ი. მოვა ორშაბათი

13
00:00:36,730 --> 00:00:40,930
მოგიწევთ, როგორც ბოლო მონაცემებით, 86.000 დამატებითი თანაკლასელები

14
00:00:40,930 --> 00:00:43,680
ვინ იქნება შემდეგ ერთად CS50-ს ლექციები და სექციები

15
00:00:43,680 --> 00:00:45,890
და walkthroughs და პრობლემა კომპლექტი.

16
00:00:45,890 --> 00:00:51,870
და, როგორც ნაწილი ამ, თქვენ წევრები გახდებიან დამფუძნებელი კლასი CS50 და ახლა CS50x.

17
00:00:51,870 --> 00:00:56,150
როგორც ნაწილი ამ ახლა, გააცნობიეროს, რომ იქნება გარკვეული upsides ისევე.

18
00:00:56,150 --> 00:01:00,620
მისაღებად მზად ამისათვის განკუთვნილი მასიური რაოდენობის სტუდენტები,

19
00:01:00,620 --> 00:01:03,820
საკმარისია ითქვას, რომ მიუხედავად იმისა, რომ ჩვენ გვაქვს 108 TFs და CAS,

20
00:01:03,820 --> 00:01:07,560
ეს არ საკმაოდ საუკეთესო სტუდენტი-მასწავლებელს კოეფიციენტი ერთხელ ჩვენ მოხვდა 80,000 სტუდენტების.

21
00:01:07,560 --> 00:01:09,830
ჩვენ არ ვაპირებთ უნდა შეფასების ამდენი პრობლემა ადგენს ხელით,

22
00:01:09,830 --> 00:01:13,050
ასე გააცნო კვირას პრობლემა კომპლექტი იქნება CS50 შემოწმება,

23
00:01:13,050 --> 00:01:15,410
რომელიც იქნება ბრძანება ხაზი კომუნალური ფარგლებში ელექტრო მოწყობილობების

24
00:01:15,410 --> 00:01:17,880
რომ თქვენ მიიღებთ ერთხელ თქვენ განაახლოთ იგი მოგვიანებით ამ კვირის.

25
00:01:17,880 --> 00:01:21,030
თქვენ გექნებათ აწარმოებს ბრძანება, check50, საკუთარ pset,

26
00:01:21,030 --> 00:01:24,770
და თქვენ მიიღებთ მყისიერი კავშირი იმის შესახებ თუ რამდენად თქვენი პროგრამის სწორია ან არასწორი

27
00:01:24,770 --> 00:01:27,980
შესაბამისად სხვადასხვა დიზაინის სპეციფიკაციები რომ ჩვენ გათვალისწინებული.

28
00:01:27,980 --> 00:01:30,310
უფრო, რომ პრობლემა კომპლექტი სპეციფიკაცია.

29
00:01:30,310 --> 00:01:34,220
CS50x თანაკლასელები იქნება გამოყენებისას ასევე.

30
00:01:34,220 --> 00:01:36,170
>> პრობლემა Set 4 არის ყველაფერი ექსპერტიზის,

31
00:01:36,170 --> 00:01:38,630
და ამ pset ნამდვილად შთაგონებული ზოგიერთი რეალურ ცხოვრებაში პერსონალის

32
00:01:38,630 --> 00:01:41,210
რის, როდესაც მე ვიყავი სკოლის მე სტაჟირება ხნით

33
00:01:41,210 --> 00:01:45,270
ერთად MIDDLESEX ქვეყნის რაიონული ადვოკატმა ოფისში აკეთებს სასამართლო მუშაობას

34
00:01:45,270 --> 00:01:47,660
მათი ტყვიის სასამართლო გამომძიებელი.

35
00:01:47,660 --> 00:01:50,280
რა ამ შეადგინა, როგორც ვფიქრობ, აღნიშნული რამდენიმე კვირის წარსულში,

36
00:01:50,280 --> 00:01:52,720
არის მასობრივი სახელმწიფო პოლიციის ან სხვა მოვიდოდა წელს,

37
00:01:52,720 --> 00:01:56,150
ისინი Drop off რამ, როგორიცაა მყარი დისკები და CD და ფლოპი დისკები და მოსწონს,

38
00:01:56,150 --> 00:01:58,770
და მაშინ მიზანი სასამართლო ექსპერტიზის ბიურო ადგენს

39
00:01:58,770 --> 00:02:01,470
არსებობდა თუ არა ან არ იყო მტკიცებულება გარკვეული.

40
00:02:01,470 --> 00:02:04,730
ეს იყო სპეციალურ გამოკვლევათა განყოფილება, ასე რომ თეთრი საყელო დანაშაული.

41
00:02:04,730 --> 00:02:10,949
ეს უფრო შემაშფოთებელი სახის დანაშაული, რაც ეხება რაღაც ციფრული მედია.

42
00:02:10,949 --> 00:02:16,450
თურმე არ არის, რომ ბევრი ადამიანი ვწერთ ელ სიტყვებით "მე ეს."

43
00:02:16,450 --> 00:02:20,490
ამიტომ ხშირად, ამ სასამართლო მოძებნილი არ ოჯახიდან ყველა რომ ბევრი რამ ხილი,

44
00:02:20,490 --> 00:02:22,820
მაგრამ ზოგჯერ ხალხი წერენ ასეთ წერილებს.

45
00:02:22,820 --> 00:02:25,240
ასე რომ, ზოგჯერ, ძალისხმევა დაჯილდოვდნენ.

46
00:02:25,240 --> 00:02:31,210
>> მაგრამ უხელმძღვანელოს მდე ამ სასამართლო pset, ჩვენ უნდა შემოღების წელს pset4 ცოტა გრაფიკა.

47
00:02:31,210 --> 00:02:35,410
თქვენ სავარაუდოდ ეს ყველაფერი თავისთავად ცხადად - JPEGs, GIFs და მოსწონს - ამ დღეებში.

48
00:02:35,410 --> 00:02:38,320
მაგრამ თუ მართლაც დაფიქრდით, გამოსახულება, ჰგავს რობ სახე,

49
00:02:38,320 --> 00:02:41,270
შეიძლება მოდელირებული როგორც თანმიმდევრობა წერტილების ან pixels.

50
00:02:41,270 --> 00:02:43,380
იმ შემთხვევაში, რობ სახე, არსებობს ყველა სახის ფერები,

51
00:02:43,380 --> 00:02:46,760
და დავიწყეთ ვხედავ ინდივიდუალური წერტილები, სხვაგვარად ცნობილია როგორც პიქსელი,

52
00:02:46,760 --> 00:02:48,610
ერთხელ დავიწყეთ zoom სისტემაში

53
00:02:48,610 --> 00:02:54,660
მაგრამ თუ ჩვენ გამარტივება მსოფლიოში ბიტიანი და უბრალოდ ვთქვა, რომ ეს აქ არის რობ შავი და თეთრი,

54
00:02:54,660 --> 00:02:57,490
წარმოადგინოს შავი და თეთრი, ჩვენ შეგვიძლია მხოლოდ გამოიყენოთ ორობითი.

55
00:02:57,490 --> 00:03:01,660
და თუ ჩვენ ვაპირებთ გამოვიყენოთ ორობითი, 1 ან 0, ჩვენ შეგვიძლია გამოვხატოთ ამ იმავე სახედ

56
00:03:01,660 --> 00:03:06,140
of Rob მისი მომღიმარი სახე ამ მაგალითზე ბიტი.

57
00:03:06,140 --> 00:03:12,100
11000011 წარმოადგენს თეთრი, თეთრი, შავი, შავი, შავი, შავი, თეთრი, თეთრი.

58
00:03:12,100 --> 00:03:16,150
და ამიტომ არ უზარმაზარი ნახტომი შემდეგ უნდა დაიწყოს ლაპარაკი ფერადი ფოტოსურათი,

59
00:03:16,150 --> 00:03:18,600
რამ, რომ ნეტავ ნახე Facebook ან მოახდინოს ციფრული კამერა.

60
00:03:18,600 --> 00:03:21,410
მაგრამ, რა თქმა უნდა, როდესაც საქმე ფერები, საჭიროა უფრო მეტი ბიტი.

61
00:03:21,410 --> 00:03:25,690
და საკმაოდ გავრცელებულია მსოფლიოს ფოტოები, გამოვიყენოთ არ 1-bit ფერი,

62
00:03:25,690 --> 00:03:29,560
როგორც ამ ვარაუდს, მაგრამ 24-bit ფერი, სადაც თქვენ რეალურად კიდევ მილიონობით ფერები.

63
00:03:29,560 --> 00:03:32,250
ასე რომ, როგორც იმ შემთხვევაში, როდესაც ჩვენ zoomed წელს რობ თვალი,

64
00:03:32,250 --> 00:03:36,370
რომ იყო ნებისმიერი რაოდენობის მილიონობით სხვადასხვა ფერად შესაძლებლობები.

65
00:03:36,370 --> 00:03:39,040
ამიტომ ჩვენ ამ თანამედროვე პრობლემების Set 4 ისევე როგორც walkthrough,

66
00:03:39,040 --> 00:03:43,370
რაც იქნება დღეს 3:30 ნაცვლად ჩვეულებრივი 2:30 გამო პარასკევის ლექცია აქ.

67
00:03:43,370 --> 00:03:46,620
მაგრამ ვიდეო იქნება ხაზზე როგორც ყოველთვის ხვალ.

68
00:03:46,620 --> 00:03:48,820
>> ჩვენ ასევე წარმოგიდგინოთ სხვა ფაილის ფორმატი.

69
00:03:48,820 --> 00:03:51,270
ეს განზრახ ნიშნავდა თვალი დაშინებას თავდაპირველად,

70
00:03:51,270 --> 00:03:55,670
მაგრამ ეს მხოლოდ ზოგიერთ დოკუმენტაცია C struct.

71
00:03:55,670 --> 00:03:58,940
თურმე Microsoft წლის წინ დაეხმარა პოპულარიზაცია ამ ფორმატში

72
00:03:58,940 --> 00:04:05,150
მოუწოდა Bitmap ფაილის ფორმატი, BMP, და ეს იყო სუპერ მარტივია, ფერადი გრაფიკული ფაილის ფორმატი

73
00:04:05,150 --> 00:04:10,150
რომელიც გამოიყენება საკმაოდ გარკვეული დრო და ზოგჯერ მაინც ამისთვის ფონები on კომპიუტერები.

74
00:04:10,150 --> 00:04:14,760
თუ ფიქრობთ თავში Windows XP და მოძრავი ბორცვები და ლურჯი ცა,

75
00:04:14,760 --> 00:04:17,170
რომ იყო ტიპიურად bmp ან Bitmap image.

76
00:04:17,170 --> 00:04:19,959
Bitmaps არიან fun ჩვენთვის, რადგან მათ უფრო მეტი სირთულის.

77
00:04:19,959 --> 00:04:22,610
ეს არ არის საკმაოდ მარტივია, როგორც ამ ქსელში 0S და 1s.

78
00:04:22,610 --> 00:04:27,510
ამის ნაცვლად, თქვენ გაქვთ რამ, როგორიცაა header დაწყების ფაილი.

79
00:04:27,510 --> 00:04:31,990
ასე რომ, სხვა სიტყვებით, შიგნით. Bmp ფაილი მთელი bunch of 0S და 1s,

80
00:04:31,990 --> 00:04:34,910
მაგრამ არსებობს რამდენიმე დამატებითი 0S და 1s იქ.

81
00:04:34,910 --> 00:04:38,220
და აღმოჩნდება, რომ ის, რაც ჩვენ, ალბათ მიღებული გაიცემა წლის -

82
00:04:38,220 --> 00:04:45,170
ფაილის ფორმატში. doc ან. XLS ან. mp3. mp4, რაც ფორმატის

83
00:04:45,170 --> 00:04:48,480
რომ თქვენ იცნობს - რას კი ნიშნავს ფაილის ფორმატი,

84
00:04:48,480 --> 00:04:52,480
იმიტომ, დღის ბოლოს ყველა ეს ფაილი გამოიყენება მხოლოდ 0S და 1s.

85
00:04:52,480 --> 00:04:56,810
და იქნებ იმ 0S და 1s წარმოადგენს ABC მეშვეობით ASCII ან მოსწონს,

86
00:04:56,810 --> 00:04:58,820
მაგრამ დღის ბოლოს, ის მაინც მხოლოდ 0S და 1s.

87
00:04:58,820 --> 00:05:02,100
ასე რომ ადამიანები უბრალოდ ზოგჯერ გადაწყვეტენ გამოგონება ახალი ფაილის ფორმატი

88
00:05:02,100 --> 00:05:06,420
სადაც ისინი standardize რა ნიმუში ბიტი რომელიც რეალურად ნიშნავს.

89
00:05:06,420 --> 00:05:09,220
და ამ შემთხვევაში აქ, დაკარგულია შექმნილია Bitmap ფაილის ფორმატი

90
00:05:09,220 --> 00:05:15,620
განაცხადა, რომ პირველივე byte წელს Bitmap ფაილი, როგორც აღნიშნა მიერ ოფსეტური 0 იქ,

91
00:05:15,620 --> 00:05:18,940
იქ იქნება გარკვეული cryptically დაასახელა ცვლადში bfType,

92
00:05:18,940 --> 00:05:23,080
რომელიც მხოლოდ დგას Bitmap ფაილის ტიპი, რა ტიპის Bitmap ფაილი ამ.

93
00:05:23,080 --> 00:05:27,700
შეგიძლიათ infer ალბათ მეორე რიგის, რომ ოფსეტური 2, byte ნომერი 2,

94
00:05:27,700 --> 00:05:33,740
აქვს ნიმუში 0S და 1s, რომელიც წარმოადგენს რა? ზომა რაღაც.

95
00:05:33,740 --> 00:05:35,310
და ეს გრძელდება იქიდან.

96
00:05:35,310 --> 00:05:37,410
ასე რომ პრობლემა Set 4, თქვენ უნდა ფეხით ისეირნა ზოგიერთი რამ.

97
00:05:37,410 --> 00:05:39,520
ჩვენ არ დასრულდება მდე ზრუნვა ყველა მათგანი.

98
00:05:39,520 --> 00:05:47,510
მაგრამ შენიშნავს იწყება მიიღოს საინტერესო გარშემო byte 54: rgbtBlue, მწვანე, და წითელი.

99
00:05:47,510 --> 00:05:52,110
თუ თქვენ ოდესმე მსმენია აბრევიატურა RGB - წითელი, მწვანე, ლურჯი - ეს არის მინიშნება, რომ

100
00:05:52,110 --> 00:05:54,610
რადგან თურმე შეგიძლიათ ხატავს ყველა ფერის Rainbow

101
00:05:54,610 --> 00:05:58,180
ზოგიერთი კომბინაცია წითელი და ლურჯი და მწვანე.

102
00:05:58,180 --> 00:06:03,320
ფაქტია, მშობლები ოთახში შეიძლება გავიხსენოთ ზოგიერთი ადრეული პროექტორები.

103
00:06:03,320 --> 00:06:05,890
ამ დღეებში, უბრალოდ ვხედავ ერთი ნათელი შუქი გამოდის ობიექტივი,

104
00:06:05,890 --> 00:06:09,800
მაგრამ უკან დღეში გქონდათ წითელი ობიექტივი, ლურჯი ლინზები, და მწვანე ლინზები,

105
00:06:09,800 --> 00:06:13,380
და ერთად ისინი მიზნად ისახავს ეკრანზე და ჩამოყალიბდა ფერადი სურათი.

106
00:06:13,380 --> 00:06:16,270
და საკმაოდ ხშირად, შუა სკოლებსა და უმაღლეს სასწავლებლებში ექნება იმ ლინზები

107
00:06:16,270 --> 00:06:19,720
ოდესმე ისე ოდნავ askew, ასე რომ თქვენ იყო ერთგვარი ხედავს ორმაგი ან სამმაგი images.

108
00:06:19,720 --> 00:06:24,100
მაგრამ ეს იყო იდეა. თქვენ ჰქონდა წითელი და მწვანე და ლურჯი შუქი ხატავდა სურათს.

109
00:06:24,100 --> 00:06:26,590
და რომ იგივე პრინციპი გამოიყენება კომპიუტერებს.

110
00:06:26,590 --> 00:06:30,230
>> ამიტომ შორის გამოწვევები მაშინ თქვენთვის პრობლემა Set 4 ვაპირებთ იყოს ცოტა რამ.

111
00:06:30,230 --> 00:06:34,800
ერთი არის რეალურად შეცვლის გამოსახულება, მიიღოს in ნიმუში 0S და 1s,

112
00:06:34,800 --> 00:06:40,200
გაერკვნენ, რომელიც მოცულობით 0S და 1s წარმოადგენენ რა სტრუქტურის მსგავსად,

113
00:06:40,200 --> 00:06:43,630
და შემდეგ გაერკვნენ, თუ როგორ უნდა replicate პიქსელი - Reds, ბლუზის, მწვანილი -

114
00:06:43,630 --> 00:06:46,660
შიგნით, ისე, რომ როდესაც სურათს ასე გამოიყურება თავდაპირველად,

115
00:06:46,660 --> 00:06:49,210
ეს შესაძლოა ასე გამოიყურება ნაცვლად ამის შემდეგ.

116
00:06:49,210 --> 00:06:53,640
შორის სხვა გამოწვევები ძალიან იქნება, რომ თქვენ უნდა გადასცეს სასამართლო გამოსახულება

117
00:06:53,640 --> 00:06:56,030
საქართველოს ფაქტობრივი ფაილი ციფრული კამერა.

118
00:06:56,030 --> 00:06:58,960
და რომ კამერა, ერთხელ, იყო მთელი bunch of ფოტო.

119
00:06:58,960 --> 00:07:03,760
პრობლემა ჩვენ შემთხვევით წაშლილია ან ჰქონდა გამოსახულება დაზიანებულია როგორღაც.

120
00:07:03,760 --> 00:07:05,750
ცუდი რამ მოხდეს ციფრული ფოტოკამერები.

121
00:07:05,750 --> 00:07:09,150
და ამიტომ ჩვენ სწრაფად გადაწერა ყველა 0S და 1s გამორთვა რომ ბარათი თქვენ,

122
00:07:09,150 --> 00:07:13,610
გადაარჩინა მათ ყველა ერთ დიდი ფაილი, და მაშინ საბოლოოდ დავრწმუნდებით გადასცემს მათ თქვენთვის პრობლემა უცნობია 4

123
00:07:13,610 --> 00:07:19,320
ასე რომ, თქვენ შეგიძლიათ დაწეროთ პროგრამა C რომელთანაც ფეხზე ყველა იმ JPEGs, იდეალურად.

124
00:07:19,320 --> 00:07:23,330
და აღმოჩნდება, რომ JPEGs, მიუხედავად იმისა, რომ ისინი გარკვეულწილად კომპლექსური ფაილის ფორმატი -

125
00:07:23,330 --> 00:07:26,360
ისინი ბევრად უფრო რთული, ვიდრე ეს მომღიმარი სახე აქ -

126
00:07:26,360 --> 00:07:31,160
აღმოჩნდება, რომ ყველა JPEG იწყება იგივე ნიმუში 0S და 1s.

127
00:07:31,160 --> 00:07:35,630
ასე გამოყენებით, საბოლოოდ, ხოლო მარყუჟი ან ამისთვის მარყუჟი ან მსგავსი,

128
00:07:35,630 --> 00:07:38,880
შეგიძლიათ iterate ყველა 0S და 1s ამ სასამართლო გამოსახულება,

129
00:07:38,880 --> 00:07:43,150
და ყოველ ჯერზე ხედავთ სპეციალური ნიმუში რომ განსაზღვრული პრობლემა კომპლექტი სპეციფიკაცია,

130
00:07:43,150 --> 00:07:47,880
თქვენ შეიძლება ვივარაუდოთ, აქ არის, ძალიან დიდი ალბათობით, დაწყების JPEG.

131
00:07:47,880 --> 00:07:51,230
და როგორც კი შეამჩნევთ იგივე ნიმუში გარკვეული რაოდენობის ბაიტი

132
00:07:51,230 --> 00:07:55,430
ან kilobytes ან მეგაბაიტები შემდეგ თქვენ შეიძლება ვივარაუდოთ, აქ არის მეორე JPEG,

133
00:07:55,430 --> 00:07:57,380
ფოტო ავიღე შემდეგ პირველი.

134
00:07:57,380 --> 00:08:01,370
ნება მომეცით შეჩერება კითხულობს, რომ პირველი ფაილი, წერა ამ ახლის,

135
00:08:01,370 --> 00:08:06,310
და გამომავალი თქვენი პროგრამის pset4 იქნება, როგორც ბევრი როგორც 50 JPEGs.

136
00:08:06,310 --> 00:08:09,270
და თუ ეს ასე არ არის 50 JPEGs, თქვენ გაქვთ ცოტა loop.

137
00:08:09,270 --> 00:08:12,490
თუ თქვენ გაქვთ უსასრულო რაოდენობის JPEGs, თქვენ გაქვთ უსასრულო ციკლი.

138
00:08:12,490 --> 00:08:14,910
ასე რომ ძალიან იქნება საკმაოდ გავრცელებული შემთხვევა.

139
00:08:14,910 --> 00:08:16,600
ასე რომ რა ჰორიზონტზე.

140
00:08:16,600 --> 00:08:21,310
>> Quiz 0 ჩვენს უკან, გააცნობიეროს თითო ჩემი ელ რომ უცვლელად არსებობს დაკარგულია ორივე ბედნიერი,

141
00:08:21,310 --> 00:08:23,640
სახის ნეიტრალური, და სამწუხარო გარშემო ვიქტორინა 0 დრო.

142
00:08:23,640 --> 00:08:26,800
და გთხოვთ, ნუ მივაწვდინოთ ჩემთვის, უფროსი TF Zamyla, თქვენი საკუთარი TF,

143
00:08:26,800 --> 00:08:31,180
ან ერთი CAS რომ თქვენ იცით, თუ გსურთ განიხილავს, თუ როგორ წავიდა.

144
00:08:31,180 --> 00:08:35,539
>> ასე რომ შთაბეჭდილების მშობლები აქ ოთახში, რა არის CS50 ბიბლიოთეკა?

145
00:08:36,429 --> 00:08:40,390
[სიცილის] კარგად იმუშავა.

146
00:08:40,390 --> 00:08:48,340
რა არის CS50 ბიბლიოთეკა? Yeah. >> [სტუდენტი] ეს წინასწარი წერილობითი კომპლექტი კოდი [inaudible]

147
00:08:48,340 --> 00:08:49,750
Okay, კარგი.

148
00:08:49,750 --> 00:08:53,240
ეს წინასწარი წერილობითი კომპლექტი კოდი, რომ ჩვენ თანამშრომლებს წერდა, ჩვენ უზრუნველყოფს თქვენ,

149
00:08:53,240 --> 00:08:55,030
რომელიც უზრუნველყოფს ზოგიერთი საერთო ფუნქციონალური,

150
00:08:55,030 --> 00:08:59,020
პერსონალის მოსწონს get me სიმებიანი, get me int - ყველა ფუნქციებს, რომლებიც აქ ჩამოთვლილი.

151
00:08:59,020 --> 00:09:02,260
>> დაწყებული ახლა ჩვენ დავიწყებთ ნამდვილად მიიღოს ამ სასწავლო თვლები off.

152
00:09:02,260 --> 00:09:05,050
ჩვენ ვაპირებთ დავიწყოთ წართმევას სიმებიანი თქვენგან,

153
00:09:05,050 --> 00:09:08,870
რომელიც გაწვევას იყო სინონიმი რა ფაქტობრივი მონაცემების ტიპის? >> [მრავალჯერადი სტუდენტებს] ჩარ *.

154
00:09:08,870 --> 00:09:12,730
ჩარ *. მშობლებისთვის, რომ იყო ალბათ [ხდის whooshing sound]. ეგ კარგია.

155
00:09:12,730 --> 00:09:17,550
ჩარ * დავიწყებთ, რათა ეკრანზე უფრო როგორც ჩვენ ამოიღონ სიმებიანი ჩვენი ლექსიკა,

156
00:09:17,550 --> 00:09:19,730
მინიმუმ როდესაც საქმე რეალურად წერა კოდი.

157
00:09:19,730 --> 00:09:22,840
ანალოგიურად, ჩვენ შეწყვიტოს გამოყენებით ზოგიერთი ფუნქციების იმდენი

158
00:09:22,840 --> 00:09:25,280
რადგან ჩვენი პროგრამების ვაპირებთ კიდევ უფრო დახვეწილი.

159
00:09:25,280 --> 00:09:28,480
და არა მხოლოდ წერენ პროგრამებს, იჯდეს იქ სწრაფი მოციმციმე,

160
00:09:28,480 --> 00:09:31,870
ელოდება მომხმარებელს აკრიფოთ რაღაც, თქვენ შეძლებთ თქვენი საშუალებებით საწყისი სხვაგან.

161
00:09:31,870 --> 00:09:35,490
მაგალითად, თქვენ შეძლებთ მათ სერია ბიტი ადგილობრივ ხისტ დისკზე.

162
00:09:35,490 --> 00:09:38,580
თქვენ ნაცვლად მიიღონ მათ მომავალში საწყისი ქსელის კავშირი,

163
00:09:38,580 --> 00:09:40,230
ზოგიერთი ნახვა სადღაც.

164
00:09:40,230 --> 00:09:44,110
>> მოდით კანი უკან ამ ფენას პირველად და გაიყვანოს up CS50 ელექტრო მოწყობილობების

165
00:09:44,110 --> 00:09:49,010
და ეს ფაილი სახელად cs50.h, რომელიც თქვენ უკვე # ჩათვლით კვირების განმავლობაში,

166
00:09:49,010 --> 00:09:51,140
მაგრამ მოდით რეალურად ხედავთ რა შიგნით ამ.

167
00:09:51,140 --> 00:09:54,430
ზევით ფაილის ლურჯი მხოლოდ მთელი bunch of კომენტარები:

168
00:09:54,430 --> 00:09:57,050
გარანტია ინფორმაცია და ლიცენზირებას.

169
00:09:57,050 --> 00:09:59,050
ეს არის ერთგვარი საერთო პარადიგმის პროგრამული უზრუნველყოფა

170
00:09:59,050 --> 00:10:01,580
რადგან ბევრი პროგრამული უზრუნველყოფის ამ დღეებში რასაც ღია წყაროებიდან,

171
00:10:01,580 --> 00:10:05,220
რაც იმას ნიშნავს, რომ ვიღაცას არ გაუკეთებია კოდი და გახადა უფასოა

172
00:10:05,220 --> 00:10:10,470
არა მხოლოდ გასაშვებად და გამოიყენოს მაგრამ რეალურად წაიკითხა და შეცვალოს და ინტეგრაციას საკუთარ სამუშაოს.

173
00:10:10,470 --> 00:10:14,660
ასე რომ სწორედ ეს თქვენ უკვე გამოყენებით, ღია პროგრამული, თუმცა ძალიან მცირე ფორმით.

174
00:10:14,660 --> 00:10:18,560
თუ მე გადახვევა ქვემოთ წარსულში კომენტარი, თუმცა, დავიწყებთ რამდენიმე უფრო ნაცნობი რამ.

175
00:10:18,560 --> 00:10:25,010
Notice ზედა აქ რომ cs50.h ფაილი მოიცავს მთელი bunch of header ფაილი.

176
00:10:25,010 --> 00:10:28,560
ყველაზე ამ, ჩვენ არ მინახავს ადრე, მაგრამ ერთი კარგად იცნობს.

177
00:10:28,560 --> 00:10:32,270
ჩამოთვლილთაგან რომელი არ ჩვენ ვხედავთ, თუმცა მოკლედ, ჯერჯერობით? >> [სტუდენტი] სტანდარტული ბიბლიოთეკა.

178
00:10:32,270 --> 00:10:35,810
ჰო, სტანდარტულ ბიბლიოთეკაში. stdlib.h აქვს malloc.

179
00:10:35,810 --> 00:10:38,320
ერთხელ ჩვენ ალაპარაკდა დინამიური მეხსიერების გამოყოფის,

180
00:10:38,320 --> 00:10:41,650
რაც ჩვენ დაბრუნდება მომავალ კვირას ასევე დავიწყეთ მათ შორის ფაილი.

181
00:10:41,650 --> 00:10:46,640
თურმე bool და ჭეშმარიტი და ყალბი არ რეალურად არსებობს C თავისთავად

182
00:10:46,640 --> 00:10:49,440
თუ თქვენ მოიცავს ამ ფაილის აქ.

183
00:10:49,440 --> 00:10:52,710
ჩვენ კვირების განმავლობაში იყო მათ შორის stdbool.h

184
00:10:52,710 --> 00:10:55,620
ასე რომ თქვენ შეგიძლიათ გამოიყენოთ ცნება bool, ჭეშმარიტი ან მცდარი.

185
00:10:55,620 --> 00:10:58,620
ამის გარეშე, თქვენ უნდა დაალაგოთ ფალსიფიცირებული და გამოიყენოთ int

186
00:10:58,620 --> 00:11:02,610
და მხოლოდ თვითნებურად ვივარაუდოთ, რომ 0 არის ყალბი და 1 მართალია.

187
00:11:02,610 --> 00:11:07,150
თუ ჩვენ გადახვევა ქვემოთ შემდგომი, აქ არის ჩვენი დეფინიცია სიმებიანი.

188
00:11:07,150 --> 00:11:11,390
თურმე, როგორც ჩვენ დაწყებამდე განაცხადა, რომ სადაც ეს ვარსკვლავი არის ნამდვილად არ აქვს.

189
00:11:11,390 --> 00:11:13,720
თქვენ კი აქვს სივრცის გარშემო.

190
00:11:13,720 --> 00:11:16,740
ჩვენ ამ სემესტრში უკვე ხელშეწყობა, როგორც ეს ნათლად

191
00:11:16,740 --> 00:11:18,620
რომ ვარსკვლავი არ უკავშირდება ტიპის,

192
00:11:18,620 --> 00:11:21,700
მაგრამ რეალიზება ისევე როგორც საერთო, თუ არ უფრო საერთო,

193
00:11:21,700 --> 00:11:24,430
არის დააყენოს ის არსებობს, მაგრამ ფუნქციურად ეს იგივე.

194
00:11:24,430 --> 00:11:27,720
მაგრამ ახლა თუ ვკითხულობთ ქვემოთ შემდგომი, მოდით შევხედოთ GetInt

195
00:11:27,720 --> 00:11:32,190
რადგან ჩვენ გამოიყენება, რომ შესაძლოა პირველ ადრე არაფერი ამ სემესტრში.

196
00:11:32,190 --> 00:11:37,440
აქ არის GetInt. ეს არის რა? >> [სტუდენტი] პროტოტიპი. >> ეს არის მხოლოდ პროტოტიპი.

197
00:11:37,440 --> 00:11:41,410
ხშირად, ჩვენ დააყენა პროტოტიპები დროს დაპყრობა ჩვენი. გ ფაილი

198
00:11:41,410 --> 00:11:46,690
მაგრამ თქვენ შეგიძლიათ დააყენა პროტოტიპები in header ფაილი. თ ფაილი, როგორც ეს ერთი აქ

199
00:11:46,690 --> 00:11:50,840
ასე რომ როდესაც წერთ ზოგიერთი ფუნქციების რომ გსურთ სხვა ხალხს შეძლებს გამოიყენოს,

200
00:11:50,840 --> 00:11:53,550
სწორედ საქმე CS50 ბიბლიოთეკა,

201
00:11:53,550 --> 00:11:57,040
თქვენ არა მხოლოდ განახორციელოს თქვენი ფუნქციების რაღაც cs50.c,

202
00:11:57,040 --> 00:12:02,790
თქვენ ასევე დააყენა პროტოტიპები არ ზედა რომ ფაილის მაგრამ ზედა header ფაილი.

203
00:12:02,790 --> 00:12:07,170
მაშინ რომ header ფაილი რა მეგობრებისა და კოლეგების მოიცავს

204
00:12:07,170 --> 00:12:09,760
ერთად # მოიცავს საკუთარ კოდი.

205
00:12:09,760 --> 00:12:12,210
ასე რომ მთელი ამ ხნის, თქვენ უკვე მათ შორის ყველა ამ პროტოტიპების,

206
00:12:12,210 --> 00:12:16,580
ეფექტურად ზედა თქვენი ფაილის მაგრამ გზით ამ # მოიცავს მექანიზმი,

207
00:12:16,580 --> 00:12:20,070
რომელიც არსებითად ასლები და პასტები ამ ფაილის შევიდა საკუთარი.

208
00:12:20,070 --> 00:12:23,070
აქ არის რამდენიმე საკმაოდ დეტალური დოკუმენტაცია.

209
00:12:23,070 --> 00:12:25,640
ჩვენ საკმაოდ ბევრი მიღებული მიანიჭა, რომ GetInt იღებს int,

210
00:12:25,640 --> 00:12:27,640
მაგრამ აღმოჩნდება, რომ არსებობს კუთხეში შემთხვევებში.

211
00:12:27,640 --> 00:12:31,810
რა მოხდება, თუ მომხმარებლის ტიპების ხმების რომ გზა ძალიან დიდია, quintillion,

212
00:12:31,810 --> 00:12:35,490
რომ უბრალოდ ვერ ჯდება შიგნით int? რა არის მოსალოდნელი ქცევა?

213
00:12:35,490 --> 00:12:38,020
იდეალურ შემთხვევაში, ეს პროგნოზირებადი.

214
00:12:38,020 --> 00:12:40,280
ასე რომ, ამ შემთხვევაში, თუ თქვენ ნამდვილად წაიკითხა ჯარიმა ბეჭდვითი,

215
00:12:40,280 --> 00:12:44,500
თქვენ რეალურად ვხედავთ, რომ თუ ხაზი არ იკითხება, ამ ბრუნდება INT_MAX.

216
00:12:44,500 --> 00:12:48,320
ჩვენ არასდროს არ ისაუბრა, თუმცა ეფუძნება მის კაპიტალიზაცია, რა არის ეს, ალბათ?

217
00:12:48,320 --> 00:12:50,640
[სტუდენტი] მუდმივი. >> ეს მუდმივი.

218
00:12:50,640 --> 00:12:54,770
ეს რაღაც განსაკუთრებული მუდმივი რომ ალბათ განაცხადა ერთ იმ header ფაილი

219
00:12:54,770 --> 00:13:00,090
რომ up მაღალია ფაილი, და INT_MAX ალბათ რაღაც უხეშად 2 მილიარდ

220
00:13:00,090 --> 00:13:04,990
იდეა მყოფი რომ რადგან ჩვენ გვჭირდება, რათა როგორმე ნიშნავდეს, რომ რაღაც არ მოხდა ისე,

221
00:13:04,990 --> 00:13:10,700
ჩვენ, დიახ, აქვს 4 მილიარდი ნომრები ჩვენს ხელთ არსებული: -2 მილიარდი მდე 2 მილიარდი, მისცეს ან მიიღოს.

222
00:13:10,700 --> 00:13:14,710
ისე, რა არის საერთო პროგრამირებაში არის თქვენ მოიპაროს მხოლოდ ერთი იმ ნომრებს,

223
00:13:14,710 --> 00:13:18,920
იქნებ 0, იქნებ 2 მილიარდი, იქნებ -2 მილიარდ

224
00:13:18,920 --> 00:13:23,280
ასე რომ თქვენ ხარჯავთ ერთი თქვენი შესაძლო მნიშვნელობებია ასე რომ თქვენ შეგიძლიათ ჩაიდინოს მსოფლიოს

225
00:13:23,280 --> 00:13:26,820
რაიმე რომ მიდის არასწორი, მე დაბრუნდება ამ სუპერ დიდი მნიშვნელობა.

226
00:13:26,820 --> 00:13:31,030
მაგრამ არ გსურთ მომხმარებლის აკრეფით რაღაც cryptic მოსწონს 234 ..., მართლაც დიდი რაოდენობის.

227
00:13:31,030 --> 00:13:34,060
თქვენ განზოგადება ის ნაცვლად, როგორც მუდმივი.

228
00:13:34,060 --> 00:13:38,060
ასე ნამდვილად, თუ თქვენ მიმდინარეობდა anal ბოლო რამდენიმე კვირის განმავლობაში, ნებისმიერ დროს მოუწოდა GetInt,

229
00:13:38,060 --> 00:13:42,900
თქვენ უნდა ყოფილიყო შემოწმების ერთად, თუ მდგომარეობა გააკეთეს მომხმარებლის ტიპის INT_MAX,

230
00:13:42,900 --> 00:13:46,590
ან, უფრო კონკრეტულად კი, არ GetInt დაბრუნების INT_MAX, რადგან თუ ეს მოხდა,

231
00:13:46,590 --> 00:13:51,830
რომ რეალურად ნიშნავს, რომ ისინი არ აკრიფოთ იგი. რაღაც მოხდა ისე ამ შემთხვევაში.

232
00:13:51,830 --> 00:13:56,080
ასე რომ, ეს რა საყოველთაოდ ცნობილია, როგორც Sentinel ღირებულებით, რაც მხოლოდ იმას ნიშნავს, სპეციალური.

233
00:13:56,080 --> 00:13:58,120
>> მოდით ახლა იქცეს. გ ფაილი.

234
00:13:58,120 --> 00:14:01,340
C ფაილის არსებობდა ელექტრო გარკვეული დროის განმავლობაში.

235
00:14:01,340 --> 00:14:06,840
და ფაქტობრივად, ელექტრო აქვს წინასწარ შედგენილი თქვენთვის შევიდა, რომ რამ ჩვენ მოუწოდა ობიექტის კოდი,

236
00:14:06,840 --> 00:14:09,540
მაგრამ ეს უბრალოდ არ აქვს მნიშვნელობა თქვენ სადაც რადგან სისტემა იცის

237
00:14:09,540 --> 00:14:11,730
ამ შემთხვევაში, სადაც ეს არის: ელექტრო მოწყობილობების.

238
00:14:11,730 --> 00:14:17,400
მოდით გადახვევა ქვემოთ ახლა GetInt და ვნახავთ, როგორ GetInt მუშაობს ყველა ამ დროს.

239
00:14:17,400 --> 00:14:19,460
აქ მსგავსი კომენტარები წინაშე.

240
00:14:19,460 --> 00:14:21,660
ნება მომეცით დიდი ზომით უბრალოდ კოდი ნაწილი.

241
00:14:21,660 --> 00:14:23,900
და რა გვაქვს ამისთვის GetInt ასეთია.

242
00:14:23,900 --> 00:14:25,700
იგი იღებს არ შეყვანის.

243
00:14:25,700 --> 00:14:29,510
ის დააბრუნებს int, ხოლო (ნამდვილი), ამიტომ ჩვენ გვაქვს მიზანმიმართულ უსასრულო ციკლი,

244
00:14:29,510 --> 00:14:33,180
მაგრამ სავარაუდოდ ჩვენ შესვენება აქედან როგორღაც ან დაბრუნების შიგნიდან ამ.

245
00:14:33,180 --> 00:14:34,870
>> ვნახოთ, როგორ ეს სამუშაოები.

246
00:14:34,870 --> 00:14:39,240
ჩვენ როგორც ჩანს გამოყენებით GetString ამ პირველი ხაზი შიგნით მარყუჟის, 166.

247
00:14:39,240 --> 00:14:43,780
ეს არის კარგი პრაქტიკა, რადგან თუ რა გარემოებებში შეიძლება GetString დაბრუნდნენ

248
00:14:43,780 --> 00:14:47,660
სპეციალური სიტყვით NULL? >> [სტუდენტი] თუ რამე მიდის არასწორი.

249
00:14:47,660 --> 00:14:51,630
თუ რამე მიდის არასწორი. და რა შეიძლება გადასვლა არასწორი როცა რეკავთ რაღაც GetString?

250
00:14:54,960 --> 00:14:57,640
Yeah. >> [სტუდენტი] Malloc ვერ მისცეს მას ints.

251
00:14:57,640 --> 00:14:59,150
Yeah. იქნებ malloc ვერ.

252
00:14:59,150 --> 00:15:03,190
სადღაც ქვეშ Hood, GetString მოუწოდებს malloc, რომელიც გამოყოფს მეხსიერება,

253
00:15:03,190 --> 00:15:06,020
რომელიც საშუალებას კომპიუტერულ მაღაზიაში ყველა გმირები

254
00:15:06,020 --> 00:15:07,750
რომ მომხმარებლის ტიპის შევიდა კლავიატურაზე.

255
00:15:07,750 --> 00:15:11,590
და ვარაუდობენ მომხმარებლის ჰქონდა მთელი ბევრი თავისუფალი დრო და აკრეფილი მეტი, მაგალითად,

256
00:15:11,590 --> 00:15:16,160
ვიდრე 2 მილიარდი სიმბოლოების, უფრო გმირები, ვიდრე კომპიუტერში კი აქვს RAM.

257
00:15:16,160 --> 00:15:19,250
GetString უნდა შეძლებს ნიშნავდეს, რომ თქვენ.

258
00:15:19,250 --> 00:15:22,560
მაშინაც კი, თუ ეს არის სუპერ, სუპერ იშვიათია კუთხეში შემთხვევაში,

259
00:15:22,560 --> 00:15:24,340
მას, რათა როგორმე შეძლებს გაუმკლავდეს ამ,

260
00:15:24,340 --> 00:15:28,750
და ასე GetString, თუ წავედით უკან და წაიკითხეთ მისი დოკუმენტაცია, აქვს რეალურად დაბრუნების null.

261
00:15:28,750 --> 00:15:34,460
ახლა თუ ვერ GetString მიერ დაბრუნების NULL, GetInt აპირებს ვერ მიერ დაბრუნების INT_MAX

262
00:15:34,460 --> 00:15:37,690
ისევე როგორც Sentinel. ეს არის უბრალოდ ადამიანის კონვენციებს.

263
00:15:37,690 --> 00:15:41,450
ერთადერთი გზა თქვენ ამას, რომ ეს არის საქმე, რომელსაც კითხულობს დოკუმენტაცია.

264
00:15:41,450 --> 00:15:45,040
>> მოდით გადახვევა ქვემოთ სადაც int ფაქტობრივად მიღებული.

265
00:15:45,040 --> 00:15:51,160
თუ მე გადახვევა ქვემოთ bit შემდგომი, შეესაბამება 170, გვაქვს კომენტარის ზემოთ აღნიშნული ხაზები.

266
00:15:51,160 --> 00:15:55,100
ჩვენ განაცხადოს 172 int, N, და char, C, და შემდეგ ამ ახალ ფუნქციას,

267
00:15:55,100 --> 00:15:58,930
რაც ზოგიერთი თქვენ stumbled მასშტაბით ადრე, sscanf.

268
00:15:58,930 --> 00:16:00,870
ეს დგას სიმებიანი scanf.

269
00:16:00,870 --> 00:16:05,700
სხვა სიტყვებით, მომეცი სიმებიანი და მე იქნება სკანირების ეს დარტყმები ინფორმაციის ინტერესის.

270
00:16:05,700 --> 00:16:07,360
რას ნიშნავს ეს?

271
00:16:07,360 --> 00:16:11,800
დავუშვათ, რომ მე აკრიფოთ, სიტყვასიტყვით, 123 ზე კლავიატურის და შემდეგ დააჭიროთ.

272
00:16:11,800 --> 00:16:16,470
რა არის მონაცემები გაცნობის 123 როდესაც დაბრუნდა მიერ GetString? >> [სტუდენტი] სიმებიანი.

273
00:16:16,470 --> 00:16:18,380
ეს აშკარად სტრიქონს, არა? მე მივიღე სიმებიანი.

274
00:16:18,380 --> 00:16:23,220
ასე რომ 123 მართლაც, ციტირებით-unquote, 123 ერთად \ 0 მიწურულს იგი.

275
00:16:23,220 --> 00:16:27,110
ეს არ არის int. ეს არ არის რიცხვი. როგორც ჩანს ხმების მაგრამ არა რეალურად.

276
00:16:27,110 --> 00:16:29,080
რას GetInt უნდა გავაკეთოთ?

277
00:16:29,080 --> 00:16:35,750
მას აქვს სკანირების რომ სიმებიანი მარცხნიდან მარჯვნივ - 123 \ 0 - და რატომღაც კონვერრტაციისთვის ფაქტობრივი რიცხვი.

278
00:16:35,750 --> 00:16:37,850
თქვენ შეიძლება გაერკვნენ, თუ როგორ უნდა გავაკეთოთ ეს.

279
00:16:37,850 --> 00:16:41,450
თუ ფიქრობთ თავში pset2, თქვენ სავარაუდოდ მიიღო პატარა კომფორტულად Caesar

280
00:16:41,450 --> 00:16:44,820
ან Vigenere, ასე რომ თქვენ შეგიძლიათ iterate მეტი ტექსტი, თქვენ შეგიძლიათ დააკონვერტიროთ chars to ints.

281
00:16:44,820 --> 00:16:46,710
მაგრამ heck, ეს მთელი ბევრი სამუშაოა.

282
00:16:46,710 --> 00:16:49,860
რატომ არ გამოიძახა ფუნქცია, როგორიცაა sscanf რომ აკეთებს, რომ თქვენთვის?

283
00:16:49,860 --> 00:16:54,230
ამიტომ sscanf მოელის არგუმენტი - ამ შემთხვევაში მოუწოდა ხაზი, რომელიც სიმებიანი.

284
00:16:54,230 --> 00:17:01,840
მაშინ მოცემული შეთავაზებები, ძალიან ჰგავს printf, რას მოველით, რომ ნახოთ ამ სიმებიანი.

285
00:17:01,840 --> 00:17:09,000
და რა მე ვამბობ, აქ მე მოველი, რომ ნახოთ ათობითი ნომერი და იქნებ ხასიათი.

286
00:17:09,000 --> 00:17:12,000
და ვნახავთ, თუ რატომ არის ამ შემთხვევაში რაღაც მომენტში.

287
00:17:12,000 --> 00:17:15,869
და აღმოჩნდება, რომ ამ ნოტაცია არის თქვენში პერსონალის ჩვენ ალაპარაკდა

288
00:17:15,869 --> 00:17:17,619
მხოლოდ ერთი კვირის წინ.

289
00:17:17,619 --> 00:17:21,740
რა არის & n და & C აკეთებს ჩვენთვის აქ? >> [სტუდენტი] მისამართი N და მისამართი გ.

290
00:17:21,740 --> 00:17:25,400
Yeah. ეს მაძლევს მისამართი N და მისამართი გ. რატომ არის, რომ მნიშვნელოვანი?

291
00:17:25,400 --> 00:17:30,220
თქვენ იცით, რომ ფუნქციონირებს C, თქვენ ყოველთვის შეგიძლიათ დაბრუნების ღირებულება ან ფასი არ არის.

292
00:17:30,220 --> 00:17:34,530
თქვენ შეგიძლიათ დაბრუნების int, string, float, char, რასაც, ან შეგიძლიათ დაბრუნებას ბათილად,

293
00:17:34,530 --> 00:17:38,030
მაგრამ შეგიძლიათ მხოლოდ დაბრუნებას ერთი რამ მაქსიმალურად.

294
00:17:38,030 --> 00:17:42,760
მაგრამ აქ ჩვენ გვინდა sscanf დაბრუნების ჩემთვის იქნებ int, ათობითი რიცხვი,

295
00:17:42,760 --> 00:17:46,220
და ასევე char, და მე რატომ char in მომენტში.

296
00:17:46,220 --> 00:17:51,460
თქვენ ეფექტურად მინდა sscanf დაბრუნების ორი რამ, მაგრამ ეს უბრალოდ არ შეიძლება C.

297
00:17:51,460 --> 00:17:55,200
თქვენ შეგიძლიათ იმუშაოთ გარშემო რომ გავლით ორ მისამართები

298
00:17:55,200 --> 00:17:57,370
რადგან, როგორც კი თქვენ გადასცემს ფუნქცია ორი მისამართები,

299
00:17:57,370 --> 00:18:00,470
რა შეიძლება, რომ გავაკეთოთ ფუნქცია მათთან? >> [სტუდენტი] დაწერეთ იმ მისამართებზე.

300
00:18:00,470 --> 00:18:02,010
მას შეუძლია დაწეროს იმ მისამართებზე.

301
00:18:02,010 --> 00:18:05,770
თქვენ შეგიძლიათ გამოიყენოთ ვარსკვლავი ოპერაცია და იქ, ყოველი იმ მისამართებზე.

302
00:18:05,770 --> 00:18:11,260
ეს ერთგვარი ამ თავში კარის მექანიზმი, მაგრამ ძალიან ხშირი შეცვლის ღირებულებების ცვლადებსა

303
00:18:11,260 --> 00:18:14,870
მეტი, ვიდრე უბრალოდ ერთი ადგილი - ამ შემთხვევაში, ორი.

304
00:18:14,870 --> 00:18:21,340
ახლა შეამჩნია მე შემოწმება == 1 და შემდეგ დაბრუნების n თუ ეს ასეა, ფაქტობრივად, შეაფასებს ჭეშმარიტი.

305
00:18:21,340 --> 00:18:26,170
ასე რომ, რა ხდება? ტექნიკურად, რიგში, ჩვენ ნამდვილად გვინდა მოხდეს GetInt ეს.

306
00:18:26,170 --> 00:18:30,740
ჩვენ გვინდა გარჩევის, ასე ვთქვათ, ჩვენ გვინდა წაიკითხოთ string - ციტირებით-unquote 123 -

307
00:18:30,740 --> 00:18:34,560
და თუ ეს ასე გამოიყურება არსებობს მთელი რიგი არსებობს, რა ჩვენ ვეუბნებით sscanf გავაკეთოთ

308
00:18:34,560 --> 00:18:38,190
ისიც, რომ ნომერი - 123 - ამ ცვლადის N ჩემთვის.

309
00:18:38,190 --> 00:18:42,090
რატომ მაშინ მე რეალურად ამ ისევე?

310
00:18:42,090 --> 00:18:48,220
რა არის როლი sscanf ამბობდა თქვენ შესაძლოა, ასევე მიიღოთ ხასიათი აქ?

311
00:18:48,220 --> 00:18:53,470
[Inaudible სტუდენტი საპასუხოდ] >> ათობითი წერტილი რეალურად შეეძლო მუშაობა.

312
00:18:53,470 --> 00:18:56,330
მოდით გამართავს, რომ ეგონა, ერთი წუთით. რა?

313
00:18:56,330 --> 00:18:59,270
[სტუდენტი] ეს შეიძლება იყოს null. >> კარგი აზრის. ეს შეიძლება იყოს null ხასიათი.

314
00:18:59,270 --> 00:19:01,660
ეს რეალურად არ არის ამ შემთხვევაში. Yeah. >> [სტუდენტი] ASCII.

315
00:19:01,660 --> 00:19:04,340
ASCII. ან ნება მომეცით განზოგადება კიდევ უფრო.

316
00:19:04,340 --> 00:19:06,640
% C არსებობს მხოლოდ შეცდომა შემოწმებისას.

317
00:19:06,640 --> 00:19:09,300
ჩვენ არ გვინდა იქ იქნება ხასიათი შემდეგ ნომერი,

318
00:19:09,300 --> 00:19:11,870
მაგრამ რა ამ საშუალებას ჩემთვის გააკეთოთ შემდეგ.

319
00:19:11,870 --> 00:19:18,210
თურმე sscanf, გარდა შენახვის ღირებულებების N და გ ამ მაგალითად აქ,

320
00:19:18,210 --> 00:19:24,890
თუ რას ასევე ამჯამად არის ის დააბრუნებს რაოდენობის ცვლადები ეს დააყენა ღირებულებების სისტემაში

321
00:19:24,890 --> 00:19:30,260
ასე რომ, თუ თქვენ მხოლოდ აკრიფოთ 123, მაშინ მხოლოდ% d აპირებს მატჩი,

322
00:19:30,260 --> 00:19:33,880
და მხოლოდ N იღებს შენახვას ღირებულება მოსწონს 123,

323
00:19:33,880 --> 00:19:35,640
და არაფერი იღებს დასვა გ.

324
00:19:35,640 --> 00:19:37,620
C რჩება ნაგვის ღირებულება, ასე ვთქვათ -

325
00:19:37,620 --> 00:19:40,730
ნაგვის რადგანაც ეს არასდროს ინიციალიზაცია ზოგიერთ ღირებულება.

326
00:19:40,730 --> 00:19:45,520
ასე რომ ამ შემთხვევაში, sscanf დააბრუნებს 1, რადგან მე დასახლებულ 1 იმ მითითებას,

327
00:19:45,520 --> 00:19:50,190
ამ შემთხვევაში დიდი, მე int მე გასათავისუფლებლად ხაზი უფასოა მეხსიერება

328
00:19:50,190 --> 00:19:54,000
რომ GetString რეალურად გამოყოფილი, და მერე დაბრუნდნენ N,

329
00:19:54,000 --> 00:19:58,500
სხვას თუ თქვენ ოდესმე გვაინტერესებდა, სადაც ეს გამეორება განაცხადი მოდის, მოდის უფლება აქ.

330
00:19:58,500 --> 00:20:04,390
ასე რომ, თუ, პირიქით, მე აკრიფოთ 123foo - რამოდენიმე შემთხვევითი თანმიმდევრობა ტექსტი -

331
00:20:04,390 --> 00:20:08,490
sscanf აპირებს ვხედავ ნომერი, ნომერი, ნომერი, ვ,

332
00:20:08,490 --> 00:20:16,410
და ის გეგმავს 123 წელს n; ის გეგმავს ვ დო და შემდეგ დაბრუნების 2.

333
00:20:16,410 --> 00:20:20,640
ამიტომ, უბრალოდ გამოყენებით ძირითადი განსაზღვრება sscanf ქცევა, ძალიან მარტივი გზა -

334
00:20:20,640 --> 00:20:23,900
ასევე, რთული ერთი შეხედვით, მაგრამ დღის ბოლოს საკმაოდ მარტივი მექანიზმი -

335
00:20:23,900 --> 00:20:28,320
საქართველოს ამბობდა არის int და თუ ასეა, ის არის, რომ ერთადერთი, რაც მე?

336
00:20:28,320 --> 00:20:29,860
და whitespace აქ არის მიზანმიმართული.

337
00:20:29,860 --> 00:20:34,000
თუ თქვენ წაიკითხავთ დოკუმენტაცია sscanf, ეს გიჩვენებთ, რომ თუ თქვენ მოიცავს ნაჭერი whitespace

338
00:20:34,000 --> 00:20:38,810
დასაწყისში ან ბოლოს, sscanf ძალიან საშუალებას მისცემს მომხმარებელს, სხვადსხვა მიზეზის გამო,

339
00:20:38,810 --> 00:20:41,860
მოხვდა სივრცეში ბარი 123 და რომ იქნება ლეგიტიმური.

340
00:20:41,860 --> 00:20:44,150
თქვენ არ დაწეროთ ზე მომხმარებლის მხოლოდ იმიტომ, რომ ისინი მოხვდა სივრცეში ბარი

341
00:20:44,150 --> 00:20:48,640
დასაწყისში ან დასასრულს, რომელიც მხოლოდ პატარა უფრო მოსახერხებელი.

342
00:20:48,640 --> 00:20:52,300
>> ნებისმიერი კითხვები შემდეგ GetInt? Yeah. >> [სტუდენტი] რა მოხდება თუ თქვენ უბრალოდ დასვა char?

343
00:20:52,300 --> 00:20:54,030
კარგი კითხვაა.

344
00:20:54,030 --> 00:20:59,890
რა მოხდება, თუ თქვენ უბრალოდ აკრეფილი char მოსწონს ვ და დააჭიროთ გარეშე ოდესმე აკრეფით 123?

345
00:20:59,890 --> 00:21:02,420
როგორ ფიქრობთ, ქცევის ამ ხაზი კოდი ამის შემდეგ იქნება?

346
00:21:02,420 --> 00:21:04,730
[Inaudible სტუდენტი საპასუხოდ]

347
00:21:04,730 --> 00:21:08,790
ჰო, ისე sscanf შეიძლება დაფაროს, რომ რადგან ამ შემთხვევაში, ის არ აპირებს შეავსოთ n ან გ.

348
00:21:08,790 --> 00:21:15,310
იგი აპირებს ნაცვლად დაბრუნების 0, ამ შემთხვევაში მე ასევე არეალიდან, რომ სცენარი

349
00:21:15,310 --> 00:21:18,750
რადგან მოსალოდნელ ღირებულების მინდა არის 1.

350
00:21:18,750 --> 00:21:22,000
მე მხოლოდ მინდა ერთი და მხოლოდ ერთი რამ უნდა იყოს შევსებული. კარგი კითხვაა.

351
00:21:22,000 --> 00:21:24,290
>> სხვა? ყველა უფლება.

352
00:21:24,290 --> 00:21:26,250
>> მოდით არ გავლა ყველა ფუნქციების აქ,

353
00:21:26,250 --> 00:21:29,500
მაგრამ ერთი, რომ, როგორც ჩანს, ალბათ დარჩენილი ინტერესი არის GetString

354
00:21:29,500 --> 00:21:32,790
რადგან აღმოჩნდება, რომ GetFloat, GetInt, GetDouble, GetLongLong

355
00:21:32,790 --> 00:21:36,260
ყველა punt ბევრი მათი ფუნქციებს GetString.

356
00:21:36,260 --> 00:21:39,750
მოდით შევხედოთ თუ როგორ ხორციელდება აქ.

357
00:21:39,750 --> 00:21:43,630
ეს ერთი გამოიყურება პატარა კომპლექსი, მაგრამ იგი იყენებს იგივე საფუძვლები

358
00:21:43,630 --> 00:21:45,670
რომ ჩვენ ალაპარაკდა გასულ კვირას.

359
00:21:45,670 --> 00:21:49,490
In GetString, რომელიც იღებს არ არგუმენტი როგორც პოსტი ბათილად აქ

360
00:21:49,490 --> 00:21:53,730
და ის დააბრუნებს string, მე აშკარად ვაცხადებ სიმებიანი ბუფერული.

361
00:21:53,730 --> 00:21:56,270
მე ნამდვილად არ ვიცი, რა, რომ იქნება გამოყენებული არ არის, მაგრამ ჩვენ დავინახავთ.

362
00:21:56,270 --> 00:21:58,390
როგორც ჩანს სიმძლავრე იყოს 0.

363
00:21:58,390 --> 00:22:01,350
არ დანამდვილებით, სადაც ეს ხდება, არ არის დარწმუნებული რა N აპირებს იქნას გამოყენებული არ არის,

364
00:22:01,350 --> 00:22:03,590
მაგრამ ახლა ის მიღების ცოტა უფრო საინტერესო.

365
00:22:03,590 --> 00:22:06,520
შეესაბამება 243, ვაცხადებთ, int, გ.

366
00:22:06,520 --> 00:22:08,800
ეს არის ერთგვარი სულელური დეტალურად.

367
00:22:08,800 --> 00:22:15,820
Char არის 8 ბიტი და 8 ბიტი შენახვა შეუძლია, თუ რამდენი სხვადასხვა ღირებულებების? >> [სტუდენტი] 256. >> 256.

368
00:22:15,820 --> 00:22:20,730
პრობლემა ის არის, თუ გნებავთ აქვს 256 სხვადასხვა ASCII სიმბოლოებს, რომელიც არსებობს

369
00:22:20,730 --> 00:22:23,340
თუ ფიქრობთ, რომ უკან - და ეს არ არის რაღაც გვემახსოვრება.

370
00:22:23,340 --> 00:22:25,710
მაგრამ თუ თქვენ ფიქრობთ, თავში რომ დიდი ASCII ჩარტში გვქონდა კვირის წინ

371
00:22:25,710 --> 00:22:30,600
იყო ამ შემთხვევაში 128 ან 256 ASCII სიმბოლოებს.

372
00:22:30,600 --> 00:22:32,940
ჩვენ ყველა ნიმუში 0S და 1s up.

373
00:22:32,940 --> 00:22:36,210
სწორედ პრობლემა თუ გსურთ შეძლებს აღმოაჩინოს შეცდომა

374
00:22:36,210 --> 00:22:40,190
რადგან თუ თქვენ უკვე იყენებს 256 ფასეულობების თქვენი გმირები,

375
00:22:40,190 --> 00:22:43,050
თქვენ არ ნამდვილად გეგმავენ ადრე რადგან ახლა არ გაქვთ გზა ამბობდა,

376
00:22:43,050 --> 00:22:46,270
ეს არ არის legit ხასიათი, ეს არის გარკვეული მცდარი გაგზავნა.

377
00:22:46,270 --> 00:22:50,270
მერე რა მსოფლიო ჯერ არის ისინი იყენებენ შემდეგი ფასეულობად, რაღაც int,

378
00:22:50,270 --> 00:22:54,720
ასე, რომ თქვენ გაქვთ Crazy რაოდენობის ბიტი, 32, 4 მილიარდი შესაძლო მნიშვნელობებია

379
00:22:54,720 --> 00:22:58,860
ასე რომ თქვენ შეგიძლიათ უბრალოდ დასრულდება up გამოყენებით არსებითად 257 მათგანი,

380
00:22:58,860 --> 00:23:01,720
1 რომლის აქვს განსაკუთრებული მნიშვნელობა როგორც შეცდომა.

381
00:23:01,720 --> 00:23:03,120
>> მოდით ვნახოთ, როგორ ეს სამუშაოები.

382
00:23:03,120 --> 00:23:07,760
შეესაბამება 246, მაქვს ამ დიდი ხოლო loop, რომელიც მოუწოდებდა fgetc,

383
00:23:07,760 --> 00:23:11,090
ვ მნიშვნელობა ფაილი, ასე getc და შემდეგ stdin.

384
00:23:11,090 --> 00:23:15,520
თურმე ეს მხოლოდ უფრო ზუსტად გზა ამბობდა წაიკითხა შეიტანენ კლავიატურაზე.

385
00:23:15,520 --> 00:23:19,300
მიწოდების სტანდარტული საშუალებებით კლავიატურის, სტანდარტულ გამოსავალზე ნიშნავს ეკრანზე,

386
00:23:19,300 --> 00:23:23,310
და სტანდარტული შეცდომა, რომელიც ჩვენ ვხედავთ pset4, ნიშნავს ეკრანზე

387
00:23:23,310 --> 00:23:27,490
მაგრამ განსაკუთრებული ნაწილი ეკრანზე ასე რომ ის conflated ფაქტობრივი გამომავალი

388
00:23:27,490 --> 00:23:30,750
რომ თქვენ აპირებდით ბეჭდვა. მაგრამ უფრო, რომ მომავალში.

389
00:23:30,750 --> 00:23:34,440
ამიტომ fgetc უბრალოდ ნიშნავს წაიკითხა ხასიათი კლავიატურის და ჩაწეროთ იგი აქ?

390
00:23:34,440 --> 00:23:37,350
ჩაწერს მას გ.

391
00:23:37,350 --> 00:23:41,360
და შემდეგ შეამოწმოთ - ასე მე უბრალოდ გამოყენებით გარკვეული ლოგიკური conjunctions აქ -

392
00:23:41,360 --> 00:23:46,000
შეამოწმეთ, რომ არ თანაბარი - \ n, ამიტომ მომხმარებელს უკვე დააჭიროთ, ჩვენ გვინდა, შეწყვიტოს იმ ეტაპზე,

393
00:23:46,000 --> 00:23:49,850
დასასრულს loop - და ჩვენ გვინდა შევამოწმოთ სპეციალური მუდმივი EOF,

394
00:23:49,850 --> 00:23:53,610
რომელიც თუ იცით ან გამოიცნოს, რას უჭერენ მხარს? >> [სტუდენტი] ფაილის დასასრულს. >> ფაილის დასასრულს.

395
00:23:53,610 --> 00:23:56,560
ეს არის სახის nonsensical რადგან თუ მე აკრეფის დროს კლავიატურაზე,

396
00:23:56,560 --> 00:23:58,870
იქ მართლაც არ ფაილი ჩართული ამ,

397
00:23:58,870 --> 00:24:01,150
მაგრამ ეს მხოლოდ სახის generic ტერმინს ვგულისხმობ

398
00:24:01,150 --> 00:24:04,220
რომ არაფერი მოდის ადამიანის თითების.

399
00:24:04,220 --> 00:24:06,460
EOF - ფაილის დასასრულს.

400
00:24:06,460 --> 00:24:09,920
როგორც განზე, თუ თქვენ ოდესმე მოხვდა კონტროლის D თქვენს კლავიატურაზე, არ, რომ თქვენ ჯერ კიდევ -

401
00:24:09,920 --> 00:24:15,230
თქვენ მოხვდა კონტროლის C - საკონტროლო D უგზავნის ამ სპეციალური მუდმივი მოუწოდა EOF.

402
00:24:15,230 --> 00:24:19,850
ახლა ჩვენ მხოლოდ გარკვეული დინამიური მეხსიერების გამოყოფის.

403
00:24:19,850 --> 00:24:23,440
>> ასე რომ, თუ (n + 1> სიმძლავრის). ახლა მე ახსნას n.

404
00:24:23,440 --> 00:24:26,100
N არის ზუსტად რამდენი ბაიტი არის ამჟამად ბუფერული,

405
00:24:26,100 --> 00:24:28,620
სიმებიანი რომ თქვენ გაკეთებული მშენებლობაზე საწყისი მომხმარებელს.

406
00:24:28,620 --> 00:24:33,450
თუ თქვენ გაქვთ მეტი სიმბოლოების თქვენი ბუფერული ვიდრე თქვენ გაქვთ შესაძლებლობები ბუფერული,

407
00:24:33,450 --> 00:24:37,410
ინტუიციურად, თუ რა უნდა გავაკეთოთ შემდეგ არის გამოყოს მეტი ტევადობის.

408
00:24:37,410 --> 00:24:43,330
ამიტომ მე ვაპირებ skim მეტი ზოგიერთი არითმეტიკა აქ და ფოკუსირება მხოლოდ ამ ფუნქციას აქ.

409
00:24:43,330 --> 00:24:46,070
თქვენ იცით, თუ რა არის malloc ან მინიმუმ ზოგადად იცნობს.

410
00:24:46,070 --> 00:24:48,970
Take გამოიცანით რა realloc აკეთებს. >> [სტუდენტი] ამატებს მეხსიერება.

411
00:24:48,970 --> 00:24:52,920
ეს არ საკმაოდ დასძინა მეხსიერება. ეს reallocates მეხსიერების შემდეგნაირად.

412
00:24:52,920 --> 00:24:57,220
თუ მაინც ოთახი დასასრულს სიმებიანი გადმოგცეთ უფრო, რომ მეხსიერების

413
00:24:57,220 --> 00:25:00,000
ვიდრე ეს თავდაპირველად გაძლევთ, მაშინ თქვენ მიიღებთ რომ დამატებითი მეხსიერება.

414
00:25:00,000 --> 00:25:03,460
ასე რომ თქვენ შეგიძლიათ მხოლოდ შეინარჩუნოს აყენებს სიმებიანი მისი გმირები თავში დაბრუნება თავში დაბრუნება.

415
00:25:03,460 --> 00:25:05,830
მაგრამ თუ ეს ასე არ არის საქმე, რადგან თქვენ დაელოდა გრძელია

416
00:25:05,830 --> 00:25:07,940
და რაღაც შემთხვევითი გაბმულ plopped მეხსიერებაში არსებობს

417
00:25:07,940 --> 00:25:10,290
მაგრამ არსებობს დამატებითი მეხსიერების ქვემოთ აქ, რომ okay.

418
00:25:10,290 --> 00:25:13,100
Realloc აპირებს ყველა მძიმე მოხსნას თქვენთვის,

419
00:25:13,100 --> 00:25:16,750
გადაადგილება string თქვენ იკითხება ამგვარად შორს აქ, დაუსვან მას იქ,

420
00:25:16,750 --> 00:25:19,460
და შემდეგ მოგცემთ კიდევ რამდენიმე პოდიუმზე იმ ეტაპზე.

421
00:25:19,460 --> 00:25:22,550
>> ამრიგად, ტალღა მხრივ, მინდა ვთქვა, რომ რა GetString აკეთებს

422
00:25:22,550 --> 00:25:26,330
არის ის დაწყებული მცირე ბუფერული, იქნებ ერთი ხასიათი,

423
00:25:26,330 --> 00:25:30,820
და თუ მომხმარებლის ტიპის ორ გმირები, GetString მთავრდება მოუწოდებდა realloc და აცხადებს,

424
00:25:30,820 --> 00:25:33,150
ერთი პერსონაჟი არ იყო საკმარისი; მომეცი ორი სიმბოლო.

425
00:25:33,150 --> 00:25:35,950
თუ წაიკითხავთ მეშვეობით ლოგიკა მარყუჟის, იგი აპირებს ამბობენ

426
00:25:35,950 --> 00:25:39,600
მომხმარებლის აკრეფილი 3 გმირები; მომეცი ახლა არ 2 მაგრამ 4 სიმბოლოზე,

427
00:25:39,600 --> 00:25:42,320
მაშინ მაძლევს 8, მაშინ მაძლევს 16 და 32.

428
00:25:42,320 --> 00:25:45,000
ის ფაქტი, რომ მე გააორმაგოს მოცულობა ყოველ ჯერზე

429
00:25:45,000 --> 00:25:48,570
იმას ნიშნავს, რომ ბუფერული არ აპირებს იზრდება ნელა, ის აპირებს იზრდება სუპერ სწრაფი.

430
00:25:48,570 --> 00:25:51,380
და რა შეიძლება იყოს უპირატესობა რომ?

431
00:25:51,380 --> 00:25:54,600
რატომ გააორმაგოს ზომა ბუფერული

432
00:25:54,600 --> 00:25:58,020
მიუხედავად იმისა, რომ შესაძლოა მომხმარებლის უბრალოდ უნდა ერთი ზედმეტი ხასიათი კლავიატურის?

433
00:25:58,020 --> 00:26:01,750
[Inaudible სტუდენტი საპასუხოდ] >> რა არის რომ? >> [სტუდენტი] თქვენ არ იზრდება, როგორც ხშირად.

434
00:26:01,750 --> 00:26:03,300
სწორედ. თქვენ არ იზრდება, როგორც ხშირად.

435
00:26:03,300 --> 00:26:05,510
და ეს მხოლოდ სახის თქვენ ხეჯირების თქვენი ფსონები აქ,

436
00:26:05,510 --> 00:26:10,850
იდეა მყოფი რომ თქვენ არ მინდა მოვუწოდო realloc ბევრი რადგან ეს tends უნდა იყოს ნელი.

437
00:26:10,850 --> 00:26:12,910
ნებისმიერ დროს თქვენ ჰკითხავთ მოქმედი სისტემის მეხსიერება,

438
00:26:12,910 --> 00:26:16,990
როგორც თქვენ მალე დავინახავთ მომავალში პრობლემა კომპლექტი, იგი აპირებს გარკვეული დრო დაჭირდეს.

439
00:26:16,990 --> 00:26:20,010
ასე რომ მინიმუმამდე შემცირების იმ დროის, თუნდაც თქვენ გაყვანაა გარკვეული სივრცე,

440
00:26:20,010 --> 00:26:21,900
tends იყოს კარგია.

441
00:26:21,900 --> 00:26:24,060
>> მაგრამ თუ ჩვენ წაკითხულად მეშვეობით დასკვნითი ნაწილი GetString აქ -

442
00:26:24,060 --> 00:26:27,950
და ისევ გაგება თითოეული ხაზი აქ არ არის ასე მნიშვნელოვანი დღეს -

443
00:26:27,950 --> 00:26:30,530
შეამჩნია, რომ ეს საბოლოოდ მოუწოდებს malloc ერთხელ

444
00:26:30,530 --> 00:26:33,880
და ეს გამოყოფს ზუსტად როგორც ბევრი bytes როგორც სჭირდება სიმებიანი

445
00:26:33,880 --> 00:26:38,060
და მაშინ ისვრის შორს დარეკვით უფასო ზედმეტად დიდი ბუფერული

446
00:26:38,060 --> 00:26:40,080
თუ იგი მართლაც მიიღო გაორმაგდა ძალიან ბევრჯერ.

447
00:26:40,080 --> 00:26:42,730
ასე მოკლედ, ასე GetString მუშაობს ყველა ამ დროს.

448
00:26:42,730 --> 00:26:47,060
ყველა ეს სულაც წაკითხვის ერთი ხასიათი დროს ისევ და ისევ და ისევ,

449
00:26:47,060 --> 00:26:50,750
და ყოველ ჯერზე მას სჭირდება დამატებითი მეხსიერება, იგი სთხოვს ოპერაციული სისტემის ეს

450
00:26:50,750 --> 00:26:53,670
დარეკვით realloc.

451
00:26:53,670 --> 00:26:57,890
>> ნებისმიერი კითხვები? ყველა უფლება.

452
00:26:57,890 --> 00:26:59,270
>> თავდასხმა.

453
00:26:59,270 --> 00:27:04,060
ახლა, როდესაც ჩვენ გვესმის პოინტერები ან თუნდაც უფრო იცნობს პოინტერები,

454
00:27:04,060 --> 00:27:06,700
განვიხილოთ, თუ როგორ მთელი მსოფლიო იწყებს დაიშალოს

455
00:27:06,700 --> 00:27:10,030
თუ თქვენ არ საკმაოდ წინააღმდეგ შეჯიბრებითობის მომხმარებლებს,

456
00:27:10,030 --> 00:27:11,850
ადამიანები, რომლებიც ცდილობენ hack თქვენს სისტემას,

457
00:27:11,850 --> 00:27:16,890
ადამიანები, რომლებიც ცდილობენ მოიპარონ თქვენი პროგრამული უზრუნველყოფა მიერ circumventing ზოგიერთი სარეგისტრაციო კოდი

458
00:27:16,890 --> 00:27:19,090
რომ მათ შეიძლება სხვაგვარად უნდა აკრიფოთ სისტემაში

459
00:27:19,090 --> 00:27:22,990
>> შეხედეთ ამ მაგალითს აქ, რაც არის C კოდი, რომელსაც აქვს ფუნქცია ძირითად ბოლოში

460
00:27:22,990 --> 00:27:26,380
რომ უწოდებს ფუნქცია foo. და რა არის ის გვერდის ავლით, რათა foo?

461
00:27:26,380 --> 00:27:29,680
[სტუდენტი] ერთჯერადი არგუმენტი. >> [Malan] ერთჯერადი არგუმენტი.

462
00:27:29,680 --> 00:27:33,450
ამიტომ argv [1], რაც იმას ნიშნავს, პირველი სიტყვა, რომელიც მომხმარებლის აკრეფილი ბრძანებათა ზოლს

463
00:27:33,450 --> 00:27:36,360
შემდეგ a.out ან რასაც პროგრამის ეწოდება.

464
00:27:36,360 --> 00:27:41,680
ამიტომ foo ზედა იღებს in char *. მაგრამ char * მხოლოდ რა? >> [სტუდენტი] სიმებიანი.

465
00:27:41,680 --> 00:27:43,350
[Malan] ტექსტი, ასე რომ არაფერი ახალი აქ.

466
00:27:43,350 --> 00:27:45,420
რომ სტრიქონს თვითნებურად მიმდინარეობს მოუწოდა ბარი.

467
00:27:45,420 --> 00:27:51,430
ამ ხაზის აქ, char გ [12], ხოლო სახის ნახევრად ტექნიკური ინგლისური, რა არის ეს ხაზი აკეთებს?

468
00:27:51,430 --> 00:27:55,220
[სტუდენტი] მასივი - >> მასივი? >> [სტუდენტი] პერსონაჟები. >> პერსონაჟები.

469
00:27:55,220 --> 00:27:58,870
მომეცი მასივი 12 სიმბოლოს. ასე რომ, ჩვენ შეიძლება მოვუწოდებთ ამ ბუფერულ.

470
00:27:58,870 --> 00:28:02,920
ეს ტექნიკურად მოუწოდა C, მაგრამ ბუფერულ პროგრამირებაში მხოლოდ იმას ნიშნავს, bunch of სივრცეში

471
00:28:02,920 --> 00:28:04,800
შეგიძლიათ განათავსოთ რაღაცები სისტემაში

472
00:28:04,800 --> 00:28:07,940
მაშინ ბოლოს, memcpy ჩვენ არ გამოიყენება ადრე, მაგრამ თქვენ ალბათ შეუძლია გამოიცნოს, თუ რას აკეთებს.

473
00:28:07,940 --> 00:28:10,480
ეს აკოპირებს მეხსიერება. რას აკეთებთ?

474
00:28:10,480 --> 00:28:19,270
ეს აშკარად აკოპირებს ბარი, მისი შეყვანის, შევიდა გ მაგრამ მხოლოდ სიგრძეზე ბარი.

475
00:28:19,270 --> 00:28:24,930
მაგრამ bug აქ. >> [სტუდენტი] თქვენ უნდა sizeof ხასიათი. >> Okay.

476
00:28:24,930 --> 00:28:30,860
ტექნიკურად, ჩვენ უნდა ნამდვილად strlen (ბარი) * sizeof (char)). რომ სწორი.

477
00:28:30,860 --> 00:28:33,930
მაგრამ უარეს შემთხვევაში აქ, მოდით ვივარაუდოთ, რომ that's -

478
00:28:33,930 --> 00:28:35,950
Okay. მაშინ არსებობს ორი შეცდომები.

479
00:28:35,950 --> 00:28:39,160
ამიტომ sizeof (char));

480
00:28:39,160 --> 00:28:41,290
მოდით ამ პატარა უფრო ფართო.

481
00:28:41,290 --> 00:28:44,910
ასე რომ ახლა მაინც bug, რაც? >> [Inaudible სტუდენტი საპასუხოდ]

482
00:28:44,910 --> 00:28:46,990
ვცადოთ რა? >> [სტუდენტი] შეამოწმეთ for null.

483
00:28:46,990 --> 00:28:50,270
ჩვენ უნდა ზოგადად იყოს შემოწმების for null რადგან ცუდი რამ ხდება

484
00:28:50,270 --> 00:28:53,200
როდესაც თქვენი კურსორი არის NULL რადგან თქვენ შეიძლება დასრულდება მდე მიმდინარეობს,

485
00:28:53,200 --> 00:28:57,630
და თქვენ არ უნდა იყოს ოდესმე აპირებს null მიერ dereferencing იგი ვარსკვლავი ოპერატორს.

486
00:28:57,630 --> 00:29:01,050
ასე რომ კარგია. და რა ვაკეთებთ? ლოგიკურად, არსებობს ხარვეზი აქაც.

487
00:29:01,050 --> 00:29:04,450
[სტუდენტი] შეამოწმეთ თუ argc არის> = to 2.

488
00:29:04,450 --> 00:29:10,550
ამიტომ შეამოწმეთ თუ argc არის> = 2. Okay, ასე რომ სამი შეცდომები ამ პროგრამის აქ.

489
00:29:10,550 --> 00:29:16,630
ჩვენ ახლა შემოწმების თუ მომხმარებელი რეალურად აკრეფილი არაფერი შევიდა argv [1]. კარგი.

490
00:29:16,630 --> 00:29:20,950
რა არის მესამე bug? Yeah. >> [სტუდენტი] C შეიძლება არ იყოს დიდი საკმარისი.

491
00:29:20,950 --> 00:29:23,320
კარგი. გადავამოწმეთ ერთი სცენარი.

492
00:29:23,320 --> 00:29:29,520
ჩვენ მინიშნებით შემოწმდება არ კოპირება მეტი მეხსიერების ვიდრე იქნებოდა აღემატებოდეს სიგრძეზე ბარი.

493
00:29:29,520 --> 00:29:32,510
ასე რომ, თუ სიმებიანი მომხმარებლის აკრეფილი არის 10 სიმბოლომდე

494
00:29:32,510 --> 00:29:36,020
ამ ამბობს მხოლოდ კოპირება 10 სიმბოლოს. და ეს okay.

495
00:29:36,020 --> 00:29:39,940
მაგრამ რა, თუ მომხმარებლის აკრეფილი სიტყვა ბრძანებათა ზოლზე მოსწონს 20-ხასიათი სიტყვა?

496
00:29:39,940 --> 00:29:44,900
ეს ამბობს ასლი 20 სიმბოლოებს ბარი შევიდა რა?

497
00:29:44,900 --> 00:29:49,750
C, სხვაგვარად ცნობილია როგორც ჩვენი ბუფერული, რაც იმას ნიშნავს, თქვენ უბრალოდ დაწერა მონაცემები

498
00:29:49,750 --> 00:29:52,540
დან 8 byte ადგილებში, რომ თქვენ არ საკუთარი,

499
00:29:52,540 --> 00:29:54,870
და თქვენ არ ფლობენ მათ გრძნობა, რომ თქვენ არასოდეს გამოყოფილი მათ.

500
00:29:54,870 --> 00:30:00,370
ასე რომ, ეს რა საყოველთაოდ ცნობილია, როგორც ბუფერული overflow თავდასხმა ან ბუფერული overrun თავდასხმა.

501
00:30:00,370 --> 00:30:05,580
და ეს თავდასხმა იმ გაგებით, რომ თუ მომხმარებელი ან პროგრამა რომ დაურეკეთ ფუნქცია

502
00:30:05,580 --> 00:30:10,490
აკეთებს ამ maliciously, რაც სინამდვილეში ხდება შემდეგი შეეძლო რეალურად საკმაოდ ცუდი.

503
00:30:10,490 --> 00:30:12,450
>> მოდით შევხედოთ ამ სურათს აქ.

504
00:30:12,450 --> 00:30:16,060
ეს სურათი წარმოადგენს თქვენი დასტის მეხსიერება.

505
00:30:16,060 --> 00:30:19,580
შეგახსენებთ, რომ ყოველ ჯერზე რეკავთ ფუნქცია თქვენ ამ პატარა ჩარჩო დასტის

506
00:30:19,580 --> 00:30:21,520
და შემდეგ კიდევ ერთი და მერე კიდევ ერთი და სხვა.

507
00:30:21,520 --> 00:30:24,300
და დღემდე, ჩვენ უბრალოდ სახის რეფერირებადი ამ როგორც მართკუთხედების

508
00:30:24,300 --> 00:30:26,290
ან ფორუმში ან ეკრანზე აქ.

509
00:30:26,290 --> 00:30:30,580
მაგრამ თუ ჩვენ მიუახლოვდით ერთ იმ მართკუთხედების, როცა რეკავთ ფუნქცია foo,

510
00:30:30,580 --> 00:30:35,880
აღმოჩნდება, რომ არსებობს უფრო დასტის შიგნით რომ ჩარჩო ამ მართკუთხედი

511
00:30:35,880 --> 00:30:40,060
ვიდრე მხოლოდ X და Y და A და B, ისე, როგორც ვსაუბრობთ swap.

512
00:30:40,060 --> 00:30:44,410
თურმე არსებობს გარკვეული ქვედა დონის დეტალები, მათ შორის დაბრუნება მისამართი.

513
00:30:44,410 --> 00:30:49,550
გამოდის, როდესაც მთავარ მოუწოდებს foo, მთავარ უნდა აცნობოს foo

514
00:30:49,550 --> 00:30:53,520
რა ძირითად მისამართი არის კომპიუტერის მეხსიერების

515
00:30:53,520 --> 00:30:57,770
რადგან, წინააღმდეგ შემთხვევაში, როგორც კი foo კეთდება შესრულებაში, როგორც ამ შემთხვევაში აქ,

516
00:30:57,770 --> 00:31:00,830
ერთხელ თქვენ მიაღწიოს ამ დახურულ Curly გაუწიოს დასასრულს foo,

517
00:31:00,830 --> 00:31:05,310
როგორ heck ამჯამად foo ვიცი სად კონტროლის პროგრამა უნდა წავიდეს?

518
00:31:05,310 --> 00:31:08,970
თურმე პასუხი ამ კითხვაზე არის ამ წითელი სამკუთხედით აქ.

519
00:31:08,970 --> 00:31:12,670
ეს წარმოადგენს მაჩვენებელი და ეს მდე კომპიუტერში შესანახად დროებით

520
00:31:12,670 --> 00:31:17,030
on ე.წ. დასტის მისამართი ძირითად ასე რომ როგორც კი foo კეთდება შესრულებაში,

521
00:31:17,030 --> 00:31:21,120
კომპიუტერი იცის სად და რა ხაზი მთავარ დაბრუნებოდნენ.

522
00:31:21,120 --> 00:31:23,940
შენახული კარკასი მაჩვენებელი ეხება მსგავსად ამ.

523
00:31:23,940 --> 00:31:26,310
ჩარ * ბარი აქ წარმოადგენს რა?

524
00:31:26,310 --> 00:31:31,350
ახლა ეს ლურჯი სეგმენტი აქ არის foo-ს ფარგლებში. რა არის ბარი?

525
00:31:31,570 --> 00:31:35,010
ბარი არის მხოლოდ არგუმენტი foo ფუნქცია.

526
00:31:35,010 --> 00:31:37,500
ახლა ჩვენ უკან სახის ნაცნობი სურათი.

527
00:31:37,500 --> 00:31:39,850
არსებობს უფრო პერსონალის და მეტი distractions ეკრანზე,

528
00:31:39,850 --> 00:31:43,380
მაგრამ ამ ღია ლურჯი სეგმენტი მხოლოდ ის არის, რაც ჩვენ ხატვა chalkboard

529
00:31:43,380 --> 00:31:45,790
ამისთვის რაღაც swap. სწორედ ფარგლებში ამისთვის foo.

530
00:31:45,790 --> 00:31:51,490
და ერთადერთი, რაც მას ახლა არის ბარი, რომელიც ამ პარამეტრს.

531
00:31:51,490 --> 00:31:55,220
მაგრამ რა უნდა იყოს დასტის მიხედვით ეს კოდი აქ?

532
00:31:55,220 --> 00:31:57,760
[სტუდენტი] char გ [12]. >> [Malan] char გ [12].

533
00:31:57,760 --> 00:32:02,810
ჩვენ ასევე უნდა ნახოთ 12 სკვერები მეხსიერების გამოყოფილი ცვლადში გ,

534
00:32:02,810 --> 00:32:04,970
და მართლაც გვაქვს, რომ ეკრანზე.

535
00:32:04,970 --> 00:32:08,480
ძალიან ზევით არის გ [0], და შემდეგ ავტორი ამ დიაგრამაზე

536
00:32:08,480 --> 00:32:11,850
არ გადაიტვირთოთ ხატვის ყველა მოედნები, მაგრამ არსებობს მართლაც არსებობს 12

537
00:32:11,850 --> 00:32:16,590
რადგან თუ გადავხედავთ ქვედა მარჯვენა, გ [11] თუ ითვლიან საწყისი 0 არის მე -12 ასეთი byte.

538
00:32:16,590 --> 00:32:18,400
მაგრამ აქ პრობლემა.

539
00:32:18,400 --> 00:32:22,390
თუ საით არის გ მზარდი?

540
00:32:22,390 --> 00:32:27,080
სახის დაბრუნება ქვემოთ თუ იგი იწყება ზედა და იზრდება ბოლოში.

541
00:32:27,080 --> 00:32:30,110
ეს არ ჰგავს ჩვენ დაუტოვებიათ საკუთარ თავს გაცილებით runway აქ ყველა.

542
00:32:30,110 --> 00:32:32,090
ჩვენ სახის მოხატული საკუთარ თავს კუთხეში,

543
00:32:32,090 --> 00:32:36,940
და რომ გ [11] არის სწორი წინააღმდეგ ბარი, რომელიც არის სწორი წინააღმდეგ შენახული კარკასი მაჩვენებელი,

544
00:32:36,940 --> 00:32:39,960
რაც უფლებას წინააღმდეგ დაბრუნება მისამართი. არ არსებობს უფრო მეტი ოთახი.

545
00:32:39,960 --> 00:32:42,810
ასე რომ რა მნიშვნელობა თუ თქვენ Screw up

546
00:32:42,810 --> 00:32:46,500
და თქვენ ცდილობენ კითხულობს 20 ბაიტი შევიდა 12-byte ბუფერული?

547
00:32:46,500 --> 00:32:50,060
სად არიან 8 დამატებითი bytes აპირებს? >> [სტუდენტი] Inside -

548
00:32:50,060 --> 00:32:53,200
Inside ყველაფერი, რომელთაგან ზოგიერთი არის სუპერ მნიშვნელოვანია.

549
00:32:53,200 --> 00:32:57,260
და ყველაზე მთავარია, პოტენციურად, არის წითელი ყუთი იქ დაბრუნება მისამართი,

550
00:32:57,260 --> 00:33:03,560
რადგან ვარაუდობენ, რომ თქვენ ან შემთხვევით ან adversarially გადავაწერო იმ 4 ბაიტი,

551
00:33:03,560 --> 00:33:07,260
რომ მომცეთ მისამართი, არა მხოლოდ ნაგვის მაგრამ ნომერი

552
00:33:07,260 --> 00:33:09,810
ეს მოხდება, რათა წარმოადგინოს ფაქტობრივი მისამართი მეხსიერებაში.

553
00:33:09,810 --> 00:33:13,880
რა გავლენა, ლოგიკურად? >> [სტუდენტი] ფუნქცია დაბრუნებას აპირებს სხვადასხვა ადგილას.

554
00:33:13,880 --> 00:33:15,250
სწორედ.

555
00:33:15,250 --> 00:33:19,170
როდესაც foo ბრუნდება და ჰიტები, რომ curly გაუწიოს, პროგრამა აპირებს გაგრძელება

556
00:33:19,170 --> 00:33:25,060
არ დაბრუნებას მთავარი, ის დაბრუნებას აპირებს რასაც მისამართის რომ წითელი ყუთი.

557
00:33:25,060 --> 00:33:28,600
>> იმ შემთხვევაში, circumventing პროგრამული რეგისტრაციის,

558
00:33:28,600 --> 00:33:32,260
რა, თუ მისამართი რომ მიმდინარეობს დაბრუნდა ფუნქცია რომ ნორმალურად იღებს მოუწოდა

559
00:33:32,260 --> 00:33:35,690
შემდეგ თქვენ გადახდილი პროგრამული და inputted თქვენი სარეგისტრაციო კოდი?

560
00:33:35,690 --> 00:33:39,870
შეგიძლიათ სახის ხრიკი კომპიუტერის შევიდა არ აპირებს აქ არამედ აპირებს აქ.

561
00:33:39,870 --> 00:33:45,100
ან თუ თქვენ ნამდვილად ჭკვიანი, მოწინააღმდეგის შეიძლება რეალურად აკრიფოთ ზე კლავიატურის, მაგალითად,

562
00:33:45,100 --> 00:33:50,690
არ ფაქტობრივი სიტყვა, არ 20 სიმბოლო, მაგრამ ვარაუდობენ, იგი რეალურად ტიპები

563
00:33:50,690 --> 00:33:52,770
ზოგიერთი გმირები რომ წარმოადგენენ კოდი.

564
00:33:52,770 --> 00:33:55,320
და ეს არ იქნება C კოდი, სინამდვილეში იქნება გმირები

565
00:33:55,320 --> 00:33:59,290
რომ წარმოადგენენ ორობითი მანქანა კოდი, 0S და 1s.

566
00:33:59,290 --> 00:34:01,290
მაგრამ ვარაუდობენ, ისინი ჭკვიანი საკმარისი ამისათვის,

567
00:34:01,290 --> 00:34:06,500
რათა როგორმე ჩასვით შევიდა GetString სწრაფი იმას, რაც არსებითად შედგენილი კოდი,

568
00:34:06,500 --> 00:34:09,980
და ბოლო 4 ბაიტი გადავაწერო, რომ დაბრუნების მისამართზე.

569
00:34:09,980 --> 00:34:13,360
და რა მისამართი ამჯამად რომ შეყვანის შემთხვევაში?

570
00:34:13,360 --> 00:34:18,630
ეს ფაქტიურად ინახავს ამ წითელი სამკუთხედით მისამართი პირველი byte of ბუფერული.

571
00:34:18,630 --> 00:34:23,070
ასე, რომ თქვენ უნდა იყოს მართლაც ჭკვიანი, და ეს არის ბევრი სასამართლო და შეცდომა ცუდი ხალხი არსებობს,

572
00:34:23,070 --> 00:34:25,639
მაგრამ თუ შეგიძლიათ გაერკვნენ, თუ როგორ დიდი ამ ბუფერული არის

573
00:34:25,639 --> 00:34:28,820
ისეთი, რომ ბოლო რამდენიმე bytes in შეტანის თქვენს მიერ მოწოდებული პროგრამის

574
00:34:28,820 --> 00:34:33,540
მოხდეს უნდა იყოს ექვივალენტური მისამართი დაწყების თქვენი ბუფერული, შეგიძლიათ ამის გაკეთება.

575
00:34:33,540 --> 00:34:39,320
თუ ვიტყვით ჩვეულებრივ მიესალმები და \ 0, არის ის, რაც მთავრდება ბუფერული.

576
00:34:39,320 --> 00:34:44,420
მაგრამ თუ ჩვენ უფრო ჭკვიანი და ჩვენ შეავსოთ რომ ბუფერული რა ჩვენ მოვუწოდებთ generically თავდასხმა კოდი -

577
00:34:44,420 --> 00:34:48,860
AAA, თავდასხმა, შეტევა, შეტევა - როდესაც ეს უბრალოდ რაღაც რომ ჯერ რაღაც ცუდი,

578
00:34:48,860 --> 00:34:51,820
რა მოხდება, თუ თქვენ მართლაც ჭკვიანი, თქვენ შეიძლება ამის გაკეთება.

579
00:34:51,820 --> 00:34:58,610
წითელ ყუთში აქ არის თანმიმდევრობა ნომრები - 80, C0, 35, 08.

580
00:34:58,610 --> 00:35:01,610
გაითვალისწინეთ, რომ სიას ხმების რომ აქ.

581
00:35:01,610 --> 00:35:04,430
ეს წელს საპირისპირო მიზნით, მაგრამ უფრო, რომ სხვა დროს.

582
00:35:04,430 --> 00:35:08,140
გაითვალისწინეთ, რომ ამ დაბრუნების მისამართი უკვე შეგნებულად შეცვლილი

583
00:35:08,140 --> 00:35:12,020
ერთნაირი მისამართი აქ, არ მისამართი ძირითადი.

584
00:35:12,020 --> 00:35:17,500
ასე რომ, თუ ცუდი ბიჭი არის სუპერ ჭკვიანი, იგი აპირებს მოიცავს, რომ თავდასხმა კოდი

585
00:35:17,500 --> 00:35:20,930
რაღაც წაშლა ყველა მომხმარებლის ფაილების ან კოპირება პაროლები

586
00:35:20,930 --> 00:35:24,680
ან შექმნათ მომხმარებლის ანგარიში, რომ მე შეიძლება მაშინ შესვლა - არაფერი საერთოდ.

587
00:35:24,680 --> 00:35:26,950
>> და ეს არის ორივე საფრთხე და ძალა C.

588
00:35:26,950 --> 00:35:29,840
იმის გამო, რომ თქვენ გაქვთ მეხსიერების მეშვეობით პოინტერები

589
00:35:29,840 --> 00:35:32,520
და შეგიძლიათ აქედან გამომდინარე წერენ არაფერი გსურთ შევიდა კომპიუტერის მეხსიერებაში,

590
00:35:32,520 --> 00:35:35,080
შეგიძლიათ კომპიუტერის არაფერი გინდათ

591
00:35:35,080 --> 00:35:39,550
უბრალოდ, რომელმაც მას ხტომა გარშემო ფარგლებში საკუთარი მეხსიერების სივრცე.

592
00:35:39,550 --> 00:35:44,650
და ასე ამ დღეს ამდენი პროგრამები და ამდენი საიტებზე, რომლებიც კომპრომეტირებული

593
00:35:44,650 --> 00:35:46,200
მოვხარშოთ ქვემოთ ხალხი უპირატესობების ამ.

594
00:35:46,200 --> 00:35:50,760
და ეს ალბათ, როგორიცაა Super დახვეწილი თავდასხმა, მაგრამ ეს ყოველთვის არ დაიწყოს, რომ გზა.

595
00:35:50,760 --> 00:35:53,560
რეალობაა ის, რომ რა ცუდი ხალხი ჩვეულებრივ გააკეთოთ,

596
00:35:53,560 --> 00:35:58,200
თუ არა ეს პროგრამა ბრძანებაში ან GUI პროგრამის ან ნახვა,

597
00:35:58,200 --> 00:35:59,940
თქვენ დავიწყო უზრუნველყოფს სისულელეა.

598
00:35:59,940 --> 00:36:03,980
თქვენ აკრიფოთ მართლაც დიდი სიტყვა შევიდა საძიებო ველში და დააჭიროთ,

599
00:36:03,980 --> 00:36:05,780
და თქვენ დაველოდოთ თუ ნახვა Crashes

600
00:36:05,780 --> 00:36:09,990
ან თქვენ დაველოდოთ თუ პროგრამის მანიფესტებმა რაიმე შეცდომა გაგზავნა

601
00:36:09,990 --> 00:36:14,330
რადგან თუ თქვენ გაქვთ გაუმართლა როგორც ცუდი ბიჭი და თქვენს მიერ მოწოდებული ზოგიერთი გიჟები შეყვანის

602
00:36:14,330 --> 00:36:18,980
რომ Crashes პროგრამა, რაც იმას ნიშნავს, პროგრამისტი არ გავუსწრო თქვენი ცუდი საქციელის გამო,

603
00:36:18,980 --> 00:36:23,630
რაც იმას ნიშნავს, თქვენ შეგიძლიათ ალბათ საკმარისი ძალისხმევა, საკმარისი სასამართლო და შეცდომა,

604
00:36:23,630 --> 00:36:26,650
გაერკვნენ, თუ როგორ უნდა ეწარმოებინა უფრო ზუსტად თავდასხმა.

605
00:36:26,650 --> 00:36:31,410
ასე რომ იმდენი ნაწილი უსაფრთხოების არა მხოლოდ თავიდან აცილების ამ თავდასხმების საერთოდ

606
00:36:31,410 --> 00:36:34,100
მაგრამ გამოვლენის მათ და რეალურად შევხედავთ ჟურნალები

607
00:36:34,100 --> 00:36:36,780
და ხედავს, რა გიჟები საშუალებებით აქვს ხალხს აკრეფილი თქვენს ნახვა,

608
00:36:36,780 --> 00:36:38,960
რა ძიება პირობები არ ხალხს აკრეფილი თქვენს ნახვა

609
00:36:38,960 --> 00:36:42,870
წელს იმედები overflowing ზოგიერთი ბუფერული.

610
00:36:42,870 --> 00:36:45,500
და ამ ყველა boils ქვემოთ მარტივი საფუძვლები რა მასივი

611
00:36:45,500 --> 00:36:49,080
და რას ნიშნავს გამოყოფას და გამოიყენოთ მეხსიერება.

612
00:36:49,080 --> 00:36:51,710
>> დაკავშირებული, რომ მაშინ ძალიან არის ამ.

613
00:36:51,710 --> 00:36:54,280
მოდით უბრალოდ შეხედვით შიგნით დისკის კიდევ ერთხელ.

614
00:36:54,280 --> 00:36:58,440
თქვენ გავიხსენოთ საწყისი ორი კვირის წინ, რომ როდესაც თქვენ გადაიტანეთ ფაილები თქვენი recycle bin ან ნაგვის შეიძლება,

615
00:36:58,440 --> 00:37:03,710
რა ხდება? >> [სტუდენტი] არაფერი. >> აბსოლუტურად არაფერს, არა?

616
00:37:03,710 --> 00:37:05,740
საბოლოოდ, თუ თქვენ აწარმოებს დაბალი on დისკზე,

617
00:37:05,740 --> 00:37:08,190
Windows ან Mac OS დაიწყება წაშლის ფაილი თქვენთვის.

618
00:37:08,190 --> 00:37:10,390
მაგრამ თუ თქვენ გადაიტანეთ რაღაც არსებობს, რომ არ არის უსაფრთხო.

619
00:37:10,390 --> 00:37:13,800
ყველა თქვენი roommate ან მეგობარს ან ოჯახის წევრს უნდა გააკეთოს არის ორმაგად დაწკაპეთ და, voila,

620
00:37:13,800 --> 00:37:16,310
იქ ყველა sketchy ფაილი, რომელიც თქვენ სცადა წაშლა.

621
00:37:16,310 --> 00:37:19,590
ყველაზე მეტად ჩვენს არანაკლებ ვიცით, რომ თქვენ უნდა მარჯვენა ღილაკით ან კონტროლის click

622
00:37:19,590 --> 00:37:22,310
და ცარიელი სანაგვე ან რამე მაგდაგვარს.

623
00:37:22,310 --> 00:37:25,000
მაგრამ მაშინაც რომ არ გააკეთოს საკმაოდ შეასრულა

624
00:37:25,000 --> 00:37:28,010
რადგან ის, რაც ხდება, როდესაც თქვენ გაქვთ ფაილი თქვენს ხისტ დისკზე

625
00:37:28,010 --> 00:37:32,770
, რომელიც წარმოადგენს გარკვეული Word დოკუმენტის ან JPEG, და ეს წარმოადგენს თქვენს ხისტ დისკზე,

626
00:37:32,770 --> 00:37:35,350
და ასე ვთქვათ ამ sliver აქ წარმოადგენს, რომ ფაილი,

627
00:37:35,350 --> 00:37:38,390
და ის შედგება მთელი bunch of 0S და 1s.

628
00:37:38,390 --> 00:37:42,470
რა ხდება, როდესაც თქვენ არა მხოლოდ გადაათრიეთ რომ ფაილი ნაგვის შეიძლება ან recycle bin

629
00:37:42,470 --> 00:37:48,020
არამედ დაცლას ეს? სახის არაფერი.

630
00:37:48,020 --> 00:37:49,640
ეს არ არის აბსოლუტურად არაფერი არის.

631
00:37:49,640 --> 00:37:54,290
ახლა კი უბრალოდ არაფერი, რადგან პატარა რამე მოხდება სახით ამ მაგიდასთან.

632
00:37:54,290 --> 00:37:58,370
ამიტომ არსებობს გარკვეული მონაცემთა ბაზაში ან მაგიდასთან შიგნით კომპიუტერის მეხსიერების

633
00:37:58,370 --> 00:38:03,850
რომ არსებითად ერთი სვეტი ფაილების 'სახელები და ერთი სვეტი ფაილების' საიდან,

634
00:38:03,850 --> 00:38:07,720
სადაც ეს შეიძლება იყოს საიდან 123, მხოლოდ შემთხვევითი რიცხვების.

635
00:38:07,720 --> 00:38:14,560
ასე რომ, ჩვენ შეიძლება რაღაც x.jpeg და საიდან 123.

636
00:38:14,560 --> 00:38:18,800
რა მოხდება მაშინ, როდესაც თქვენ ნამდვილად დაცლას თქვენი ურნის?

637
00:38:18,800 --> 00:38:20,330
რომ მიდის.

638
00:38:20,330 --> 00:38:23,610
მაგრამ რა არ მიდიან არის 0S და 1s.

639
00:38:23,610 --> 00:38:26,270
>> რა არის მაშინ კავშირი pset4?

640
00:38:26,270 --> 00:38:31,240
ისე, ერთად pset4, მხოლოდ იმიტომ, რომ ჩვენ შემთხვევით წაშლილია კომპაქტური ფლეშ განყოფილებიდან

641
00:38:31,240 --> 00:38:35,750
რომ ჰქონდა ყველა ეს ფოტოები ან უბრალოდ იმიტომ, რომ ეს ცუდი იღბალი გახდა კორუმპირებული

642
00:38:35,750 --> 00:38:38,000
არ ნიშნავს, რომ 0S და 1s არ ვართ ჯერ კიდევ არსებობს.

643
00:38:38,000 --> 00:38:40,410
იქნებ რამდენიმე მათგანი იკარგება, რადგან რაღაც გაბმულ კორუმპირებული

644
00:38:40,410 --> 00:38:43,320
იმ გაგებით, რომ ზოგიერთი 0S გახდა 1s და 1s გახდა 0S.

645
00:38:43,320 --> 00:38:47,240
ცუდი რამ შეიძლება მოხდეს, რადგან buggy პროგრამული უზრუნველყოფის ან წუნდებული აპარატურა.

646
00:38:47,240 --> 00:38:50,370
მაგრამ ბევრი იმ ბიტი, შესაძლოა, 100% მათგანი, ჯერ კიდევ არსებობს.

647
00:38:50,370 --> 00:38:55,050
უბრალოდ კომპიუტერი ან კამერა არ იცის სად JPEG1 დაიწყო

648
00:38:55,050 --> 00:38:56,910
და სადაც JPEG2 დაიწყო.

649
00:38:56,910 --> 00:39:01,070
მაგრამ თუ თქვენ, პროგრამისტი, ვიცი ერთად ცოტა საზრიანი სადაც JPEGs are

650
00:39:01,070 --> 00:39:06,010
ან, რას ჰგავს, ასე რომ თქვენ შეგიძლიათ გაანალიზოს 0S და 1s და აცხადებენ JPEG, JPEG,

651
00:39:06,010 --> 00:39:09,440
თქვენ შეგიძლიათ დაწეროთ პროგრამა არსებითად მხოლოდ ან ხოლო loop

652
00:39:09,440 --> 00:39:12,820
რომ აღდგება ყოველ ერთ იმ ფაილებს.

653
00:39:12,820 --> 00:39:16,030
ასე რომ გაკვეთილი შემდეგ უნდა დაიწყოს უსაფრთხოდ erasing ფაილი

654
00:39:16,030 --> 00:39:18,340
თუ გსურთ თავიდან ასაცილებლად საერთოდ. დიახ.

655
00:39:18,340 --> 00:39:21,010
>> [სტუდენტი] როგორ მოვა ნათქვამია თქვენს კომპიუტერში

656
00:39:21,010 --> 00:39:23,550
რომ თქვენ უფრო მეტი მეხსიერება, ვიდრე გააკეთეთ თქვენ წინაშე?

657
00:39:23,550 --> 00:39:27,820
კიდევ გაქვთ მეხსიერების ვიდრე გააკეთეთ თქვენ წინაშე - >> [სტუდენტი] უფრო ხელმისაწვდომი მეხსიერება.

658
00:39:27,820 --> 00:39:29,630
Oh. კარგი კითხვაა.

659
00:39:29,630 --> 00:39:32,360
რატომ შემდეგ ვასუფთავებ სანაგვე ყუთს ამჯამად თქვენს კომპიუტერში გითხრათ

660
00:39:32,360 --> 00:39:34,910
რომ თქვენ უფრო მეტი თავისუფალი სივრცე, ვიდრე გააკეთეთ თქვენ წინაშე?

661
00:39:34,910 --> 00:39:36,770
In მოკლედ, რადგან ეს ცრუობს.

662
00:39:36,770 --> 00:39:40,740
გაძლიერებული ტექნიკურად, თუ თქვენ ჩვენგან უფრო სივრცეში, რადგან ახლა თქვენ არ განაცხადა

663
00:39:40,740 --> 00:39:43,680
თქვენ შეგიძლიათ განათავსოთ სხვა პერსონალის სადაც ეს ფაილი ადრე იყო.

664
00:39:43,680 --> 00:39:45,450
მაგრამ ეს არ ნიშნავს, ბიტი ვაპირებთ მოშორებით,

665
00:39:45,450 --> 00:39:48,590
და ეს არ ნიშნავს, ბიტი მიმდინარეობს შეიცვალოს ყველა 0S, მაგალითად,

666
00:39:48,590 --> 00:39:50,150
თქვენი დაცვა.

667
00:39:50,150 --> 00:39:54,640
ასე რომ პირიქით, თუ თქვენ უსაფრთხოდ წაშალოთ ფაილი ან ფიზიკური განადგურებით მოწყობილობის,

668
00:39:54,640 --> 00:39:57,300
რომ ნამდვილად არის ერთადერთი გზა ზოგჯერ გარშემო რომ.

669
00:39:57,300 --> 00:40:02,020
>> მაშ რატომ არ გვაქვს დატოვება რომ ნახევრად საშინელი შენიშვნა, და ვნახავთ თქვენ ორშაბათს.

670
00:40:02,020 --> 00:40:07,000
[ტაში]

671
00:40:07,780 --> 00:40:10,000
>> [CS50.TV]