1
00:00:00,000 --> 00:00:02,490
[Powered by Google Translate] [CS50 ბიბლიოთეკა]

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

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

4
00:00:07,260 --> 00:00:11,510
CS50 ბიბლიოთეკა სასარგებლო ინსტრუმენტი, რომელიც ჩვენ დამონტაჟებული ელექტრო მოწყობილობების

5
00:00:11,510 --> 00:00:15,870
რათა გაუადვილოს ჩემზე პროგრამების სწრაფი მომხმარებლებს შეყვანის.

6
00:00:15,870 --> 00:00:21,670
ამ ვიდეო, ჩვენ უკან დახევის ფარდა და შევხედოთ რა არის CS50 ბიბლიოთეკაში.

7
00:00:21,670 --> 00:00:25,520
>> In ვიდეო C ბიბლიოთეკა, ვსაუბრობთ თუ როგორ # მოიცავს სათაურებში ფაილები

8
00:00:25,520 --> 00:00:27,570
ბიბლიოთეკის თქვენს კოდებს,

9
00:00:27,570 --> 00:00:31,150
და მაშინ კავშირი ორობითი ბიბლიოთეკა ფაილი დროს აკავშირებს ფაზა

10
00:00:31,150 --> 00:00:33,140
საქართველოს compilation პროცესში.

11
00:00:33,140 --> 00:00:36,440
Header ფაილი დააკონკრეტა ინტერფეისი ბიბლიოთეკა.

12
00:00:36,440 --> 00:00:41,280
ანუ, ისინი დეტალურად ყველა რესურსი, რომ ბიბლიოთეკას აქვს ხელმისაწვდომია გამოიყენოთ,

13
00:00:41,280 --> 00:00:45,250
მოსწონს ფუნქცია დეკლარაციების, მუდმივები და მონაცემთა ტიპები.

14
00:00:45,250 --> 00:00:48,890
ორობითი ბიბლიოთეკა ფაილი შეიცავს განხორციელების ბიბლიოთეკა,

15
00:00:48,890 --> 00:00:54,580
რომელიც დგება საწყისი ბიბლიოთეკის header ფაილი და ბიბლიოთეკის. გ კოდის ფაილი.

16
00:00:54,580 --> 00:00:59,820
>> ორობითი ბიბლიოთეკა ფაილი არ არის ძალიან საინტერესო შევხედოთ რადგან, ისევე, როგორც ორობითი.

17
00:00:59,820 --> 00:01:03,300
ასე რომ, მოდით, შევხედოთ header ფაილების ბიბლიოთეკა ნაცვლად.

18
00:01:03,300 --> 00:01:07,710
ამ შემთხვევაში, მხოლოდ ერთი header ფაილი სახელად cs50.h.

19
00:01:07,710 --> 00:01:11,040
ჩვენ დაყენებული ის მომხმარებლის მოიცავს დირექტორია

20
00:01:11,040 --> 00:01:15,150
ერთად სხვა სისტემის ბიბლიოთეკების 'header ფაილი.

21
00:01:15,150 --> 00:01:21,530
>> ერთი პირველი რამ თქვენ შეამჩნევთ არის, რომ cs50.h # მოიცავს header ფაილი სხვა ბიბლიოთეკების -

22
00:01:21,530 --> 00:01:25,670
float, ლიმიტები, სტანდარტული bool, და სტანდარტული lib.

23
00:01:25,670 --> 00:01:28,800
ერთხელ, შემდეგ პრინციპი არ ხელახლა იბრუნებს საჭე,

24
00:01:28,800 --> 00:01:33,490
ჩვენ ავაშენეთ CS0 ბიბლიოთეკის გამოყენებით ინსტრუმენტები, სხვა მოწოდებული ჩვენთვის.

25
00:01:33,490 --> 00:01:38,690
>> შემდეგი რაც თქვენ ნახავთ ბიბლიოთეკაში არის, რომ ჩვენ განსაზღვროს ახალი ტიპის მოუწოდა "string."

26
00:01:38,690 --> 00:01:42,330
ეს ხაზი ნამდვილად უბრალოდ ქმნის alias for char * ტიპის,

27
00:01:42,330 --> 00:01:46,000
ასე რომ არ magically imbue ახალი string ტიპის ატრიბუტები

28
00:01:46,000 --> 00:01:49,650
ჩვეულებრივ ასოცირდება სიმებიანი ობიექტების სხვა ენებზე,

29
00:01:49,650 --> 00:01:50,850
როგორიცაა სიგრძე.

30
00:01:50,850 --> 00:01:55,180
მიზეზი ჩვენ გავაკეთეთ ეს საფარველად ახალი პროგრამისტების საწყისი გორის დეტალები

31
00:01:55,180 --> 00:01:57,580
საქართველოს პოინტერები სანამ ისინი მზად.

32
00:01:57,580 --> 00:02:00,130
>> შემდეგი ნაწილი header ფაილი დეკლარაცია ფუნქციები

33
00:02:00,130 --> 00:02:04,410
რომ CS50 ბიბლიოთეკა უზრუნველყოფს ერთად დოკუმენტაცია.

34
00:02:04,410 --> 00:02:06,940
გაითვალისწინეთ დონეზე დეტალურად კომენტარი აქ.

35
00:02:06,940 --> 00:02:10,560
ეს არის სუპერ მნიშვნელოვანია იმდენად, რომ ადამიანმა იცის როგორ გამოიყენოს ეს ფუნქციები.

36
00:02:10,560 --> 00:02:19,150
ჩვენ ვაცხადებთ, თავის მხრივ, ფუნქციების შეეკითხება მომხმარებელს და დაბრუნების სიმბოლო, ორადგილიანი, მოძრავი, ints,

37
00:02:19,150 --> 00:02:24,160
ხანგრძლივი longs და სიმები, გამოყენებით ჩვენი საკუთარი string ტიპის.

38
00:02:24,160 --> 00:02:26,260
შემდეგ პრინციპი ინფორმაცია მალვის,

39
00:02:26,260 --> 00:02:31,640
ჩვენ დააყენა ჩვენი განმარტება ცალკე. გ განხორციელების ფაილი - cs50.c--

40
00:02:31,640 --> 00:02:35,110
მდებარეობს მომხმარებლის წყაროს დირექტორია.

41
00:02:35,110 --> 00:02:38,040
ჩვენ იმ პირობით, რომ ფაილის ასე რომ თქვენ შეგიძლიათ შევხედოთ მას,

42
00:02:38,040 --> 00:02:41,490
ვისწავლოთ, და recompile იგი სხვადასხვა მანქანები, თუ თქვენ გაქვთ სურვილი,

43
00:02:41,490 --> 00:02:45,510
მიუხედავად იმისა, რომ ჩვენ მიგვაჩნია, რომ ეს უკეთესი მუშაობა ელექტრო ამ კლასში.

44
00:02:45,510 --> 00:02:47,580
ყოველ შემთხვევაში, მოდით შევხედოთ ეს არის.

45
00:02:49,020 --> 00:02:54,620
>> ფუნქციების GetChar, GetDouble, GetFloat, GetInt და GetLongLong

46
00:02:54,620 --> 00:02:58,160
ყველა აგებული ზევით GetString ფუნქცია.

47
00:02:58,160 --> 00:03:01,510
თურმე ისინი ყველა დაიცვას არსებითად იგივე ნიმუში.

48
00:03:01,510 --> 00:03:04,870
ისინი იყენებენ ხოლო loop to შეეკითხება მომხმარებელს ერთი ხაზი შეყვანის.

49
00:03:04,870 --> 00:03:08,430
ისინი დაბრუნდებიან მასივები, თუ მომხმარებლის საშუალებებით ცარიელი ხაზი.

50
00:03:08,430 --> 00:03:11,750
ისინი ცდილობენ გარჩევის მომხმარებლის შეყვანის როგორც შესაბამისი ტიპის,

51
00:03:11,750 --> 00:03:15,010
იქნება ეს char, ორმაგი, float და ა.შ.

52
00:03:15,010 --> 00:03:18,710
შემდეგ კი არც დაბრუნების შედეგი თუ შეყვანის წარმატებით გაანალიზება

53
00:03:18,710 --> 00:03:21,330
ან ისინი reprompt მომხმარებლის.

54
00:03:21,330 --> 00:03:24,230
>> მაღალ დონეზე, არაფერია მართლაც სახიფათო აქ.

55
00:03:24,230 --> 00:03:28,760
ალბათ წერილობითი ანალოგიურად სტრუქტურირებული კოდი თავის წარსულში.

56
00:03:28,760 --> 00:03:34,720
ყველაზე cryptic ორიენტირებული ნაწილი sscanf მოწოდება, რომ parses მომხმარებლის შეყვანის.

57
00:03:34,720 --> 00:03:38,160
Sscanf ნაწილია შეყვანის ფორმატი კონვერტაციის ოჯახს.

58
00:03:38,160 --> 00:03:42,300
იგი ცხოვრობს სტანდარტული io.h და მისი საქმეა გარჩევის C სიმებიანი,

59
00:03:42,300 --> 00:03:46,520
შესაბამისად კონკრეტულ ფორმატის, შენახვა გარჩევის შედეგების ცვლადი

60
00:03:46,520 --> 00:03:48,720
გათვალისწინებული Caller.

61
00:03:48,720 --> 00:03:53,570
წლიდან შეყვანის ფორმატი კონვერტაციის ფუნქციები ძალიან სასარგებლო, ფართოდ გამოიყენება ფუნქციები

62
00:03:53,570 --> 00:03:56,160
რომ არ ვართ სუპერ ინტუიციური თავდაპირველად,

63
00:03:56,160 --> 00:03:58,300
ჩვენ წავიდეთ მეტი როგორ sscanf მუშაობს.

64
00:03:58,300 --> 00:04:03,330
>> პირველი არგუმენტი sscanf არის char * - მომცეთ ხასიათი.

65
00:04:03,330 --> 00:04:05,150
იყიდება ფუნქცია იმუშავებს,

66
00:04:05,150 --> 00:04:08,340
რომ ხასიათი უნდა იყოს პირველი ხასიათი C სიმებიანი,

67
00:04:08,340 --> 00:04:12,270
შეწყვეტილად ერთად null \ 0 ხასიათი.

68
00:04:12,270 --> 00:04:15,120
ეს არის სიმებიანი გარჩევის

69
00:04:15,120 --> 00:04:18,269
მეორე არგუმენტი sscanf არის სტრიქონში,

70
00:04:18,269 --> 00:04:20,839
ჩვეულებრივ გადავიდა როგორც სიმებიანი მუდმივი,

71
00:04:20,839 --> 00:04:24,040
და თქვენ ალბათ არ უნახავს სიმებიანი მოსწონს ეს ადრე, როდესაც გამოყენებით printf.

72
00:04:24,040 --> 00:04:28,650
პროცენტი შესვლა სტრიქონში მიუთითებს კონვერტაციის specifier.

73
00:04:28,650 --> 00:04:30,850
ხასიათი მაშინვე შემდეგ პროცენტს ნიშანი,

74
00:04:30,850 --> 00:04:35,430
მიუთითებს C ტიპის, რომ ჩვენ გვინდა sscanf კონვერრტაციისთვის.

75
00:04:35,430 --> 00:04:40,090
In GetInt, ხედავთ, რომ არსებობს% d და% გ.

76
00:04:40,090 --> 00:04:48,690
ეს ნიშნავს, რომ sscanf შეეცდება ათობითი int -% d - და char -% გ.

77
00:04:48,690 --> 00:04:51,510
თითოეული კონვერტაციის specifier სტრიქონში,

78
00:04:51,510 --> 00:04:56,620
sscanf მოელის შესაბამისი არგუმენტი მოგვიანებით მისი არგუმენტი სიაში.

79
00:04:56,620 --> 00:05:00,850
ეს არგუმენტი უნდა აღვნიშნო, რომ სათანადოდ აკრეფილი საიდან

80
00:05:00,850 --> 00:05:04,000
რომელშიც შესანახად შედეგად კონვერტაცია.

81
00:05:04,000 --> 00:05:08,910
>> ტიპიური გზა ამით შევქმნათ ცვლადი on დასტის სანამ sscanf ზარის

82
00:05:08,910 --> 00:05:11,440
თითოეული ნივთი, რომ გსურთ გარჩევის საწყისი სიმებიანი

83
00:05:11,440 --> 00:05:15,520
და შემდეგ გამოიყენოთ მისამართი ოპერატორი - ampersand - გავლა პოინტერები

84
00:05:15,520 --> 00:05:19,100
იმ ცვლადები sscanf ზარი.

85
00:05:19,100 --> 00:05:22,720
თქვენ ხედავთ, რომ GetInt ვაკეთებთ სწორედ ეს არის.

86
00:05:22,720 --> 00:05:28,240
მარჯვენა ადრე sscanf ზარის ვაცხადებთ, int მოუწოდა N და char ზარის გ შესახებ დასტის,

87
00:05:28,240 --> 00:05:32,340
და ჩვენ გავლა მითითებას მათი sscanf ზარი.

88
00:05:32,340 --> 00:05:35,800
ჩვენ ამ ცვლადის შესახებ დასტის სასურველია მეტი გამოყენებით სივრცეში გამოყოფილი

89
00:05:35,800 --> 00:05:39,350
on ბევრი ერთად malloc, რადგან თქვენ თავიდან ოვერჰედის of malloc ზარი,

90
00:05:39,350 --> 00:05:43,060
და თქვენ არ ინერვიულოთ შესახებ ჩამოდის მეხსიერება.

91
00:05:43,060 --> 00:05:47,280
ჩარი არ prefixed მიერ პროცენტს ნიშანი არ შეეკითხება კონვერტაცია.

92
00:05:47,280 --> 00:05:50,380
პირიქით, უბრალოდ დაამატოთ ფორმატის სპეციფიკაცია.

93
00:05:50,380 --> 00:05:56,500
>> მაგალითად, თუ სტრიქონში წელს GetInt იყო% d ნაცვლად,

94
00:05:56,500 --> 00:05:59,800
sscanf რომ ვეძებოთ წერილს მოჰყვა int,

95
00:05:59,800 --> 00:06:04,360
და სანამ ეს იქნებოდა ცდილობენ კონვერტირება int, რომ ის არ გააკეთებს არაფერი ერთად.

96
00:06:04,360 --> 00:06:07,440
ერთადერთი გამონაკლისი ამ არის whitespace.

97
00:06:07,440 --> 00:06:11,030
თეთრი სივრცეში სიმბოლოების სტრიქონში დაემთხვა რომელიმე თანხის whitespace -

98
00:06:11,030 --> 00:06:12,890
კი არა ყველა.

99
00:06:12,890 --> 00:06:18,100
ასე რომ, ამიტომ კომენტარი აღნიშნავს შესაძლოა წამყვან ან / და გადმოკიდული whitespace.

100
00:06:18,100 --> 00:06:22,910
ასე რომ, ამ ეტაპზე გამოიყურება ჩვენი sscanf ზარის შეეცდება გარჩევის მომხმარებლის შეყვანის სიმებიანი

101
00:06:22,910 --> 00:06:25,380
მიერ შემოწმების შესაძლო წამყვანი whitespace,

102
00:06:25,380 --> 00:06:29,300
მოჰყვა int რომ იქნება მოაქცია და შენახული int ცვლადი N

103
00:06:29,300 --> 00:06:33,090
მოჰყვა რამდენიმე თანხის whitespace, და მოჰყვა ხასიათი

104
00:06:33,090 --> 00:06:35,810
შენახული char ცვლადი გ.

105
00:06:35,810 --> 00:06:37,790
>> რაც შეეხება დაბრუნებული მნიშვნელობა?

106
00:06:37,790 --> 00:06:41,560
Sscanf იქნება გარჩევის შეყვანის ხაზის დასაწყისიდან დასრულებამდე,

107
00:06:41,560 --> 00:06:44,860
შეჩერების, როდესაც იგი აღწევს ბოლოს ან როცა პერსონაჟი შეყვანის

108
00:06:44,860 --> 00:06:49,320
არ შეესაბამება ფორმატის სიმბოლოს ან როდესაც მას არ შეუძლია მიიღოს კონვერტაცია.

109
00:06:49,320 --> 00:06:52,690
მისი დაბრუნების ღირებულება გამოიყენება ერთი როდესაც იგი შეაჩერა.

110
00:06:52,690 --> 00:06:55,670
თუ ეს შეჩერდა, რადგან ეს მიაღწიეს ბოლომდე შეყვანის სიმებიანი

111
00:06:55,670 --> 00:07:00,630
მიღების წინ ნებისმიერი კონვერტაციები და ადრე ვერ ემთხვევა ნაწილი სტრიქონში,

112
00:07:00,630 --> 00:07:04,840
მაშინ სპეციალური მუდმივი EOF უბრუნდება.

113
00:07:04,840 --> 00:07:08,200
წინააღმდეგ შემთხვევაში, ის დააბრუნებს ხმების წარმატებული კონვერტაციის,

114
00:07:08,200 --> 00:07:14,380
რაც შეიძლება იყოს 0, 1, ან 2, რადგან ჩვენ ვთხოვე ორი კონვერტაციის.

115
00:07:14,380 --> 00:07:19,000
ჩვენს შემთხვევაში, ჩვენ გვინდა დავრწმუნდეთ, რომ მომხმარებლის აკრეფილი int და მხოლოდ int.

116
00:07:19,000 --> 00:07:23,370
>> ასე რომ, ჩვენ გვინდა sscanf დაბრუნებას 1. თუ რატომ?

117
00:07:23,370 --> 00:07:26,850
თუ sscanf დაბრუნდა 0, მაშინ არ კონვერტაციის შევიდა,

118
00:07:26,850 --> 00:07:31,690
ასე მომხმარებლის აკრეფილი რაღაც გარდა int დასაწყისში შეყვანის.

119
00:07:31,690 --> 00:07:37,100
თუ sscanf ბრუნდება 2, მაშინ მომხმარებლის საერთოდ სწორად აკრიფოთ ის დასაწყისში შეყვანის,

120
00:07:37,100 --> 00:07:41,390
მაგრამ მაშინ აკრეფილი ზოგიერთი არასამთავრობო whitespace ხასიათი შემდგომ

121
00:07:41,390 --> 00:07:44,940
წლიდან% C კონვერტაციის შედგა.

122
00:07:44,940 --> 00:07:49,570
Wow, რომ საკმაოდ ხანგრძლივი ახსნა ერთი ფუნქცია ზარი.

123
00:07:49,570 --> 00:07:53,460
ყოველ შემთხვევაში, თუ გსურთ მეტი ინფორმაციის sscanf და მისი ძმა,

124
00:07:53,460 --> 00:07:57,130
შეამოწმეთ კაცი გვერდებზე, Google, ან ორივე ერთად.

125
00:07:57,130 --> 00:07:58,780
უამრავი სტრიქონში პარამეტრები,

126
00:07:58,780 --> 00:08:03,830
და ეს შეგიძლიათ შეინახოთ თქვენი უამრავი სახელმძღვანელო შრომის, როდესაც ცდილობს გარჩევის სიმებისათვის C.

127
00:08:03,830 --> 00:08:07,180
>> საბოლოო ფუნქცია ბიბლიოთეკა შევხედოთ არის GetString.

128
00:08:07,180 --> 00:08:10,310
თურმე GetString არის სახიფათო ფუნქციის დაწერა სწორად,

129
00:08:10,310 --> 00:08:14,290
მიუხედავად იმისა, რომ როგორც ჩანს, ასეთი მარტივი, საერთო ამოცანაა.

130
00:08:14,290 --> 00:08:16,170
რატომ არის ამ შემთხვევაში?

131
00:08:16,170 --> 00:08:21,380
კარგად, მოდით ვიფიქროთ, თუ როგორ ვაპირებთ შესანახად ხაზი მომხმარებლის ტიპის სისტემაში

132
00:08:21,380 --> 00:08:23,880
მას შემდეგ, string არის თანმიმდევრობა სიმბოლო,

133
00:08:23,880 --> 00:08:26,430
ჩვენ დაგვჭირდება ჩაწერს მას მასივი on დასტის,

134
00:08:26,430 --> 00:08:31,250
მაგრამ ჩვენ უნდა ვიცოდეთ, რამდენი ხანი მასივი იქნება, როდესაც ვაცხადებთ, რომ ეს.

135
00:08:31,250 --> 00:08:34,030
ანალოგიურად, თუ გვინდა Put It On ბევრი,

136
00:08:34,030 --> 00:08:38,090
ჩვენ გვჭირდება გადავიდეთ malloc ბაიტების რაოდენობას გვინდა რეზერვი,

137
00:08:38,090 --> 00:08:39,730
მაგრამ ეს შეუძლებელია.

138
00:08:39,730 --> 00:08:42,760
ჩვენ არ გვაქვს იდეა რამდენი chars მომხმარებელი აკრიფოთ

139
00:08:42,760 --> 00:08:46,590
ადრე მომხმარებლის რეალურად ამჯამად აკრიფოთ მათ.

140
00:08:46,590 --> 00:08:50,720
>> გულუბრყვილო აღნიშნული პრობლემის მოსაგვარებლად არის მხოლოდ ვიტოვებთ დიდ ბლოკი სივრცის, ვთქვათ,

141
00:08:50,720 --> 00:08:54,540
მრავალბინიანი 1000 chars ამისთვის მომხმარებლის input,

142
00:08:54,540 --> 00:08:57,980
თუ ვივარაუდებთ, რომ მომხმარებლის არასოდეს აკრიფოთ სიმებიანი რომ ხანგრძლივი.

143
00:08:57,980 --> 00:09:00,810
ეს არის ცუდი იდეა ორი მიზეზის გამო.

144
00:09:00,810 --> 00:09:05,280
პირველი, თუ ვივარაუდებთ, რომ მომხმარებლებს როგორც წესი არ აკრიფოთ სტრიქონები რომ ხანგრძლივი,

145
00:09:05,280 --> 00:09:07,610
თქვენ შეიძლება ნარჩენების მეხსიერების დიდ ნაწილს.

146
00:09:07,610 --> 00:09:10,530
თანამედროვე მანქანები, ეს არ შეიძლება იყოს საკითხის თუ ამ

147
00:09:10,530 --> 00:09:13,890
ერთი ან ორი იზოლირებული შემთხვევაში,

148
00:09:13,890 --> 00:09:17,630
მაგრამ თუ თქვენ აღების მომხმარებლის input in loop და შენახვის მოგვიანებით გამოყენება,

149
00:09:17,630 --> 00:09:20,870
თქვენ შეგიძლიათ სწრაფად suck up ტონა მეხსიერება.

150
00:09:20,870 --> 00:09:24,450
გარდა ამისა, თუ პროგრამა თქვენ წერილობით არის პატარა კომპიუტერი -

151
00:09:24,450 --> 00:09:28,100
მოწყობილობის სმარტფონის მსგავსი ან რაღაც შეზღუდული მეხსიერება -

152
00:09:28,100 --> 00:09:32,060
ამ გადაწყვეტა გამოიწვევს პრობლემებს ბევრი უფრო სწრაფად.

153
00:09:32,060 --> 00:09:36,450
მეორე, უფრო სერიოზული მიზეზი, რომ აღარ არის, რომ ის დატოვებს თქვენს პროგრამაში დაუცველი

154
00:09:36,450 --> 00:09:39,710
თუ რა ე.წ. ბუფერული overflow თავდასხმა.

155
00:09:39,710 --> 00:09:45,840
პროგრამირებაში, ბუფერული არის მეხსიერების გამოიყენება დროებით შესანახად შეყვანის ან გამომავალი მონაცემები,

156
00:09:45,840 --> 00:09:48,980
რაც ამ შემთხვევაში არის ჩვენი 1000-char ბლოკი.

157
00:09:48,980 --> 00:09:53,370
ბუფერული overflow ხდება, როდესაც მონაცემები წერია წარსულში ბოლოს ბლოკი.

158
00:09:53,370 --> 00:09:57,790
>> მაგალითად, თუ მომხმარებლის რეალურად აკეთებს ტიპის ზე მეტ 1000 სიმბოლო.

159
00:09:57,790 --> 00:10:01,570
ალბათ გამოცდილი ამ შემთხვევით, როდესაც პროგრამირების ერთად მასივები.

160
00:10:01,570 --> 00:10:05,620
თუ თქვენ გაქვთ მასივი 10 ints, არაფერი აჩერებს თქვენ წაკითხვის მცდელობისას ან ჩაწერის

161
00:10:05,620 --> 00:10:07,810
15 int.

162
00:10:07,810 --> 00:10:10,000
არ არის შემდგენელი გაფრთხილებებისა და შეცდომები.

163
00:10:10,000 --> 00:10:13,250
პროგრამა მხოლოდ შეცდომების სწორი წინ და ხელმისაწვდომი მეხსიერება

164
00:10:13,250 --> 00:10:18,150
სადაც მას მიაჩნია, 15 int იქნება, და ეს შეიძლება ჩაანაცვლებს სხვა ცვლადები.

165
00:10:18,150 --> 00:10:22,040
ყველაზე ცუდ შემთხვევაში, შეგიძლიათ გადავაწერო ზოგიერთი თქვენი პროგრამის შიდა

166
00:10:22,040 --> 00:10:26,820
კონტროლის მექანიზმების, რამაც თქვენი პროგრამის რეალურად შეასრულოს სხვადასხვა მითითებებს

167
00:10:26,820 --> 00:10:28,340
ვიდრე თქვენ განკუთვნილი.

168
00:10:28,340 --> 00:10:31,360
>> ახლა, ეს არ საერთო ამის შემთხვევით,

169
00:10:31,360 --> 00:10:35,150
მაგრამ ეს საკმაოდ გავრცელებული ტექნიკა რომ ცუდები გამოიყენოთ შესვენება პროგრამები

170
00:10:35,150 --> 00:10:39,080
და დააყენა მუქარის კოდი სხვა ხალხის კომპიუტერები.

171
00:10:39,080 --> 00:10:42,910
აქედან გამომდინარე, ჩვენ არ შეგვიძლია ისარგებლეთ ჩვენი გულუბრყვილო გადაწყვეტა.

172
00:10:42,910 --> 00:10:45,590
ჩვენ გვჭირდება თავიდან აცილების საუკეთესო საშუალებაა ჩვენი პროგრამების მიმდინარეობს დაუცველი

173
00:10:45,590 --> 00:10:47,880
დან ბუფერული overflow თავდასხმა.

174
00:10:47,880 --> 00:10:51,430
ამისათვის, ჩვენ უნდა დავრწმუნდეთ, რომ ჩვენი ბუფერული შეგიძლიათ იზრდება როგორც ვკითხულობთ

175
00:10:51,430 --> 00:10:53,850
მეტი შეიტანენ მომხმარებლის.

176
00:10:53,850 --> 00:10:57,440
გამოსავალი? ჩვენ ვიყენებთ ბევრი გამოყოფილი ბუფერული.

177
00:10:57,440 --> 00:10:59,950
მას შემდეგ, რაც ჩვენ შეგვიძლია შემცირება მისი გამოყენება Resize realloc ფუნქცია,

178
00:10:59,950 --> 00:11:04,580
და ჩვენ ტრეკზე ორი ნომერი - მაჩვენებელი მომდევნო ცარიელ ჭრილში ბუფერული

179
00:11:04,580 --> 00:11:08,390
და სიგრძის ან მოცულობა ბუფერული.

180
00:11:08,390 --> 00:11:13,210
ვკითხულობთ chars საწყისი მომხმარებლის ერთ დროს გამოყენებით fgetc ფუნქცია.

181
00:11:13,210 --> 00:11:19,360
არგუმენტი fgetc ფუნქცია იღებს - stdin - არის მინიშნება სტანდარტული input სიმებიანი,

182
00:11:19,360 --> 00:11:23,810
რაც preconnected შეყვანის არხი, რომელიც გამოიყენება გადასცეს მომხმარებლის შეყვანის

183
00:11:23,810 --> 00:11:26,270
საწყისი ტერმინალის პროგრამა.

184
00:11:26,270 --> 00:11:29,890
>> როდესაც მომხმარებლის ტიპის ახალი ხასიათის, ჩვენ შეამოწმეთ, რომ ინდექსი

185
00:11:29,890 --> 00:11:35,810
მომდევნო უფასო სლოტი Plus 1 მეტია მოცულობა ბუფერული.

186
00:11:35,810 --> 00:11:39,690
+1 მოდის რადგან თუ მომავალი უფასო ინდექსი არის 5,

187
00:11:39,690 --> 00:11:44,150
მაშინ ჩვენი ბუფერული მისი სიგრძე უნდა იყოს 6 წყალობით 0 ინდექსირებას.

188
00:11:44,150 --> 00:11:48,350
თუ ჩვენ ამოიწურა სივრცეში ბუფერული, მაშინ ჩვენ ცდილობენ შეცვლის მას,

189
00:11:48,350 --> 00:11:51,690
გააორმაგოს ისე, რომ ჩვენ მოჭრილი რაოდენობის შესახებ ჯერ რომ ჩვენ ზომის შეცვლა

190
00:11:51,690 --> 00:11:54,760
თუ მომხმარებელს აკრეფით მართლაც ხანგრძლივი string.

191
00:11:54,760 --> 00:11:57,950
თუ სიმებიანი აქვს მიღებული ძალიან გრძელი ან თუ ჩვენ ამოიწურა ბევრი მეხსიერება,

192
00:11:57,950 --> 00:12:01,350
ჩვენ გასათავისუფლებლად ჩვენი ბუფერული და დაბრუნების null.

193
00:12:01,350 --> 00:12:04,170
>> საბოლოოდ, ჩვენ დამატება char რომ ბუფერული.

194
00:12:04,170 --> 00:12:08,200
ერთხელ მომხმარებლის ჰიტები შევა ან დაბრუნების, სასიგნალო ახალი ხაზი,

195
00:12:08,200 --> 00:12:12,050
ან სპეციალური char - კონტროლი დ - რომელიც გვიჩვენებს ბოლომდე შეყვანა,

196
00:12:12,050 --> 00:12:16,240
ვაკეთებთ შეამოწმეთ, რომ მომხმარებლის რეალურად აკრეფილი არაფერი ყოფილა.

197
00:12:16,240 --> 00:12:18,820
თუ არა, ვბრუნდებით null.

198
00:12:18,820 --> 00:12:22,280
წინააღმდეგ შემთხვევაში, რადგან ჩვენი ბუფერული ალბათ უფრო დიდი ვიდრე ჩვენ გვჭირდება,

199
00:12:22,280 --> 00:12:24,830
ყველაზე ცუდ შემთხვევაში ეს თითქმის ორჯერ დიდი, როგორც ჩვენ გვჭირდება

200
00:12:24,830 --> 00:12:27,830
რადგან ჩვენ გაორმაგდეს ყოველ ჯერზე ჩვენ შემცირება,

201
00:12:27,830 --> 00:12:31,840
ჩვენ ახალი ასლი string გამოყენებით მხოლოდ თანხის სივრცეში, რომ ჩვენ გვჭირდება.

202
00:12:31,840 --> 00:12:34,220
ჩვენ დაამატოთ Extra 1 დან malloc ზარი,

203
00:12:34,220 --> 00:12:37,810
ასე, რომ არც ერთ ფართი სპეციალური null terminator ხასიათი - \ 0,

204
00:12:37,810 --> 00:12:41,990
რომელიც ჩვენ დამატება to string ერთხელ ჩვენ ასლი დანარჩენი გმირები,

205
00:12:41,990 --> 00:12:45,060
გამოყენებით strncpy ნაცვლად strcpy

206
00:12:45,060 --> 00:12:48,830
ასე, რომ ჩვენ შეგვიძლია მიუთითოთ ზუსტად რამდენი chars გვინდა ასლი.

207
00:12:48,830 --> 00:12:51,690
Strcpy აკოპირებს სანამ ჰიტები \ 0.

208
00:12:51,690 --> 00:12:55,740
მაშინ ჩვენ გასათავისუფლებლად ჩვენი ბუფერული და დააბრუნოს ასლი Caller.

209
00:12:55,740 --> 00:12:59,840
>> ვინ იცოდა ასეთი მარტივი მოჩვენებითი ფუნქცია შეიძლება ასე რთული?

210
00:12:59,840 --> 00:13:02,820
ახლა თქვენ იცით, რა შედის CS50 ბიბლიოთეკაში.

211
00:13:02,820 --> 00:13:06,470
>> ჩემი სახელი არის Nate Hardison, და ეს არის CS50.

212
00:13:06,470 --> 00:13:08,350
[CS50.TV]