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

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

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

4
00:00:08,990 --> 00:00:14,250
>> მომწონს განაცხადა ჩემი ელ, არის ბევრი რამ შეგიძლიათ გამოიყენოთ

5
00:00:14,250 --> 00:00:17,060
გარდა ელექტრო რეალურად გავაკეთოთ პრობლემა კომპლექტი.

6
00:00:17,060 --> 00:00:19,910
ჩვენ გირჩევთ ამას ელექტრო მოწყობილობების მხოლოდ იმიტომ, რომ მაშინ ჩვენ შეგვიძლია უფრო მარტივად დაგეხმაროთ

7
00:00:19,910 --> 00:00:22,070
და ჩვენ ვიცით, როგორ ყველაფერი იმუშავებს.

8
00:00:22,070 --> 00:00:26,950
თუმცა, როგორც ერთი მაგალითი, სადაც შეგიძლიათ გააკეთოთ რამ, თუ, ვთქვათ, თქვენ არ გაქვთ

9
00:00:26,950 --> 00:00:31,570
უნდა ელექტრო მოწყობილობების ან გსურთ მუშაობა მეცნიერების ცენტრი სარდაფი -

10
00:00:31,570 --> 00:00:33,090
რაც რეალურად აქვთ ელექტრო ძალიან -

11
00:00:33,090 --> 00:00:35,150
თუ გსურთ მუშაობა სადმე.

12
00:00:35,150 --> 00:00:42,370
ერთი მაგალითი არ გინახავთ / მსმენია SSH?

13
00:00:44,380 --> 00:00:47,780
SSH ძირითადად ისევე ვუკავშირდები რაღაც.

14
00:00:47,780 --> 00:00:51,340
სინამდვილეში, სწორედ ახლა მე SSHed შევიდა ელექტრო მოწყობილობების.

15
00:00:51,340 --> 00:00:54,290
მე არასოდეს მუშაობა პირდაპირ ელექტრო.

16
00:00:55,930 --> 00:01:01,060
აქ არის ელექტრო და, თუ გადავხედავთ ქვემოთ აქ ხედავთ ამ IP მისამართზე.

17
00:01:01,060 --> 00:01:03,650
მე არასოდეს მუშაობა ელექტრო თვით;

18
00:01:03,650 --> 00:01:08,840
მე ყოველთვის მეტი iTerm2 ფანჯარა / ტერმინალის ფანჯარაში.

19
00:01:08,840 --> 00:01:15,910
შეგიძლია SSH რომ IP მისამართი, SSH jharvard@192.168.129.128.

20
00:01:15,910 --> 00:01:20,390
მახსოვს, რომ ნომერი ძალიან მარტივად იმიტომ რომ ასეთი ლამაზი ნიმუში.

21
00:01:20,390 --> 00:01:24,920
მაგრამ ეს იქნება შემეკითხებით ჩემი პაროლი, და ახლა მე ელექტრო მოწყობილობების.

22
00:01:24,920 --> 00:01:33,060
ძირითადად, ამ ეტაპზე, თუ გახსნა ტერმინალის შიგნით ელექტრო თვით,

23
00:01:33,060 --> 00:01:36,350
ამ ინტერფეისით, თუმცა თქვენ რომ მისი გამოყენება, არის ზუსტად იგივე

24
00:01:36,350 --> 00:01:40,010
როგორც ინტერფეისის მე გამოყენებით მეტი აქ, მაგრამ ახლა თქვენ SSHed.

25
00:01:42,240 --> 00:01:44,920
თქვენ არ SSH რომ ელექტრო მოწყობილობების.

26
00:01:44,920 --> 00:01:52,360
ერთი მაგალითი სხვა ადგილას შეგიძლიათ SSH რომ არის მე საკმაოდ დარწმუნებული გაქვთ იყოს -

27
00:01:52,360 --> 00:01:55,020
Oh. Bigger.

28
00:01:55,020 --> 00:02:01,130
ყველა თქვენგანს უნდა ჰქონდეს სტანდარტულად FAS ანგარიშების შესახებ FAS სერვერები.

29
00:02:01,130 --> 00:02:06,840
ჩემთვის, მინდა SSH to rbowden@nice.fas.harvard.edu.

30
00:02:06,840 --> 00:02:11,610
იგი აპირებს გთხოვოთ, რომ პირველად, და თქვენი პასუხები დადებითია.

31
00:02:11,610 --> 00:02:15,840
ჩემი დაგავიწყდათ უბრალოდ იქნება ჩემი FAS დაგავიწყდათ.

32
00:02:15,840 --> 00:02:22,650
და ახლა, მე SSHed to ლამაზი სერვერებზე და არაფერზე უკან არ დავიხევ მინდა აქ.

33
00:02:22,650 --> 00:02:28,560
ბევრი კლასების თქვენ შესაძლოა, ისევე როგორც 124, ვაპირებთ გაქვთ ატვირთეთ პერსონალის აქ

34
00:02:28,560 --> 00:02:30,950
რეალურად თქვენი პრობლემა კომპლექტი.

35
00:02:30,950 --> 00:02:34,100
მაგრამ ამბობენ თქვენ არ ხელმისაწვდომობის თქვენი მოწყობილობის.

36
00:02:34,100 --> 00:02:37,910
შემდეგ შეგიძლიათ გააკეთოთ რამ, როგორიცაა აქ იგი იტყვის -

37
00:02:37,910 --> 00:02:42,160
ეს არის მხოლოდ ჩვენი მონაკვეთის კითხვები.

38
00:02:42,160 --> 00:02:45,070
იგი მოგთხოვთ ამის გაკეთება წელს ელექტრო მოწყობილობების.

39
00:02:45,070 --> 00:02:47,790
ამის ნაცვლად მე მხოლოდ ამის შესახებ სერვერზე.

40
00:02:47,790 --> 00:02:50,560
მე ვაპირებ unzip რომ.

41
00:02:50,560 --> 00:02:55,670
პრობლემა იქნება, რომ თქვენ გამოიყენება გამოყენებით რაღაც gedit

42
00:02:55,670 --> 00:02:58,160
ან რასაც შიგნით ელექტრო მოწყობილობების.

43
00:02:58,160 --> 00:03:01,830
თქვენ არ გვექნება, რომ FAS სერვერზე.

44
00:03:01,830 --> 00:03:04,110
ეს ყველაფერი უბრალოდ იქნება ეს ტექსტური ინტერფეისით.

45
00:03:04,110 --> 00:03:09,180
ასე, რომ თქვენ შეიძლება არც ერთი, ვცდილობთ ვისწავლოთ ტექსტური რედაქტორი, რომელიც მათ აქვთ.

46
00:03:09,180 --> 00:03:12,130
მათ აქვთ ნანო.

47
00:03:12,130 --> 00:03:14,990
ნანო ჩვეულებრივ საკმაოდ მარტივი.

48
00:03:14,990 --> 00:03:19,470
თქვენ შეგიძლიათ გამოიყენოთ თქვენი ისრებით და ტიპის ნორმალურად.

49
00:03:19,470 --> 00:03:21,250
ასე რომ არ არის ძნელი.

50
00:03:21,250 --> 00:03:24,720
თუ გსურთ მიიღოთ მართლაც ლამაზი შეგიძლიათ გამოიყენოთ Emacs,

51
00:03:24,720 --> 00:03:29,850
რომელიც მე ალბათ არ უნდა გახსნა, რადგან ისიც კი არ ვიცით, როგორ დახურვა Emacs.

52
00:03:29,850 --> 00:03:32,760
კონტროლის X, საკონტროლო C? Yeah.

53
00:03:32,760 --> 00:03:35,310
ან შეგიძლიათ გამოიყენოთ Vim, რაც გამოვიყენო.

54
00:03:35,310 --> 00:03:37,800
და ა.შ. ეს ის თქვენი პარამეტრები.

55
00:03:37,800 --> 00:03:43,830
თუ არ გსურთ, რომ, ასევე, შეგიძლიათ, თუ გადავხედავთ manual.cs50.net--

56
00:03:43,830 --> 00:03:45,410
Oh.

57
00:03:45,410 --> 00:03:49,920
On PC, შეგიძლიათ SSH გამოყენებით საბაღე,

58
00:03:49,920 --> 00:03:51,940
რაც თქვენ ვაპირებთ უნდა ჩამოტვირთოთ ცალკე.

59
00:03:51,940 --> 00:03:55,460
On Mac, შეგიძლიათ უბრალოდ იყოს გამოყენების ტერმინალის ან შეგიძლიათ ჩამოტვირთოთ iTerm2,

60
00:03:55,460 --> 00:03:58,490
რაც მოსწონს ლამაზი, ლამაზი ტერმინალი.

61
00:03:58,490 --> 00:04:03,780
თუ წასვლა manual.cs50.net დაინახავთ ბმული ჩასაწერი + +,

62
00:04:03,780 --> 00:04:07,120
რაც შეგიძლიათ გამოიყენოთ on PC.

63
00:04:07,120 --> 00:04:13,340
იგი საშუალებას გაძლევთ SFTP საწყისი ჩასაწერი + +, რომელიც ძირითადად SSH.

64
00:04:13,340 --> 00:04:17,750
რა ამ შევძლებთ თქვენ გააკეთოთ შეასწოროთ თქვენი ფაილი ადგილობრივად,

65
00:04:17,750 --> 00:04:20,670
და მაშინ, როცა მოისურვებთ მათი შენახვა, ის შენახვა nice.fas,

66
00:04:20,670 --> 00:04:23,670
სადაც შეგიძლიათ შემდეგ აწარმოებს მათ.

67
00:04:23,670 --> 00:04:26,880
და ექვივალენტი on Mac იქნება TextWrangler.

68
00:04:26,880 --> 00:04:28,760
ასე რომ გაძლევთ გავაკეთოთ იგივე.

69
00:04:28,760 --> 00:04:32,800
იგი საშუალებას გაძლევთ რედაქტირების ფაილი ადგილობრივად და მათი შენახვა nice.fas,

70
00:04:32,800 --> 00:04:35,730
სადაც შეგიძლიათ შემდეგ აწარმოებს მათ.

71
00:04:35,730 --> 00:04:40,400
ასე რომ, თუ თქვენ ოდესმე დავრჩებოდით გარეშე ელექტრო მოწყობილობების, თქვენ გაქვთ ეს პარამეტრები

72
00:04:40,400 --> 00:04:44,230
კიდევ თქვენი პრობლემა კომპლექტი.

73
00:04:44,230 --> 00:04:48,250
ერთი პრობლემა იქნება, რომ თქვენ არ აპირებს CS50 ბიბლიოთეკა

74
00:04:48,250 --> 00:04:51,580
რადგან nice.fas არ იყოს აქვს, რომ.

75
00:04:51,580 --> 00:04:55,970
თქვენ შეგიძლიათ ან ჩამოტვირთოთ CS50 ბიბლიოთეკა -

76
00:04:55,970 --> 00:04:58,470
არა მგონია, მე უნდა, რომ ამ ეტაპზე.

77
00:04:58,470 --> 00:05:03,270
თქვენ შეგიძლიათ ან ჩამოტვირთოთ CS50 ბიბლიოთეკა და კოპირება მეტი nice.fas,

78
00:05:03,270 --> 00:05:07,450
ან მე ვფიქრობ, ამ ეტაპზე ჩვენ არ ვიყენებთ მას აღარ ჩათვალა.

79
00:05:07,450 --> 00:05:12,720
ან თუ ჩვენ გავაკეთებთ, შეგიძლიათ ამ დროისათვის შეცვალოს იგი

80
00:05:12,720 --> 00:05:18,480
განსახორციელებლად ფუნქციებს CS50 ბიბლიოთეკა მაინც.

81
00:05:18,480 --> 00:05:21,370
ასე რომ არ უნდა იყოს, რომ ბევრი შეზღუდვა.

82
00:05:21,370 --> 00:05:23,710
სწორედ რომ.

83
00:05:26,460 --> 00:05:29,820
>> მე დაბრუნდებით ელექტრო ახლა, ჩვენ გავაკეთებთ ყველაფერს ელექტრო მოწყობილობების.

84
00:05:29,820 --> 00:05:37,510
ეძებს ჩვენს განყოფილებაში კითხვები, დასაწყისში, ისევე როგორც მე ვთქვი ჩემი ელ,

85
00:05:37,510 --> 00:05:43,620
ჩვენ უნდა ვილაპარაკოთ ერთი მოკლე თქვენ უნდა უყუროთ.

86
00:05:43,620 --> 00:05:51,980
ჩვენ გვყავს გადამისამართება & მილები და ეს სამი კითხვები.

87
00:05:51,980 --> 00:05:56,070
>> რომლის ნაკადი არ ფუნქციების მსგავსად printf წერენ იყოს?

88
00:05:56,070 --> 00:05:59,130
ამიტომ ნაკადი. რა არის ნაკადი?

89
00:06:06,520 --> 00:06:15,100
ნაკადი ძირითადად მოსწონს ეს მხოლოდ რამდენიმე -

90
00:06:15,100 --> 00:06:21,450
ეს კი არ წყაროს 1s და 0S.

91
00:06:21,450 --> 00:06:24,920
ნაკადი ის ითხოვს აქ არის სტანდარტული გარეთ.

92
00:06:24,920 --> 00:06:27,250
და ასე სტანდარტული გარეთ არის ნაკადი, რომ როდესაც წერთ კი

93
00:06:27,250 --> 00:06:30,940
როგორც ჩანს ეკრანზე.

94
00:06:30,940 --> 00:06:36,860
სტანდარტული გარეთ, რომელსაც ნაკადი, ეს იმას ნიშნავს, თქვენ უბრალოდ დაწერეთ 1s და 0S კი

95
00:06:36,860 --> 00:06:40,220
და სხვა ბოლოს სტანდარტი მხოლოდ ნათქვამია, რომ ნაკადი.

96
00:06:40,220 --> 00:06:43,540
უბრალოდ string of 1s და 0S.

97
00:06:43,540 --> 00:06:45,570
შეგიძლიათ მიწეროთ ნაკადს ან შეგიძლიათ წაკითხვის ნაკადს

98
00:06:45,570 --> 00:06:47,950
დამოკიდებულია რა ნაკადი რეალურად არის.

99
00:06:47,950 --> 00:06:52,800
დანარჩენი ორი წევრი ნაკადს არის სტანდარტული და სტანდარტული შეცდომა.

100
00:06:52,800 --> 00:06:57,540
სტანდარტი არის როდესაც თქვენ ჩვენგან GetString, ეს გელოდებათ შესაყვანად პერსონალი.

101
00:06:57,540 --> 00:07:01,570
ასე რომ გელით, სინამდვილეში ელოდება სტანდარტული წელს,

102
00:07:01,570 --> 00:07:04,880
რაც რეალურად რა თქვენ, როდესაც თქვენ აკრიფეთ კლავიატურაზე.

103
00:07:04,880 --> 00:07:07,530
თქვენ აკრეფით შევიდა სტანდარტული სისტემაში

104
00:07:07,530 --> 00:07:10,050
სტანდარტული შეცდომა ძირითადად ეკვივალენტი სტანდარტის out,

105
00:07:10,050 --> 00:07:13,280
მაგრამ სპეციალიზებული, რომ როდესაც თქვენ ბეჭდვა სტანდარტული შეცდომა,

106
00:07:13,280 --> 00:07:16,770
თქვენ უნდა მხოლოდ ბეჭდვა შეცდომის შეტყობინებები, რომ

107
00:07:16,770 --> 00:07:20,200
ასე რომ თქვენ შეგიძლიათ დიფერენცირება შორის რეგულარული შეტყობინებები დაბეჭდილი რომ ეკრანზე

108
00:07:20,200 --> 00:07:24,560
წინააღმდეგ შეცდომის შეტყობინებები დამოკიდებულია თუ არა ისინი წავიდნენ სტანდარტული გამოსვლა ან სტანდარტული შეცდომა.

109
00:07:24,560 --> 00:07:28,660
ფაილები ძალიან.

110
00:07:28,660 --> 00:07:32,440
სტანდარტული out, სტანდარტების, და სტანდარტული შეცდომა მხოლოდ სპეციალური ნაკადს,

111
00:07:32,440 --> 00:07:36,810
მაგრამ ნამდვილად ნებისმიერი ფაილი, როდესაც თქვენ გახსნა ფაილი, ის ხდება ნაკადი ბაიტი

112
00:07:36,810 --> 00:07:40,740
სადაც შეგიძლიათ მხოლოდ წაკითხვის, რომ ნაკადი.

113
00:07:40,740 --> 00:07:47,770
თქვენ, ამისთვის დიდი ნაწილი, უბრალოდ ვფიქრობ ფაილი, როგორც ნაკადი bytes.

114
00:07:47,770 --> 00:07:51,190
მერე რა ნაკადს ვერ ვწერ იყოს? სტანდარტული გარეთ.

115
00:07:51,190 --> 00:07:56,980
>> რა სხვაობაა> და >>?

116
00:07:58,140 --> 00:08:03,710
ხომ არავის უყუროთ ვიდეო წინასწარ? Okay.

117
00:08:03,710 --> 00:08:10,960
> იქნება თუ როგორ გადამისამართება შევიდა ფაილი

118
00:08:10,960 --> 00:08:15,240
და >> ასევე აპირებს გადამისამართება გამომავალი შევიდა ფაილი

119
00:08:15,240 --> 00:08:17,820
მაგრამ ნაცვლად აპირებს დამატება ფაილი.

120
00:08:17,820 --> 00:08:23,430
მაგალითად, ვთქვათ მე ემართება აქვს dict უფლება აქ,

121
00:08:23,430 --> 00:08:27,020
და მხოლოდ პერსონალის შიგნით dict არის კატა, კატა, ძაღლი, თევზი, ძაღლი.

122
00:08:27,020 --> 00:08:31,530
ერთი ბრძანება, რომ თქვენ გაქვთ ბრძანებათა ზოლი არის კატა,

123
00:08:31,530 --> 00:08:34,539
რომელიც მხოლოდ აპირებს ბეჭდვა რა ფაილი.

124
00:08:34,539 --> 00:08:40,679
ამიტომ როდესაც ვამბობ, რომ CAT dict, ის აპირებს ბეჭდვა კატა, კატა, ძაღლი, თევზი, ძაღლი. ეს იყო კატა აკეთებს.

125
00:08:40,679 --> 00:08:46,280
ეს იმას ნიშნავს, რომ დაბეჭდილი სტანდარტული გარეთ კატა, კატა, ძაღლი, თევზი, ძაღლი.

126
00:08:46,280 --> 00:08:53,240
თუ მე მინდა ნაცვლად გადამისამართება, რომ ფაილი, შემიძლია> და გადამისამართება მას რასაც ფაილი.

127
00:08:53,240 --> 00:08:56,460
მე მოვუწოდებ ფაილი ფაილის.

128
00:08:56,460 --> 00:09:00,320
ახლა თუ ls, მე ვხედავ მე ახალი ფაილი სახელად ფაილი.

129
00:09:00,320 --> 00:09:05,700
და თუ გავხსნა ეს, ის აპირებს ზუსტად რა cat დააყენა ბრძანებათა ზოლს.

130
00:09:05,700 --> 00:09:11,040
ახლა, თუ რომ ერთხელ, მაშინ იგი ხდება გადამისამართება გამომავალი შევიდა ფაილი,

131
00:09:11,040 --> 00:09:13,930
და მე ვაპირებ აქვს იგივე ზუსტი რამ.

132
00:09:13,930 --> 00:09:17,910
ასე რომ ტექნიკურად, იგი მთლიანად overrode, რაც ჩვენ გვქონდა.

133
00:09:17,910 --> 00:09:22,970
ჩვენ დავინახავთ, თუ შევცვალო dict, მე ამოიღეს ძაღლი.

134
00:09:22,970 --> 00:09:29,980
ახლა თუ ჩვენ cat dict შევიდა ფაილის ერთხელ, ჩვენ ვაპირებთ აქვს ახალი ვერსია ძაღლით ამოიღეს.

135
00:09:29,980 --> 00:09:32,400
ამიტომ იგი მთლიანად overrides იგი.

136
00:09:32,400 --> 00:09:36,640
სამაგიეროდ, თუ ჩვენ ვიყენებთ >>, ის აპირებს დამატება ფაილი.

137
00:09:36,640 --> 00:09:40,860
ახლა გახსნის ფაილი, ჩვენ ვხედავთ ჩვენ ცოტა ხნის წინ იგივე დაბეჭდილი ორჯერ

138
00:09:40,860 --> 00:09:44,920
რადგან ეს იყო იქ ერთხელ, მაშინ ჩვენ დაემატება ორიგინალური.

139
00:09:44,920 --> 00:09:48,130
ასე რომ რა> და >> გავაკეთოთ.

140
00:09:48,130 --> 00:09:50,580
ამჯამად შემდეგი ერთი კითხვა - ეს არ ეკითხება ამის შესახებ.

141
00:09:50,580 --> 00:09:59,050
>> მეორე, რომ ჩვენ გვაქვს არის <, რომელიც თუ> გადამისამართებების სტანდარტული out,

142
00:09:59,050 --> 00:10:01,970
<იქნება გადამისამართება სტანდარტული სისტემაში

143
00:10:01,970 --> 00:10:12,050
ვნახოთ, თუ ჩვენ გვაქვს მაგალითი.

144
00:10:14,750 --> 00:10:16,930
მე შეგიძლიათ დაწეროთ ერთი რეალური სწრაფი.

145
00:10:17,870 --> 00:10:25,700
ავიღოთ ნებისმიერი ფაილი, hello.c.

146
00:10:56,060 --> 00:10:59,070
შედარებით მარტივია ფაილი.

147
00:10:59,070 --> 00:11:03,570
მე უბრალოდ მიღების სიმებიანი და შემდეგ ბეჭდვა "Hello" რასაც სიმებიანი უბრალოდ შევიდა იყო.

148
00:11:03,570 --> 00:11:07,990
ასე რომ მიესალმები და შემდეგ. / Hello.

149
00:11:07,990 --> 00:11:10,720
ახლა კი რითაც ჩემთვის შესვლის რაღაც,

150
00:11:10,720 --> 00:11:15,070
რაც იმას ნიშნავს, რომ ის ელოდება on რამ უნდა შევიდა სტანდარტული სისტემაში

151
00:11:15,070 --> 00:11:20,450
ასე რომ შევა რასაც მინდა შევიდა სტანდარტული შემოსული ჩვენ უბრალოდ აპირებს მიესალმები, რობ!

152
00:11:20,450 --> 00:11:23,310
მაშინ ის დაბეჭდვის სტანდარტული გარეთ Hello, რობ!

153
00:11:23,310 --> 00:11:28,860
თუ. / მიესალმები და შემდეგ გადამისამართება,

154
00:11:30,740 --> 00:11:34,310
ახლა თქვენ შეგიძლიათ მხოლოდ გადამისამართება ფაილიდან.

155
00:11:34,310 --> 00:11:41,720
ასე რომ, თუ მე ზუსტად ზოგიერთ ფაილი, TXT, და მე ზუსტად რობ,

156
00:11:41,720 --> 00:11:52,300
თუ აწარმოებს მიესალმები და შემდეგ გადამისამართება ფაილი txt შევიდა. / Hello, ის აპირებს მიესალმები, რობ! დაუყოვნებლივ.

157
00:11:52,300 --> 00:11:57,160
როდესაც იგი პირველი იღებს GetString და ის ელოდება სტანდარტული წელს,

158
00:11:57,160 --> 00:12:01,730
სტანდარტი აღარ ელოდება ხელს კლავიატურაზე მონაცემთა მისაღებად შევიდა.

159
00:12:01,730 --> 00:12:05,980
სამაგიეროდ, ჩვენ გადამისამართებულ სტანდარტების წაკითხვის ფაილი txt.

160
00:12:05,980 --> 00:12:10,290
და ამიტომ აპირებს წაკითხვის ფაილი txt, რომელიც მხოლოდ ხაზის რობ,

161
00:12:10,290 --> 00:12:13,380
და მაშინ იგი აპირებს ბეჭდვა Hello, რობ!

162
00:12:13,380 --> 00:12:18,180
და თუ მინდოდა, მე ვერ გააკეთოს. / მიესალმები <txt

163
00:12:18,180 --> 00:12:21,500
და შემდეგ სტანდარტული, რომ მისი ბეჭდვა, რომელიც Hello, რობ,,

164
00:12:21,500 --> 00:12:24,700
შემიძლია გადამისამართება, რომ მისი საკუთარი ფაილი.

165
00:12:24,700 --> 00:12:29,790
მე უბრალოდ მოვუწოდებ ფაილი მიესალმები - არა, მე არ, რადგან ისინი შესრულებადი - txt2.

166
00:12:29,790 --> 00:12:40,150
ახლა, txt2 აპირებს აქვს გამოშვება. / მიესალმები <txt, რომელიც იქნება Hello, რობ!

167
00:12:41,370 --> 00:12:43,520
>> კითხვები?

168
00:12:45,900 --> 00:12:49,090
>> Okay. ასე შემდეგ აქ გვაქვს მილსადენი.

169
00:12:49,090 --> 00:12:53,510
მილები ბოლო ერთეული გადამისამართება.

170
00:12:53,510 --> 00:12:58,750
>> Oh. ვფიქრობ კიდევ ერთი ერთეული გადამისამართება არის თუ ნაცვლად> ხაზვის 2>,

171
00:12:58,750 --> 00:13:01,070
რომ გადამისამართება სტანდარტული შეცდომა.

172
00:13:01,070 --> 00:13:06,280
ასე რომ, თუ რამე წავიდა სტანდარტული შეცდომა, ის არ მიიღოთ ამოქმედებული txt2.

173
00:13:06,280 --> 00:13:12,480
მაგრამ შეამჩნევს თუ 2>, მაშინ ეს ჯერ კიდევ ბეჭდვის Hello, რობ! ბრძანების ხაზი

174
00:13:12,480 --> 00:13:18,600
რადგან მე მხოლოდ გადამისამართება სტანდარტული შეცდომა, მე არ გადამისამართება სტანდარტული გარეთ.

175
00:13:18,600 --> 00:13:22,210
სტანდარტული შეცდომა და სტანდარტული გარეთ განსხვავებულია.

176
00:13:24,210 --> 00:13:27,080
თუ უნდოდა რეალურად ჩაწერის სტანდარტული შეცდომა,

177
00:13:27,080 --> 00:13:35,080
მაშინ მე ვერ შეცვლის ეს უნდა იყოს fprintf to stderr.

178
00:13:35,080 --> 00:13:37,850
ამიტომ printf, ჩვეულებრივ, ბეჭდავს სტანდარტული გარეთ.

179
00:13:37,850 --> 00:13:41,720
თუკი მინდა ბეჭდვა სტანდარტული შეცდომა ხელით, მაშინ მე უნდა გამოვიყენოთ fprintf

180
00:13:41,720 --> 00:13:45,010
და დააკონკრეტა, თუ რა მინდა ბეჭდვა.

181
00:13:45,010 --> 00:13:49,720
თუ ნაცვლად მე fprintf stdout, მაშინ ეს ძირითადად ექვივალენტი printf.

182
00:13:49,720 --> 00:13:55,530
მაგრამ fprintf სტანდარტული შეცდომა.

183
00:13:57,790 --> 00:14:03,650
ახლა, თუ გადამისამართება ამ შევიდა txt2, Hello, რობ! კვლავ მიღების დაბეჭდილი ბრძანებათა ზოლს

184
00:14:03,650 --> 00:14:08,270
რადგან არც დაბეჭდილი სტანდარტული შეცდომა და მე მხოლოდ გადამისამართება სტანდარტული გარეთ.

185
00:14:08,270 --> 00:14:16,420
თუ მე ახლა გადამისამართება სტანდარტული შეცდომა, ახლა კი ვერ დაბეჭდილი და txt2 იქნება Hello, რობ!

186
00:14:16,420 --> 00:14:21,910
ახლა, თქვენ შეგიძლიათ ამობეჭდოთ თქვენი ფაქტობრივი შეცდომების სტანდარტული შეცდომა

187
00:14:21,910 --> 00:14:24,720
და ბეჭდვა თქვენი რეგულარული შეტყობინებები სტანდარტული გარეთ.

188
00:14:24,720 --> 00:14:31,420
და ამრიგად, როდესაც თქვენ აწარმოებს თქვენი პროგრამის, შეგიძლიათ გაუშვათ როგორც. / მიესალმები ამ ტიპის 2>

189
00:14:31,420 --> 00:14:33,800
ისე, რომ თქვენი პროგრამის მიღებას აპირებს ნორმალურად,

190
00:14:33,800 --> 00:14:38,400
მაგრამ ნებისმიერი შეცდომის შეტყობინებები, რომ თქვენ შეგიძლიათ შეამოწმოთ მოგვიანებით თქვენს შეცდომების ლოგი,

191
00:14:38,400 --> 00:14:44,500
ასე შეცდომები, და შემდეგ შეხედეთ მოგვიანებით და თქვენი შეცდომები ფაილი ექნება ნებისმიერი შეცდომები, რაც მოხდა.

192
00:14:45,200 --> 00:14:47,540
>> კითხვები?

193
00:14:47,540 --> 00:14:58,070
>> ბოლო ერთი მილსადენი, რომელიც შეგიძლიათ წარმოიდგინოთ, რომ როგორც აღების სტანდარტული აქედან ერთი ბრძანება

194
00:14:58,070 --> 00:15:01,210
და რაც სტანდარტი მომდევნო ბრძანება.

195
00:15:01,210 --> 00:15:05,570
მაგალითად აქ არის გამოძახილი არის command line რამ

196
00:15:05,570 --> 00:15:11,840
რომ მხოლოდ აპირებს echo რასაც მე, როგორც მისი არგუმენტი. მე არ დააყენოს შეთავაზებები.

197
00:15:11,840 --> 00:15:16,150
ეხო blah, blah, blah მხოლოდ აპირებს ბეჭდვა blah, blah, blah.

198
00:15:16,150 --> 00:15:20,600
მანამდე, როდესაც მე ვუთხარი, დააყენოს რობ შევიდა txt ფაილი

199
00:15:20,600 --> 00:15:28,830
რადგან მე შემიძლია მხოლოდ გადამისამართება txt ფაილი, ნაცვლად, / თუ echo რობ

200
00:15:28,830 --> 00:15:35,520
და მაშინ მილის იგი. / Hello, რომელიც ასევე იგივე ტიპის რამ.

201
00:15:35,520 --> 00:15:39,160
ეს ხდება გამოშვებულ ამ ბრძანების ეხო რობ,

202
00:15:39,160 --> 00:15:43,610
და იყენებს მას, როგორც შეყვანის მიზნით. / hello.

203
00:15:44,790 --> 00:15:49,560
თქვენ შეგიძლიათ ვფიქრობ, რომ ეს პირველი გადამისამართება ეხო რობ შევიდა ფაილი

204
00:15:49,560 --> 00:15:54,160
და შემდეგ წვლილის შეტანა. / მიესალმები რომ ფაილი, რომელიც იყო მხოლოდ outputted.

205
00:15:54,160 --> 00:15:57,850
მაგრამ ეს ხდება დროებითი ფაილის გარეთ Picture.

206
00:16:01,890 --> 00:16:04,460
>> კითხვები რომ?

207
00:16:04,460 --> 00:16:07,150
>> შემდეგი შეკითხვა აპირებს ჩაერთოს ამ.

208
00:16:07,150 --> 00:16:15,310
რა მილსადენის იქნებ გამოიყენოთ მოძიების პუნქტების უნიკალური სახელების ფაილი სახელად names.txt?

209
00:16:15,310 --> 00:16:24,160
ბრძანებები ჩვენ ვაპირებთ გინდათ გამოიყენოთ აქ არის უნიკალური, ასე რომ uniq და შემდეგ WC.

210
00:16:24,160 --> 00:16:28,840
ამის გაკეთება შეგიძლიათ კაცს uniq რეალურად შევხედოთ რა, რომ ასეა,

211
00:16:28,840 --> 00:16:34,840
და ეს მხოლოდ აპირებს გავფილტროთ მიმდებარე შესატყვისი ხაზები საწყისი შეყვანის.

212
00:16:34,840 --> 00:16:40,690
და კაცი WC აპირებს ბეჭდვა სტრიქონების გადატანით, სიტყვა, და ბიტიანი ითვლის თითოეული ფაილი.

213
00:16:40,690 --> 00:16:43,760
და ბოლოს ერთი ჩვენ ვაპირებთ გინდათ გამოიყენოთ არის დახარისხების,

214
00:16:43,760 --> 00:16:47,410
რომელიც აპირებს მხოლოდ დასალაგებლად ხაზების txt ფაილი.

215
00:16:47,410 --> 00:16:58,080
თუ მე რაღაც txt ფაილი, names.txt და ეს რობ, ტომი, იოსები, Tommy, იოსები, RJ, რობ,

216
00:16:58,080 --> 00:17:03,910
რა მინდა აქ არის იპოვოს პუნქტების უნიკალური სახელები ამ ფაილის.

217
00:17:03,910 --> 00:17:08,750
მერე რა უნდა იყოს პასუხი? >> [სტუდენტი] 4. >> Yeah.

218
00:17:08,750 --> 00:17:13,780
ეს უნდა იყოს 4 წლიდან რობ, ტომი, იოსები, RJ ერთადერთი უნიკალური სახელები ამ ფაილის.

219
00:17:13,780 --> 00:17:20,180
პირველი ნაბიჯი, თუ უბრალოდ სიტყვის იმედი names.txt,

220
00:17:20,180 --> 00:17:24,290
ამ ფაქტობრივად მეუბნებოდა ყველაფერი.

221
00:17:24,290 --> 00:17:32,560
ეს არის რეალურად ბეჭდვის - ვნახოთ, კაცი WC - newlines, სიტყვა, და ბიტიანი რაოდენობა.

222
00:17:32,560 --> 00:17:38,270
თუ მე მხოლოდ აინტერესებს ხაზები, მაშინ მე შემიძლია უბრალოდ WC-მ names.txt.

223
00:17:41,730 --> 00:17:44,300
ასე რომ ნაბიჯი 1.

224
00:17:44,300 --> 00:17:50,510
მაგრამ მე არ მინდა, რომ WC-მ names.txt რადგან names.txt უბრალოდ შეიცავს ყველა სახელები,

225
00:17:50,510 --> 00:17:54,170
და მინდა გავფილტროთ ნებისმიერი არასამთავრობო უნიკალური მიიჩნიეს.

226
00:17:54,170 --> 00:18:01,200
ასე რომ, თუ uniq names.txt, რომ არ საკმაოდ მომეცი რა მინდა

227
00:18:01,200 --> 00:18:03,760
რადგან დუბლირებული სახელები დღესაც არსებობს.

228
00:18:03,760 --> 00:18:07,690
რატომ არის, რომ? რატომ uniq არ აკეთებს რაც მე მინდა?

229
00:18:07,690 --> 00:18:10,500
[სტუდენტი] დუბლიკატები არ არის [inaudible] >> Yeah.

230
00:18:10,500 --> 00:18:16,370
დამახსოვრება man გვერდი uniq ამბობს ფილტრაციის მიმდებარე დამთხვევა ხაზები.

231
00:18:16,370 --> 00:18:19,680
ისინი არ მიმდებარე, ასე რომ არ გავფილტროთ მათ.

232
00:18:19,680 --> 00:18:31,100
თუ მე დასალაგებლად მათ პირველი, დალაგება names.txt გეგმავს ყველა დუბლიკატი ხაზები ერთად.

233
00:18:31,100 --> 00:18:34,450
ახლა დალაგების names.txt არის, რომ.

234
00:18:34,450 --> 00:18:40,550
მე ვაპირებ გინდათ გამოიყენოთ, რომ როგორც შეყვანის to uniq, რომელიც | uniq.

235
00:18:40,550 --> 00:18:43,390
რომელიც მაძლევს ჯოზეფ, RJ, რობ, ტომი,

236
00:18:43,390 --> 00:18:49,260
და მინდა, რომ როგორც შეყვანის to WC-მ,

237
00:18:49,260 --> 00:18:52,740
რომელიც აპირებს მომეცი 4.

238
00:18:52,740 --> 00:18:56,930
როგორც ეს ამბობს აქ, რა მილსადენის იქნებ გამოვიყენოთ?

239
00:18:56,930 --> 00:19:01,390
შეგიძლიათ ბევრი რამ, როგორიცაა გამოყენებით სერია ბრძანებები

240
00:19:01,390 --> 00:19:05,130
სადაც თქვენ გამოიყენოს გამომავალი ერთი ბრძანება, როგორც შეყვანის შემდეგ ბრძანება.

241
00:19:05,130 --> 00:19:08,780
შეგიძლიათ ბევრი რამ, ბევრი ჭკვიანი რამ.

242
00:19:08,780 --> 00:19:11,440
>> კითხვები?

243
00:19:12,910 --> 00:19:14,600
Okay.

244
00:19:14,600 --> 00:19:17,880
სწორედ ეს მილები და გადამისამართება.

245
00:19:18,370 --> 00:19:24,090
>> ახლა ჩვენ რა იქნება ნამდვილი პერსონალის, კოდირების პერსონალი.

246
00:19:24,090 --> 00:19:29,100
შიგნით ამ PDF, თქვენ ნახავთ ამ ბრძანების

247
00:19:29,100 --> 00:19:32,950
და თქვენ სურთ ამ ბრძანების თქვენს ელექტრო მოწყობილობების.

248
00:19:36,240 --> 00:19:42,250
wget არის ბრძანება მხოლოდ მიღების რაიმე ინტერნეტი, ძირითადად,

249
00:19:42,250 --> 00:19:45,180
ასე wget და ამ URL.

250
00:19:45,180 --> 00:19:49,110
თუ წავიდა ამ URL თქვენს ბრაუზერში, ეს იქნებოდა ჩამოტვირთოთ რომ ფაილი.

251
00:19:49,110 --> 00:19:52,510
მე უბრალოდ დაწკაპავთ მას, ასე რომ გადმოწერილი ფაილი ჩემთვის.

252
00:19:52,510 --> 00:19:55,650
მაგრამ წერილობით wget რომ რამ შიგნით ტერმინალში

253
00:19:55,650 --> 00:19:58,620
უბრალოდ აპირებს ჩამოტვირთოთ იგი თქვენი ტერმინალში.

254
00:19:58,620 --> 00:20:02,750
მაქვს section5.zip, და თქვენ გსურთ unzip section5.zip,

255
00:20:02,750 --> 00:20:06,520
რომელიც აპირებს მოგცემთ საქაღალდეში მოუწოდა section5,

256
00:20:06,520 --> 00:20:11,550
რომელიც აპირებს ყველა ფაილი ჩვენ ვაპირებთ იყოს გამოყენებით დღეს შიგნით მას.

257
00:20:33,380 --> 00:20:37,710
როგორც ამ პროგრამების 'ფაილის სახელები ვარაუდობენ, ისინი ცოტა buggy,

258
00:20:37,710 --> 00:20:40,990
ასე რომ თქვენი მისიაა გაერკვნენ, თუ რატომ იყენებს GDB.

259
00:20:40,990 --> 00:20:44,560
ამჯამად ყველას არ მათ გადმოწერილი / ვიცით თუ როგორ უნდა მათ გადმოწერილი

260
00:20:44,560 --> 00:20:47,480
თავიანთ ელექტრო? Okay.

261
00:20:47,480 --> 00:20:56,400
>> Running ./buggy1, ის იტყვის სეგმენტაცია ბრალია (ბირთვი dumped),

262
00:20:56,400 --> 00:21:00,500
რომელიც ნებისმიერ დროს თქვენ მიიღებთ segfault, ეს ცუდი რამ.

263
00:21:00,500 --> 00:21:03,810
რა გარემოებებში იღებთ segfault?

264
00:21:03,810 --> 00:21:08,210
[სტუდენტი] Dereferencing null მაჩვენებელი. >> Yeah. ასე რომ არის ერთი მაგალითი.

265
00:21:08,210 --> 00:21:11,580
Dereferencing null კურსორი თქვენ აპირებს მიიღოს segfault.

266
00:21:11,580 --> 00:21:16,720
რა segfault ნიშნავს, თქვენ ეხება მეხსიერების თქვენ არ უნდა ეხება.

267
00:21:16,720 --> 00:21:21,350
ამიტომ dereferencing null მაჩვენებელი არის ეხება მისამართი 0,

268
00:21:21,350 --> 00:21:28,060
და ძირითადად, ყველა კომპიუტერი დღესდღეობით ამბობენ, რომ მისამართი არის 0 მეხსიერების თქვენ არ უნდა ეხება.

269
00:21:28,060 --> 00:21:31,920
ასე ამიტომ dereferencing null მაჩვენებელი შედეგების segfault.

270
00:21:31,920 --> 00:21:37,210
როდესაც თქვენ ემართება არ ვრთავ კურსორი, მაშინ მას აქვს ნაგვის ღირებულება,

271
00:21:37,210 --> 00:21:41,520
და ამრიგად, როდესაც თქვენ ცდილობენ dereference იგი, ყველა ალბათობა თქვენ ეხება მეხსიერება

272
00:21:41,520 --> 00:21:43,540
რომ შუა არსად.

273
00:21:43,540 --> 00:21:45,650
თუ მოხდება მისაღებად გაუმართლა და ნაგვის ღირებულება

274
00:21:45,650 --> 00:21:48,440
მოხდა აღვნიშნო, რომ სადმე დასტის ან რაღაც,

275
00:21:48,440 --> 00:21:50,820
მაშინ, როდესაც თქვენ dereference რომ მომცეთ, რომელიც თქვენ არ ინიციალიზდება,

276
00:21:50,820 --> 00:21:52,730
არაფერი წავა არასწორია.

277
00:21:52,730 --> 00:21:55,480
მაგრამ თუ ეს მიუთითებს, ვთქვათ, სადღაც შორის დასტის და ბევრი,

278
00:21:55,480 --> 00:21:59,850
ან ის მიუთითებს მხოლოდ სადღაც, რომ არ იყო გამოყენებული თქვენი პროგრამა არ არის,

279
00:21:59,850 --> 00:22:02,240
მაშინ თქვენ ეხება მეხსიერების თქვენ არ უნდა ეხება და თქვენ segfault.

280
00:22:02,240 --> 00:22:06,370
როდესაც ვწერთ რეკურსიული ფუნქცია და იგი recurses ძალიან ბევრი ჯერ

281
00:22:06,370 --> 00:22:08,720
და თქვენი დასტის იზრდება ძალიან დიდია და დასტის collides შევიდა რამ

282
00:22:08,720 --> 00:22:12,270
რომ იგი არ უნდა colliding ერთად, თქვენ ეხება მეხსიერების თქვენ არ უნდა ეხება,

283
00:22:12,270 --> 00:22:14,810
ასე რომ თქვენ segfault.

284
00:22:14,810 --> 00:22:17,010
სწორედ ეს არის segfault.

285
00:22:17,010 --> 00:22:21,810
>> ასევე ამავე მიზეზით, რომ თუ თქვენ გაქვთ სიმებიანი მოსწონს -

286
00:22:21,810 --> 00:22:23,930
მოდით დავუბრუნდეთ წინა პროგრამა.

287
00:22:23,930 --> 00:22:28,530
In hello.c--I'm just ვაპირებთ რაღაც.

288
00:22:28,530 --> 00:22:33,770
char * s = "Hello world!";

289
00:22:33,770 --> 00:22:42,310
თუ გამოვიყენო * s = რაღაც ან s [0] = 'X';

290
00:22:42,310 --> 00:22:47,290
ასე რომ Hello,. / Hello, რატომ, რომ segfault?

291
00:22:48,410 --> 00:22:51,250
რატომ ამ segfault?

292
00:22:55,660 --> 00:22:57,890
რას ველოდოთ მოხდეს?

293
00:22:57,890 --> 00:23:06,640
თუ წავიდოდი printf ("% s \ n", S); რას ველოდოთ უნდა დაიბეჭდოს?

294
00:23:06,640 --> 00:23:09,930
[სტუდენტი] X hello. >> Yeah.

295
00:23:09,930 --> 00:23:15,140
პრობლემა ისაა, რომ როდესაც თქვენ გამოაცხადოს სიმებიანი მოსწონს,

296
00:23:15,140 --> 00:23:18,190
s არის მაჩვენებელი, აპირებს გააგრძელოს დასტის,

297
00:23:18,190 --> 00:23:25,880
და რა არის მიუთითებს ეს ტექსტი, რომელიც შეიცავს წაუკითხავი მეხსიერება.

298
00:23:25,880 --> 00:23:30,560
ასე რომ მხოლოდ სახელი, წაუკითხავი მეხსიერება, თქვენ უნდა მიიღოს იდეა

299
00:23:30,560 --> 00:23:33,010
რომ თუ თქვენ ცდილობენ შეცვლის რა წაუკითხავი მეხსიერება,

300
00:23:33,010 --> 00:23:36,670
თქვენ აკეთებთ რაღაც არ უნდა აკეთებს მეხსიერების და თქვენ segfault.

301
00:23:36,670 --> 00:23:45,360
ეს არის რეალურად დიდი სხვაობა char * s და char s [].

302
00:23:45,360 --> 00:23:48,790
ასე რომ char s [], ახლა ეს კონტექსტი იქნება ჩაიცვი დასტის,

303
00:23:48,790 --> 00:23:53,960
და დასტის არ არის წაუკითხავი, რაც იმას ნიშნავს, რომ ეს უნდა იმუშაოს შესანიშნავად ჯარიმა.

304
00:23:55,500 --> 00:23:57,370
ეს სულაც.

305
00:23:57,370 --> 00:24:06,250
გახსოვდეთ, რომ როდესაც გავაკეთო char * s = "Hello World!", S თავად არის დასტის

306
00:24:06,250 --> 00:24:10,390
მაგრამ ჯერ ქულები სადმე სხვაგან, და რომ სხვაგან ხდება უნდა წაიკითხოთ მხოლოდ.

307
00:24:10,390 --> 00:24:15,640
მაგრამ char s [] არის მხოლოდ რაღაც Stack.

308
00:24:17,560 --> 00:24:21,760
ასე რომ კიდევ ერთი მაგალითი segfault ხდება.

309
00:24:21,760 --> 00:24:27,820
>> ჩვენ ვნახეთ, რომ ./buggy1 შედეგად segfault.

310
00:24:27,820 --> 00:24:31,810
თეორიულად, თქვენ არ უნდა შევხედოთ buggy1.c დაუყოვნებლივ.

311
00:24:31,810 --> 00:24:35,170
სამაგიეროდ, ჩვენ შევხედოთ ის მეშვეობით GDB.

312
00:24:35,170 --> 00:24:37,750
გაითვალისწინეთ, რომ როდესაც თქვენ სეგმენტაცია ბრალია (ბირთვი dumped),

313
00:24:37,750 --> 00:24:40,850
თქვენ ამ ფაილის აქ მოუწოდა core.

314
00:24:40,850 --> 00:24:45,200
თუ ჩვენ ls-l, ვნახავთ, რომ ძირითადი ჩვეულებრივ საკმაოდ დიდი ფაილი.

315
00:24:45,200 --> 00:24:51,580
ეს არის ბაიტების რაოდენობას of ფაილი, ასე რომ ჰგავს ეს 250-რაღაც kilobytes.

316
00:24:51,580 --> 00:24:56,120
მიზეზი არის ის, რომ რაც core ნაგავსაყრელი რეალურად არის

317
00:24:56,120 --> 00:25:01,410
როდესაც თქვენი პროგრამის დამსხვრევაზე, სახელმწიფოს მეხსიერებაში პროგრამა

318
00:25:01,410 --> 00:25:05,230
მხოლოდ იღებს გადაწერა და pasted შევიდა ამ ფაილის.

319
00:25:05,230 --> 00:25:07,270
იგი იღებს dumped შევიდა, რომ ფაილი.

320
00:25:07,270 --> 00:25:13,060
ეს პროგრამა, ხოლო ეს იყო გაშვებული, მოხდა აქვს მეხსიერების გამოყენების დაახლოებით 250 kilobytes,

321
00:25:13,060 --> 00:25:17,040
და ისე, რომ ის, რაც მიიღო dumped ამ ფაილის.

322
00:25:17,040 --> 00:25:23,630
ახლა თქვენ შეგიძლიათ შეხედოთ რომ ფაილი თუ ჩვენ GDB buggy1 core.

323
00:25:23,630 --> 00:25:30,130
ჩვენ შეგვიძლია უბრალოდ GDB buggy1, და რომელიც უბრალოდ დავიწყოთ GDB რეგულარულად,

324
00:25:30,130 --> 00:25:33,800
გამოყენებით buggy1 როგორც მისი შეყვანის ფაილი.

325
00:25:33,800 --> 00:25:38,260
მაგრამ თუ GDB buggy1 Core, მაშინ ეს კონკრეტულად აპირებს დავიწყოთ GDB

326
00:25:38,260 --> 00:25:40,330
მიერ ეძებს, რომ ძირითადი ფაილი.

327
00:25:40,330 --> 00:25:45,560
და თქვენ ამბობდა buggy1 საშუალებით GDB იცის, რომ ძირითადი ფაილის მოდის buggy1 პროგრამა.

328
00:25:45,560 --> 00:25:49,580
ამიტომ GDB buggy1 ძირითადი აპირებს დაუყოვნებლივ მიგვიყვანს

329
00:25:49,580 --> 00:25:52,060
იქ, სადაც პროგრამის მოხდა შეწყვიტოს.

330
00:25:57,720 --> 00:26:02,340
ჩვენ ვხედავთ, აქ პროგრამის წყდება ერთად სიგნალი 11, სეგმენტირება ბრალია.

331
00:26:02,340 --> 00:26:10,110
ჩვენ არ უნდა დაინახოს ხაზი ასამბლეის, რაც ალბათ არ არის ძალიან გამოსადეგი.

332
00:26:10,110 --> 00:26:15,360
მაგრამ თუ თქვენ აკრიფოთ BT ან backtrace, რომ იქნება ფუნქცია

333
00:26:15,360 --> 00:26:19,430
რომ გვაძლევს სიაში ჩვენი დღევანდელი დასტის ფარგლებში.

334
00:26:19,430 --> 00:26:23,150
ამიტომ backtrace. როგორც ჩანს ჩვენ მხოლოდ ორი დასტის ფარგლებში.

335
00:26:23,150 --> 00:26:26,310
პირველი არის ჩვენი მთავარი დასტის ჩარჩო,

336
00:26:26,310 --> 00:26:29,810
და მეორე არის დასტის ჩარჩო ამ ფუნქციას, რომ ჩვენ არ უნდა იყოს,

337
00:26:29,810 --> 00:26:34,440
რომელიც ჰგავს ჩვენ მხოლოდ ასამბლეის კოდი.

338
00:26:34,440 --> 00:26:38,050
მოდით დავუბრუნდეთ ჩვენს ძირითად ფუნქციას,

339
00:26:38,050 --> 00:26:42,300
და ამისათვის ჩვენ შეგვიძლია გავაკეთოთ ჩარჩოს 1, და მე ვფიქრობ, ჩვენ შეგვიძლია გავაკეთოთ ასევე ქვემოთ,

340
00:26:42,300 --> 00:26:45,160
მაგრამ მე თითქმის არასდროს არ Down - ან up. Yeah.

341
00:26:45,160 --> 00:26:50,710
ზემოთ და ქვემოთ. Up მოაქვს თქვენ ერთი დასტის ჩარჩო, ქვემოთ მოაქვს თქვენ ქვემოთ დასტის ჩარჩო.

342
00:26:50,710 --> 00:26:53,240
მე ტენდენცია არასდროს არ გამოიყენოთ რომ.

343
00:26:53,240 --> 00:26:59,120
მე მხოლოდ კონკრეტულად ამბობენ ჩარჩოს 1, რომელიც წასვლა ჩარჩო შეაფასა 1.

344
00:26:59,120 --> 00:27:01,750
კარკასი 1 აპირებს მიგვიყვანს შევიდა ძირითადი დასტის ჩარჩო,

345
00:27:01,750 --> 00:27:05,570
და ეს ამბობს უფლება აქ ხაზი კოდი ჩვენ მოხდეს იყოს.

346
00:27:05,570 --> 00:27:07,950
თუ გვინდოდა რამდენიმე ხაზი კოდი, შეიძლება ითქვას სია,

347
00:27:07,950 --> 00:27:11,280
და რომ აპირებს მოგვცეს ყველა ხაზი კოდი გარშემო.

348
00:27:11,280 --> 00:27:13,360
ხაზი ჩვენ segfaulted ზე იყო 6:

349
00:27:13,360 --> 00:27:17,360
თუ (strcmp ("CS50 კლდეები", argv [1]) == 0).

350
00:27:17,360 --> 00:27:24,130
თუ ეს არ არის აშკარა არ არის, თქვენ უკვე შეგიძლიად პირდაპირ აქ მხოლოდ ფიქრობს, თუ რატომ segfaulted.

351
00:27:24,130 --> 00:27:28,800
მაგრამ ჩვენ შეგვიძლია მას ერთი ნაბიჯით შემდგომი და აცხადებენ, "რატომ argv [1] segfault?"

352
00:27:28,800 --> 00:27:38,830
მოდით ბეჭდვითი argv [1], და როგორც ჩანს ეს 0x0, რომელიც null მაჩვენებელი.

353
00:27:38,830 --> 00:27:44,750
ჩვენ strcmping CS50 კლდეები და null, და ისე, რომ აპირებს segfault.

354
00:27:44,750 --> 00:27:48,280
და რატომ არის argv [1] null?

355
00:27:48,640 --> 00:27:51,280
[სტუდენტი] იმიტომ, რომ ჩვენ არ მისცა მას ნებისმიერი ბრძანების ხაზი არგუმენტები.

356
00:27:51,280 --> 00:27:53,390
Yeah. ჩვენ არ მისცეს მას ნებისმიერი ბრძანების ხაზი არგუმენტები.

357
00:27:53,390 --> 00:27:58,460
ამიტომ ./buggy1 მხოლოდ აპირებს argv [0] იყოს ./buggy1.

358
00:27:58,460 --> 00:28:02,100
ეს არ აპირებს argv [1], ისე, რომ აპირებს segfault.

359
00:28:02,100 --> 00:28:07,450
მაგრამ თუ, ნაცვლად, მე უბრალოდ CS50, იგი აპირებს ამბობენ თქვენ D

360
00:28:07,450 --> 00:28:09,950
იმიტომ, რომ ის, რაც მას უნდა გავაკეთოთ.

361
00:28:09,950 --> 00:28:15,240
ეძებს buggy1.c, ის უნდა ბეჭდვა "თქვენ მიიღეთ D" -

362
00:28:15,240 --> 00:28:20,820
თუ argv [1] არ არის "CS50 კლდეები", "თქვენ D", სხვაგან "თქვენ!"

363
00:28:20,820 --> 00:28:25,660
ასე რომ, თუ ჩვენ გვინდა, ჩვენ გვჭირდება ამ შედარების როგორც ჭეშმარიტი,

364
00:28:25,660 --> 00:28:28,710
რაც იმას ნიშნავს, რომ ადარებს, რათა 0.

365
00:28:28,710 --> 00:28:31,100
ამიტომ argv [1] უნდა იყოს "CS50 კლდეები".

366
00:28:31,100 --> 00:28:35,660
თუ გსურთ, რომ ბრძანების სტრიქონში, თქვენ უნდა გამოვიყენოთ \ გაქცევა სივრცეში.

367
00:28:35,660 --> 00:28:41,690
ამიტომ CS50 \ კლდეები და თქვენ მიიღებთ?

368
00:28:41,690 --> 00:28:44,060
თუ არ გააკეთებს backslash, რატომ ამ არ იმუშავებს?

369
00:28:44,060 --> 00:28:47,190
[სტუდენტი] ეს ორი განსხვავებული არგუმენტები. >> Yeah.

370
00:28:47,190 --> 00:28:52,540
Argv [1] იქნება CS50 და argv [2] იქნება კლდეები. Okay.

371
00:28:52,540 --> 00:28:56,470
>> ახლა ./buggy2 აპირებს segfault ერთხელ.

372
00:28:56,470 --> 00:29:01,880
იმის ნაცვლად, რომ გახსნის ეს მისი ძირითადი ფაილი, ჩვენ უბრალოდ გახსენით buggy2 პირდაპირ,

373
00:29:01,880 --> 00:29:05,000
ასე GDB buggy2.

374
00:29:05,000 --> 00:29:09,590
ახლა თუ ჩვენ მხოლოდ აწარმოებს ჩვენი პროგრამა, მაშინ იგი აპირებს ამბობენ პროგრამა მიღებულია სიგნალი SIGSEGV,

375
00:29:09,590 --> 00:29:15,530
რაც segfault სიგნალი, და ეს არის, სადაც ეს მოხდა მოხდეს.

376
00:29:15,530 --> 00:29:21,250
ეძებს ჩვენს backtrace, ჩვენ ვხედავთ, რომ ერთმანეთი ფუნქცია oh_no,

377
00:29:21,250 --> 00:29:23,900
რომელიც იწვევს ფუნქციის Dinky, რომელიც იწვევს ფუნქციის binky,

378
00:29:23,900 --> 00:29:26,460
რომელსაც სხვადასხვა დროს ძირითადი.

379
00:29:26,460 --> 00:29:31,680
ჩვენ შეგვიძლია აგრეთვე არგუმენტები ამ ფუნქციების.

380
00:29:31,680 --> 00:29:34,680
არგუმენტი Dinky და binky იყო 1.

381
00:29:34,680 --> 00:29:44,390
თუ ჩვენ სიაში ფუნქცია oh_no, ჩვენ ვხედავთ, რომ oh_no უბრალოდ აკეთებს char ** s = NULL;

382
00:29:44,390 --> 00:29:47,410
* S = "BOOM";

383
00:29:47,410 --> 00:29:50,330
რატომ უნდა, რომ ვერ?

384
00:29:54,330 --> 00:29:58,380
[სტუდენტი] თქვენ არ შეგიძლიათ dereference null მაჩვენებელი? >> Yeah.

385
00:29:58,380 --> 00:30:06,090
ეს მხოლოდ ამბობდა s არის NULL, მიუხედავად, თუ ეს მოხდება, რომ იყოს char **,

386
00:30:06,090 --> 00:30:12,070
რომელიც, იმის მიხედვით, თუ როგორ ინტერპრეტაცია, ეს შეიძლება იყოს მომცეთ მომცეთ სიმებიანი

387
00:30:12,070 --> 00:30:15,550
ან მასივი სტრიქონები.

388
00:30:15,550 --> 00:30:21,430
ეს s არის NULL, ამიტომ * s არის dereferencing null მაჩვენებელი,

389
00:30:21,430 --> 00:30:24,800
და ა.შ. ამ აპირებს მისაწოდებლად.

390
00:30:24,800 --> 00:30:27,540
ეს არის ერთ სწრაფი გზები შეგიძლიათ შესაძლოა segfault.

391
00:30:27,540 --> 00:30:31,300
უბრალოდ გამოცხადების null კურსორი და დაუყოვნებლივ segfaulting.

392
00:30:31,300 --> 00:30:34,570
რაც oh_no აკეთებს.

393
00:30:34,570 --> 00:30:43,400
თუ ჩვენ ახვიდეთ ერთ ჩარჩოში, მაშინ ჩვენ ვაპირებთ შეღწევას ფუნქცია მოუწოდა oh_no.

394
00:30:43,400 --> 00:30:44,830
მე უნდა გავაკეთოთ, რომ ქვემოთ.

395
00:30:44,830 --> 00:30:48,610
თუ არ შევა ბრძანება და თქვენ უბრალოდ დააჭირეთ ერთხელ,

396
00:30:48,610 --> 00:30:52,350
ის უბრალოდ ვიმეორებ წინა ბრძანება რომ თქვენ გაიქცა.

397
00:30:52,350 --> 00:30:56,610
ჩვენ ჩარჩოში 1.

398
00:30:56,610 --> 00:31:04,650
ლისტინგ ამ ჩარჩოს, ჩვენ ვხედავთ აქ არის ჩვენი ფუნქცია.

399
00:31:04,650 --> 00:31:08,520
შეგიძლიათ მოხვდა სიაში თავიდან, ან შეგიძლიათ გააკეთოთ სიაში 20 და მას სიაში მეტი.

400
00:31:08,520 --> 00:31:13,640
ფუნქციის Dinky ამბობს თუ არის 1, შემდეგ კი oh_no ფუნქცია,

401
00:31:13,640 --> 00:31:15,960
სხვაგან წასვლა slinky ფუნქცია.

402
00:31:15,960 --> 00:31:18,700
და ვიცით, მე კი 1 რადგან ჩვენ არ უნდა დაინახოს აქ

403
00:31:18,700 --> 00:31:22,560
რომ Dinky დაურეკეს არგუმენტი 1.

404
00:31:22,560 --> 00:31:27,560
ან შეგიძლიათ უბრალოდ ამობეჭდოთ მე და ის იტყვის მე არის 1.

405
00:31:27,560 --> 00:31:33,770
ჩვენ ამჟამად Dinky და, თუ ჩვენ კიდევ ერთ ჩარჩოში, ჩვენ ვიცით, ჩვენ დასრულდება მდე binky.

406
00:31:33,770 --> 00:31:36,600
Up. ახლა ჩვენ წელს binky.

407
00:31:36,600 --> 00:31:41,340
ლისტინგ ამ ფუნქციის - სიის ადრე ნახევარი მოჭრილი me off -

408
00:31:41,340 --> 00:31:52,670
დაიწყო off თითქოს მე არის 0, მაშინ ჩვენ ვაპირებთ ეძახით oh_no, სხვას მოვუწოდებ Dinky.

409
00:31:52,670 --> 00:31:57,000
ჩვენ ვიცით, მე ვიყავი 1, ასე რომ მოუწოდა Dinky.

410
00:31:57,000 --> 00:32:05,030
და ახლა ჩვენ უკან მთავარ და ძირითად მხოლოდ იქნება int i = RAND ()% 3;

411
00:32:05,030 --> 00:32:08,790
რომ მხოლოდ აპირებს მოგცემთ შემთხვევითი ნომერი, რომელიც არის ან 0, 1, ან 2.

412
00:32:08,790 --> 00:32:12,780
ეს ვაპირებ მოვუწოდო binky რომ ნომერი, და ეს დაბრუნდება 0.

413
00:32:12,780 --> 00:32:16,700
ეძებს ამ,

414
00:32:16,700 --> 00:32:19,880
უბრალოდ გავლით პროგრამა ხელით გარეშე გაშვებული მაშინვე,

415
00:32:19,880 --> 00:32:25,400
თქვენ მითითებული შესვენების ადგილამდე მთავარი, რაც იმას ნიშნავს, რომ როდესაც ჩვენ აწარმოებს პროგრამა

416
00:32:25,400 --> 00:32:31,020
თქვენი პროგრამა ეშვება მდე სანამ ჰიტები შესვენების წერტილი.

417
00:32:31,020 --> 00:32:35,450
ასე რომ გაშვებული პროგრამა, იგი აწარმოებს და მაშინ მოხვდა მთავარი ფუნქცია და შეწყვიტოს გაშვებული.

418
00:32:35,450 --> 00:32:44,700
ახლა ჩვენ შიგნით ძირითადი და ნაბიჯი ან მომდევნო აპირებს მიგვიყვანს შემდეგი ხაზი კოდი.

419
00:32:44,700 --> 00:32:47,050
ამის გაკეთება შეგიძლიათ ნაბიჯი ან მომდევნო.

420
00:32:47,050 --> 00:32:51,800
Hitting მომდევნო, მე ახლა უკვე მითითებული RAND ()% 3, ასე რომ ჩვენ შეგვიძლია ბეჭდვა ღირებულება i,

421
00:32:51,800 --> 00:32:55,280
და ეს იტყვის მე არის 1.

422
00:32:55,280 --> 00:32:58,110
ახლა კი არ აქვს მნიშვნელობა, თუ არა ჩვენ ვიყენებთ შემდეგი ან ნაბიჯი.

423
00:32:58,110 --> 00:33:01,000
ვფიქრობ ეს მნიშვნელოვანი წელს ადრე, მაგრამ ჩვენ გვინდა გამოვიყენოთ შემდეგი.

424
00:33:01,000 --> 00:33:06,000
თუ ჩვენ ვიყენებთ ნაბიჯი, ჩვენ დახევას შევიდა ფუნქცია, რაც იმას ნიშნავს, შევხედოთ რეალურ რამ

425
00:33:06,000 --> 00:33:07,940
რომ ხდება შიგნით binky.

426
00:33:07,940 --> 00:33:10,510
თუ ჩვენ ვიყენებთ შემდეგი, მაშინ ეს იმას ნიშნავს, წავიდეს მეტი ფუნქცია

427
00:33:10,510 --> 00:33:14,070
და უბრალოდ წასვლა შემდეგი ხაზი კოდი ჩვენი მთავარი ფუნქცია.

428
00:33:14,070 --> 00:33:17,900
სწორედ აქ, ამ ხაზის ვიყავი, სადაც ეს განაცხადა RAND ()% 3;

429
00:33:17,900 --> 00:33:21,320
თუ წავიდოდი ნაბიჯი, ეს იქნებოდა წასვლას განხორციელების RAND

430
00:33:21,320 --> 00:33:25,110
და შეხედეთ, რა ხდება იქ, და მე ვერ დაიხევს მეშვეობით RAND ფუნქცია.

431
00:33:25,110 --> 00:33:26,920
მაგრამ მე არ აინტერესებს RAND ფუნქცია.

432
00:33:26,920 --> 00:33:30,190
მინდა წასვლა შემდეგი ხაზი კოდი მთავარ, ისე გამოიყენოს შემდეგი.

433
00:33:30,190 --> 00:33:35,800
მაგრამ ახლა მე ზრუნავენ binky ფუნქცია, ასე რომ მინდა დახევას შევიდა, რომ.

434
00:33:35,800 --> 00:33:37,730
ახლა მე binky.

435
00:33:37,730 --> 00:33:42,040
პირველი ხაზი კოდი თქმას თუ (i == 0), მე ნაბიჯი,

436
00:33:42,040 --> 00:33:44,930
ჩვენ ვხედავთ ჩვენ დასრულდება მდე საათზე Dinky.

437
00:33:44,930 --> 00:33:51,620
თუ ჩვენ სიაში რამ, ჩვენ ვხედავთ, რომ ეს არის გადამოწმებული i = 0.

438
00:33:51,620 --> 00:33:55,470
მე არ ტოლია 0, ასე რომ წავიდა სხვას მდგომარეობა,

439
00:33:55,470 --> 00:33:59,540
რომელიც ვაპირებ მოვუწოდო Dinky (I).

440
00:33:59,540 --> 00:34:04,030
შესაძლოა დაბნეული.

441
00:34:04,030 --> 00:34:07,380
თუ თქვენ უბრალოდ შეხედეთ ამ ხაზების პირდაპირ, თქვენ ალბათ ფიქრობთ, თუ (i == 0),

442
00:34:07,380 --> 00:34:10,800
okay, მაშინ მე მივიღე ნაბიჯი და ახლა მე ზე Dinky (I),

443
00:34:10,800 --> 00:34:14,120
თქვენ ალბათ ფიქრობთ, რომ უნდა ნიშნავდეს i = 0 ან რაღაც.

444
00:34:14,120 --> 00:34:18,980
პოსტები უბრალოდ იმას ნიშნავს, რომ იგი დარწმუნებულია, მას შეუძლია გამყარებაში უშუალოდ ხაზის Dinky (I).

445
00:34:18,980 --> 00:34:23,300
იმიტომ, რომ მე არ 0, შემდეგი ნაბიჯი არ აპირებს დასრულდება სხვაგან.

446
00:34:23,300 --> 00:34:26,239
Else არ არის ხაზზე ის აპირებს შეჩერება.

447
00:34:26,239 --> 00:34:31,570
უბრალოდ აპირებს მისვლას შემდეგი ხაზი მას შეუძლია რეალურად შეასრულოს, რომელიც Dinky (I).

448
00:34:31,570 --> 00:34:36,090
Stepping შევიდა Dinky (I), ჩვენ ვხედავთ, თუ (i == 1).

449
00:34:36,090 --> 00:34:42,670
ჩვენ ვიცით i = 1, ასე რომ, როდესაც ჩვენ ნაბიჯი, ჩვენ ვიცით ჩვენ ვაპირებთ დასრულდება up in oh_no

450
00:34:42,670 --> 00:34:46,489
იმიტომ, რომ მე = 1 მოუწოდებს ფუნქცია oh_no, რომელიც შეგიძლიათ დახევას შევიდა,

451
00:34:46,489 --> 00:34:52,969
რომელიც აპირებს მითითებული char ** s = to null და დაუყოვნებლივ "BOOM".

452
00:34:54,270 --> 00:34:59,690
და მაშინ რეალურად შევხედავთ განხორციელების buggy2,

453
00:34:59,690 --> 00:35:04,590
ამ, მე მხოლოდ მიღების შემთხვევითი ხმების - 0, 1, ან 2 - დარეკვის binky,

454
00:35:04,590 --> 00:35:10,610
რომელიც თუ არის 0 ის მოუწოდებს oh_no, სხვას ის მოუწოდებს Dinky, რომელიც მოდის აქ.

455
00:35:10,610 --> 00:35:18,100
თუ მე არის 1, Call oh_no, სხვას მოვუწოდებ slinky, რომელიც მალე აქ,

456
00:35:18,100 --> 00:35:20,460
თუ არის 2, მოვუწოდებთ oh_no.

457
00:35:20,460 --> 00:35:24,720
ისიც კი არ ფიქრობს, რომ ეს გზა -

458
00:35:24,720 --> 00:35:30,030
ვინმეს ვხედავთ გზას მიღების ამ პროგრამა, რომელიც არ segfault?

459
00:35:30,030 --> 00:35:37,530
იმის გამო, რომ მანამ, სანამ მე გავიგე რამე, თუ არის 0, თქვენ მაშინვე segfault,

460
00:35:37,530 --> 00:35:41,250
სხვაგან მიდიხარ ფუნქცია რომელიც თუ არის 1 თქვენ segfault,

461
00:35:41,250 --> 00:35:44,540
სხვაგან მიდიხარ ფუნქცია აქ თუ არის 2 თქვენ segfault.

462
00:35:44,540 --> 00:35:46,810
ასე რომ არ აქვს მნიშვნელობა, თუ რას აკეთებთ, თქვენ segfault.

463
00:35:46,810 --> 00:35:52,380
>> ვფიქრობ ერთი გზა აფიქსირებს იქნებოდა ნაცვლად აკეთებს char ** s = NULL,

464
00:35:52,380 --> 00:35:55,610
თქვენ შეიძლება malloc ფართი რომ სიმებიანი.

465
00:35:55,610 --> 00:36:04,230
ჩვენ შეიძლება არ malloc (sizeof) - sizeof რა?

466
00:36:09,910 --> 00:36:15,190
[სტუდენტი] (char) * 5? >> საერთოდ ჩანს უფლება?

467
00:36:15,190 --> 00:36:21,060
მე თუ ვთქვათ ამ იმუშავებს თუ რეალურად გაიქცა, მაგრამ ეს არ რა მე ეძებს.

468
00:36:24,400 --> 00:36:32,940
შეხედეთ გაცნობის s. მოდით დაამატოთ int *, ასე int * x.

469
00:36:32,940 --> 00:36:35,600
მე ყველაფერს გააკეთებს malloc (sizeof (int)).

470
00:36:35,600 --> 00:36:40,490
ან თუ მინდოდა მასივი 5, მე ყველაფერს გააკეთებს (sizeof (int) * 5);

471
00:36:40,490 --> 00:36:44,210
თუ აქვს int **?

472
00:36:46,260 --> 00:36:49,140
რა შეიძლება malloc?

473
00:36:49,140 --> 00:36:53,510
[სტუდენტი] ზომა კურსორის. >> Yeah. (Sizeof (int *));

474
00:36:53,510 --> 00:36:56,960
იგივე ქვემოთ აქ.

475
00:36:56,960 --> 00:37:01,280
მინდა (sizeof (char *));

476
00:37:06,170 --> 00:37:12,840
ეს აპირებს გამოყოს ფართი მაჩვენებელი, რომელიც მიუთითებს "BOOM".

477
00:37:12,840 --> 00:37:15,330
მე არ უნდა გამოყოს ფართი "BOOM" თავად

478
00:37:15,330 --> 00:37:17,210
რადგან ეს არის ძირითადად ექვივალენტი რა ვთქვი

479
00:37:17,210 --> 00:37:20,870
of char * x = "BOOM".

480
00:37:20,870 --> 00:37:27,950
"BOOM" უკვე არსებობს. ეს ხდება არსებობა წაუკითხავი რეგიონში მეხსიერება.

481
00:37:27,950 --> 00:37:35,200
მაგრამ ეს უკვე არსებობს, რაც იმას ნიშნავს, ამ ხაზი კოდი, თუ არის char **,

482
00:37:35,200 --> 00:37:43,900
მაშინ * s არის char * და თქვენ დააყენოთ ეს char * აღვნიშნო, რომ "BOOM".

483
00:37:43,900 --> 00:37:50,040
თუ მინდოდა ასლი "BOOM" შევიდა s, მაშინ მე უნდა გამოყოს ფართი s.

484
00:37:55,170 --> 00:38:03,900
მე გავაკეთებ * s = malloc (sizeof (char) * 5);

485
00:38:03,900 --> 00:38:06,210
რატომ 5?

486
00:38:06,210 --> 00:38:10,860
რატომ არ 4? როგორც ჩანს "BOOM" არის 4 სიმბოლო. >> [სტუდენტი] null ხასიათი.

487
00:38:10,860 --> 00:38:14,580
Yeah. ყველა თქვენი სტრიქონები ვაპირებთ გვჭირდება null ხასიათი.

488
00:38:14,580 --> 00:38:23,590
ახლა შემიძლია რაღაც strcat - რა არის ფუნქცია კოპირება სიმებიანი?

489
00:38:23,590 --> 00:38:28,520
[სტუდენტი] cpy? >> Strcpy.

490
00:38:28,520 --> 00:38:32,700
კაცი strcpy.

491
00:38:36,120 --> 00:38:39,590
ამიტომ strcpy ან strncpy.

492
00:38:39,590 --> 00:38:43,410
strncpy ოდნავ უსაფრთხო რადგან თქვენ შეგიძლიათ მიუთითოთ ზუსტად რამდენი გმირები,

493
00:38:43,410 --> 00:38:46,190
მაგრამ აქ არა აქვს მნიშვნელობა, რადგან ჩვენ ვიცით.

494
00:38:46,190 --> 00:38:50,340
ამიტომ strcpy და მოუთმენლად წელს არგუმენტები.

495
00:38:50,340 --> 00:38:53,100
პირველი არგუმენტი არის ჩვენი დანიშნულების.

496
00:38:53,100 --> 00:38:56,770
მეორე არგუმენტი არის ჩვენი წყარო.

497
00:38:56,770 --> 00:39:10,310
ჩვენ ვაპირებთ კოპირება ჩვენს დანიშნულების * s კურსორის "BOOM".

498
00:39:10,310 --> 00:39:19,820
რატომ შეიძლება გსურთ ამ strcpy ნაცვლად მხოლოდ, რაც ჩვენ გვქონდა ადრე

499
00:39:19,820 --> 00:39:22,800
of * s = "BOOM"?

500
00:39:22,800 --> 00:39:28,630
არსებობს მიზეზი, დაგვჭირდება ამის გაკეთება, მაგრამ რა არის ის, რომ ამის მიზეზი?

501
00:39:28,630 --> 00:39:31,940
[სტუდენტი] თუ თქვენ გსურთ შეცვალოთ რაღაც "BOOM". >> Yeah.

502
00:39:31,940 --> 00:39:37,950
ახლა შემიძლია რაღაც s [0] = 'X';

503
00:39:37,950 --> 00:39:48,190
რადგან s მიუთითებს ბევრი და რომ სივრცე ბევრი რომ არის მიუთითებს

504
00:39:48,190 --> 00:39:52,320
არის მომცეთ მეტი სივრცე ბევრი, რომელიც შენახვის "BOOM".

505
00:39:52,320 --> 00:39:55,150
ასე რომ, ეს ასლი "BOOM" მიმდინარეობს ინახება ბევრი.

506
00:39:55,150 --> 00:39:58,780
არსებობს ტექნიკურად ორი ასლი "BOOM" ჩვენი პროგრამა.

507
00:39:58,780 --> 00:40:03,500
იქ პირველი ეს მხოლოდ მიერ ამ "BOOM" სიმებიანი მუდმივი,

508
00:40:03,500 --> 00:40:09,250
და მეორე ასლი "BOOM", strcpy შექმნილი ასლი "BOOM".

509
00:40:09,250 --> 00:40:13,100
მაგრამ ასლი "BOOM" მიმდინარეობს ინახება ბევრი და ბევრი თქვენ მისი შეცვლა.

510
00:40:13,100 --> 00:40:17,250
ბევრი არ არის წაუკითხავი, ისე, რომ ნიშნავს, რომ [0]

511
00:40:17,250 --> 00:40:20,500
აპირებს მოგცემთ შეცვალოთ ღირებულების "BOOM".

512
00:40:20,500 --> 00:40:23,130
იგი აპირებს მოგცემთ შეცვალოთ იმ სიმბოლოებს.

513
00:40:23,130 --> 00:40:26,640
>> კითხვები?

514
00:40:27,740 --> 00:40:29,290
Okay.

515
00:40:29,290 --> 00:40:35,500
>> მოძრავი to buggy3, მოდით GDB buggy3.

516
00:40:35,500 --> 00:40:39,840
ჩვენ უბრალოდ გაუშვით და ჩვენ ვხედავთ მივიღებთ segfault.

517
00:40:39,840 --> 00:40:46,550
თუ ჩვენ backtrace, არის მხოლოდ ორი ფუნქცია.

518
00:40:46,550 --> 00:40:52,970
თუ ჩვენ ახვიდეთ შევიდა ჩვენი მთავარი ფუნქცია, ჩვენ ვხედავთ, რომ ჩვენ segfaulted ამ ხაზის.

519
00:40:52,970 --> 00:41:00,180
ასე რომ მხოლოდ შევხედავთ ამ ხაზის, ამისთვის (int ხაზი = 0; fgets ამ პერსონალის არ თანაბარი NULL;

520
00:41:00,180 --> 00:41:03,770
ხაზი + +).

521
00:41:03,770 --> 00:41:08,010
ჩვენი წინა ჩარჩო ეწოდა _IO_fgets.

522
00:41:08,010 --> 00:41:10,720
თქვენ ნახავთ, რომ ბევრი ჩაშენებული C ფუნქციები,

523
00:41:10,720 --> 00:41:15,350
რომ როდესაც თქვენ segfault, იქნება მართლაც cryptic ფუნქცია სახელები

524
00:41:15,350 --> 00:41:18,090
მსგავსი _IO_fgets.

525
00:41:18,090 --> 00:41:21,770
მაგრამ ეს აპირებს ეხება ამ fgets ზარი.

526
00:41:21,770 --> 00:41:25,850
სადღაც შიგნით აქ, ჩვენ segfaulting.

527
00:41:25,850 --> 00:41:30,340
თუ დავაკვირდებით არგუმენტები fgets, ჩვენ შეგვიძლია ბეჭდვა ბუფერული.

528
00:41:30,340 --> 00:41:41,180
მოდით ბეჭდვა როგორც - ო, არა.

529
00:41:48,980 --> 00:41:51,900
ბეჭდვის არ აპირებს იმუშაოს ზუსტად როგორც მე მინდა მას.

530
00:41:55,460 --> 00:41:58,000
მოდით შევხედოთ რეალურ პროგრამა.

531
00:42:02,200 --> 00:42:09,640
ბუფერული არის ხასიათი მასივი. ეს ხასიათი მასივი 128 სიმბოლო.

532
00:42:09,640 --> 00:42:14,980
ამიტომ როდესაც ვამბობ, რომ ბეჭდვითი ბუფერული, ის აპირებს ბეჭდვა იმ 128 გმირები,

533
00:42:14,980 --> 00:42:18,300
რაც ვფიქრობ, არის ის, რაც მოსალოდნელი იყო.

534
00:42:18,300 --> 00:42:21,390
რა ეძებდა არის ბეჭდვის მისამართი ბუფერული,

535
00:42:21,390 --> 00:42:23,680
მაგრამ, რომ ნამდვილად არ მითხრათ ბევრად.

536
00:42:23,680 --> 00:42:30,770
ასე რომ, როდესაც მე მოხდეს ვთქვა აქ x ბუფერული, იგი აჩვენებს ჩემთან 0xbffff090,

537
00:42:30,770 --> 00:42:38,690
რომელიც, თუ გახსოვთ საწყისი ადრე თუ რაღაც მომენტში, Oxbffff tends იყოს Stack-ish რეგიონში.

538
00:42:38,690 --> 00:42:46,020
დასტის tends უნდა დაიწყოს სადღაც მხოლოდ ქვეშ 0xc000.

539
00:42:46,020 --> 00:42:51,890
მხოლოდ ვხედავთ ამ მისამართზე, ვიცი, რომ ბუფერული ხდება Stack.

540
00:42:51,890 --> 00:43:04,500
ხელმეორედ ჩემი პროგრამა, გაუშვით, up, ბუფერის დავინახეთ იყო ამ თანმიმდევრობა გმირები

541
00:43:04,500 --> 00:43:06,530
რომ არის საკმაოდ ბევრი უაზრო.

542
00:43:06,530 --> 00:43:12,270
მაშინ დაბეჭდვის ფაილი, რას ფაილი ჰგავს?

543
00:43:15,120 --> 00:43:17,310
[სტუდენტი] null. >> Yeah.

544
00:43:17,310 --> 00:43:22,610
ფაილი არის ტიპის ფაილ *, ასე რომ მომცეთ,

545
00:43:22,610 --> 00:43:26,610
და ღირებულება, რომ კურსორი არის null.

546
00:43:26,610 --> 00:43:33,240
ამიტომ fgets აპირებს ცდილობენ წაკითხვის რომ მაჩვენებელი წელს არაპირდაპირი გზით,

547
00:43:33,240 --> 00:43:37,320
მაგრამ იმისათვის, რათა შეამოწმონ, რომ მაჩვენებელი, ის dereference იგი.

548
00:43:37,320 --> 00:43:40,550
ან, რათა შედიხართ რა უნდა მივუთითოთ, ეს dereferences იგი.

549
00:43:40,550 --> 00:43:43,810
ამიტომ dereferencing null მაჩვენებელი და ეს segfaults.

550
00:43:46,600 --> 00:43:48,730
შემეძლო კვლავ დაიწყო მას იქ.

551
00:43:48,730 --> 00:43:52,170
თუ ჩვენ შესვენება ჩვენს მთავარია და აწარმოებს,

552
00:43:52,170 --> 00:43:57,320
პირველი ხაზი კოდი არის char * ფაილის სახელი = "nonexistent.txt";

553
00:43:57,320 --> 00:44:00,870
რომ უნდა მისცეს საკმაოდ დიდი მინიშნება, თუ რატომ ეს პროგრამა ვერ.

554
00:44:00,870 --> 00:44:06,080
Typing შემდეგი გამოიტანს მიბოძეთ შემდეგი ხაზი, სადაც მე ამ ფაილის გახსნის,

555
00:44:06,080 --> 00:44:11,140
და შემდეგ მაშინვე შეღწევას ჩვენი ხაზი, სადაც კიდევ ერთხელ მე მოხვდა შემდეგი, ეს აპირებს segfault.

556
00:44:11,140 --> 00:44:16,880
ვინმეს გსურთ ჩააგდე მიზეზი, რის გამოც ჩვენ შეიძლება segfaulting?

557
00:44:16,880 --> 00:44:19,130
[სტუდენტი] ფაილი არ არსებობს. >> Yeah.

558
00:44:19,130 --> 00:44:22,250
ეს უნდა იყოს მინიშნება

559
00:44:22,250 --> 00:44:29,570
რომ როდესაც თქვენ გახსნის ფაილი თქვენ უნდა დარწმუნდეთ რომ ფაილი ნამდვილად არსებობს.

560
00:44:29,570 --> 00:44:31,510
ასე რომ აქ, "nonexistent.txt";

561
00:44:31,510 --> 00:44:34,700
როდესაც ჩვენ fopen ფაილის წასაკითხად, ჩვენ მაშინ უნდა ითქვას,

562
00:44:34,700 --> 00:44:45,870
თუ (ფაილი == NULL) და ვთქვათ printf ("ფაილი არ არსებობს!"

563
00:44:45,870 --> 00:44:56,340
ან - კიდევ უკეთესი - ფაილის სახელი); დაბრუნების 1;

564
00:44:56,340 --> 00:45:00,300
ახლა ჩვენ შეამოწმეთ თუ NULL

565
00:45:00,300 --> 00:45:03,930
სანამ რეალურად გრძელდება და ცდილობს წაკითხვის რომ ფაილი.

566
00:45:03,930 --> 00:45:08,800
ჩვენ შეგვიძლია რიმეიკი უბრალოდ დაინახოს, რომ სამუშაოები.

567
00:45:11,020 --> 00:45:14,970
მე აპირებდა მოიცავს ახალი ხაზი.

568
00:45:21,090 --> 00:45:25,290
ახლა nonexistent.txt არ არსებობს.

569
00:45:26,890 --> 00:45:30,040
თქვენ ყოველთვის უნდა შეამოწმოთ ამ სახის რამ.

570
00:45:30,040 --> 00:45:33,870
თქვენ ყოველთვის უნდა შეამოწმოთ თუ fopen ბრუნდება null.

571
00:45:33,870 --> 00:45:38,170
თქვენ ყოველთვის უნდა შეამოწმოთ რომ დავრწმუნდეთ, რომ malloc არ დააბრუნებს NULL,

572
00:45:38,170 --> 00:45:41,410
ანდა თქვენ segfault.

573
00:45:42,200 --> 00:45:45,930
>> ახლა buggy4.c.

574
00:45:49,190 --> 00:45:58,440
გაშვებული. მე გამოცნობა ამ ელოდება შეყვანის ან შესაძლოა უსასრულო looping.

575
00:45:58,440 --> 00:46:01,870
დიახ, ეს უსასრულო looping.

576
00:46:01,870 --> 00:46:05,560
ამიტომ buggy4. როგორც ჩანს ჩვენ უსასრულო looping.

577
00:46:05,560 --> 00:46:12,590
ჩვენ შეგვიძლია შესვენება დროს ძირითადი, აწარმოებს ჩვენი პროგრამა.

578
00:46:12,590 --> 00:46:20,180
In GDB, რადგან აბრევიატურა თქვენ იყენებთ არის ცალსახა

579
00:46:20,180 --> 00:46:23,420
ან სპეციალური აბრევიატურების რომ ისინი უზრუნველყოფენ თქვენთვის,

580
00:46:23,420 --> 00:46:29,020
მაშინ შეგიძლიათ გამოიყენოთ N გამოიყენოს შემდეგი ნაცვლად, რომელმაც უნდა აკრიფოთ out შემდეგი ყველა გზა.

581
00:46:29,020 --> 00:46:33,730
და ახლა რომ მე მოხვდა n ერთხელ, მე შემიძლია უბრალოდ დააჭიროთ შენარჩუნება აპირებს შემდეგი

582
00:46:33,730 --> 00:46:36,640
ნაცვლად, რომელმაც მოხვდა n შეიყვანეთ, n შეიყვანეთ, n შეიყვანეთ.

583
00:46:36,640 --> 00:46:44,630
როგორც ჩანს მე რაღაც ამისთვის loop რომ შექმნის array [i] 0.

584
00:46:44,630 --> 00:46:50,510
როგორც ჩანს მე არასოდეს არღვევს ამ for loop.

585
00:46:50,510 --> 00:46:54,780
თუ მე ბეჭდვა მე ვარ, ამიტომ არის 2, მაშინ მე წასვლა შემდეგი.

586
00:46:54,780 --> 00:46:59,250
მე ბეჭდვა i, მე არის 3, მაშინ მე წასვლა შემდეგი.

587
00:46:59,250 --> 00:47:05,360
მე ბეჭდვა I და მე არის 3. შემდეგი, ბეჭდვა i, მე არის 4.

588
00:47:05,360 --> 00:47:14,520
სინამდვილეში, ბეჭდვითი sizeof (მასივი), რათა ზომის მასივი 20.

589
00:47:16,310 --> 00:47:32,870
მაგრამ ეს ჰგავს არსებობს ზოგიერთი სპეციალური GDB შემქმნელი აპირებს მანამ, სანამ რამე მოხდება.

590
00:47:32,870 --> 00:47:37,620
ეს მოსწონს შექმნის მდგომარეობის ღირებულება ცვლადი. მაგრამ არ მახსოვს რა არის.

591
00:47:37,620 --> 00:47:44,100
ასე რომ, თუ ჩვენ ვაპირებთ შენარჩუნება -

592
00:47:44,100 --> 00:47:47,120
რის ამბობდა? რა ზრდიან?

593
00:47:47,120 --> 00:47:50,500
[სტუდენტი] არ არიან დავამატო - >> Yeah. ასე არაა მე შეიძლება დაეხმაროს.

594
00:47:50,500 --> 00:47:54,530
თუ ჩვენ მხოლოდ ცარიელია i, იგი შეეგუება აქ რა ღირებულება მე არის

595
00:47:54,530 --> 00:47:56,470
ასე რომ არ უნდა ამობეჭდოთ ყოველ ჯერზე.

596
00:47:56,470 --> 00:48:02,930
თუ ჩვენ უბრალოდ შეინახოს აპირებს მომდევნო, ჩვენ ვხედავთ 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5.

597
00:48:02,930 --> 00:48:08,530
რაღაც მიდის არასწორი საშინლად, და მე მიმდინარეობს დაიყვანება 0.

598
00:48:13,330 --> 00:48:22,220
ეძებს buggy4.c, ჩვენ ვხედავთ, რომ ყველა ხდება int array [5];

599
00:48:22,220 --> 00:48:26,200
ამისთვის (i = 0; i <= sizeof (მასივი), მე + +)

600
00:48:26,200 --> 00:48:28,550
array [i] = 0;

601
00:48:28,550 --> 00:48:31,390
რა ჩვენ ვხედავთ, რომ არასწორი აქ?

602
00:48:31,390 --> 00:48:39,480
როგორც მინიშნება, როდესაც აკეთებს GDB buggy4 - მოდით შესვენება მთავარ, პერსპექტივაში -

603
00:48:39,480 --> 00:48:45,980
მე ბეჭდვითი sizeof (Array) უბრალოდ რა მდგომარეობა არის, სადაც მე უნდა საბოლოოდ შესვენება out.

604
00:48:47,690 --> 00:48:51,100
სად ვარ მე? არ ვამბობ, აწარმოებს?

605
00:48:51,100 --> 00:48:54,280
მე არ ვაცხადებ, არავის გაუკეთებია.

606
00:48:54,280 --> 00:48:58,680
ამიტომ ბეჭდვა sizeof (Array) და ეს 20,

607
00:48:58,680 --> 00:49:06,690
რაც მოსალოდნელია, რადგან ჩემი array არის ზომა 5 და ეს სულ 5 რიცხვებით,

608
00:49:06,690 --> 00:49:12,410
ასე მთელი რამ უნდა იყოს 5 * sizeof (int) ბაიტი, სადაც sizeof (int) tends უნდა იყოს 4.

609
00:49:12,410 --> 00:49:14,780
ამიტომ sizeof (Array) არის 20.

610
00:49:14,780 --> 00:49:17,420
რა უნდა იყოს ეს?

611
00:49:17,420 --> 00:49:21,720
[სტუდენტი] დაყოფილი sizeof (int). >> Yeah, / sizeof (int).

612
00:49:21,720 --> 00:49:30,630
როგორც ჩანს, იქ მაინც პრობლემა აქ. მე ვფიქრობ, ეს უნდა იყოს მხოლოდ <

613
00:49:30,630 --> 00:49:36,960
რადგან საკმაოდ ბევრი ყოველთვის <და არასოდეს <=.

614
00:49:36,960 --> 00:49:44,860
ახლა მოდით ვიფიქროთ, ამიტომ ეს იყო რეალურად გატეხილი.

615
00:49:44,860 --> 00:49:53,370
ვინმეს არ მიხვდება რატომ მე დაიყვანება 0 მეშვეობით თითოეულ iteration of loop?

616
00:50:01,300 --> 00:50:09,350
ერთადერთი, რაც შიგნით აქ რომ ხდება ის არის, რომ მასივი [i] იქმნება, რომ 0.

617
00:50:09,350 --> 00:50:15,350
ასე რომ როგორღაც, ამ ხაზი კოდი რამ გამოიწვია ჩვენი int მე უნდა მითითებული 0.

618
00:50:16,730 --> 00:50:23,130
[სტუდენტი] შეიძლება, რადგან ის უმთავრესი მეხსიერების ამ ნაწილის მე

619
00:50:23,130 --> 00:50:27,970
როდესაც იგი მიიჩნევს, რომ ეს მორიგი ელემენტს მასივი? >> [Bowden] დიახ.

620
00:50:27,970 --> 00:50:33,880
როდესაც ჩვენ ვაპირებთ მიღმა ბოლოს ჩვენი მასივი,

621
00:50:33,880 --> 00:50:39,870
რატომღაც, რომ სივრცეში, რომ ჩვენ მნიშვნელოვანი არის უმთავრესი ღირებულება მე.

622
00:50:39,870 --> 00:50:48,030
და ასე თუ გადავხედავთ შევიდა buggy4, შესვენება მთავარ, პერსპექტივაში,

623
00:50:48,030 --> 00:50:53,120
მოდით ბეჭდვა მისამართი მე.

624
00:50:53,120 --> 00:50:57,280
როგორც ჩანს ეს bffff124.

625
00:50:57,280 --> 00:51:03,930
ახლა მოდით ბეჭდვა მისამართი array [0]. 110.

626
00:51:03,930 --> 00:51:06,290
რაც შეეხება [1]? 114.

627
00:51:06,290 --> 00:51:07,920
[2], 118.

628
00:51:07,920 --> 00:51:14,530
11C, 120. array [5] არის bfff124.

629
00:51:14,530 --> 00:51:26,990
ამიტომ array [5] აქვს იგივე მიმართვა როგორც მე, რაც იმას ნიშნავს, რომ მასივი [5] არის მე.

630
00:51:26,990 --> 00:51:30,720
თუ აქვთ იგივე მისამართზე, ისინი იგივე.

631
00:51:30,720 --> 00:51:38,410
ასე რომ, როდესაც ჩვენ დავსახეთ array [5] 0, ჩვენ ვქმნით მე რომ 0.

632
00:51:38,410 --> 00:51:46,070
და თუ ფიქრობთ, რომ ამ თვალსაზრისით დასტის,

633
00:51:46,070 --> 00:51:55,590
int მე ცხადდება პირველი, რაც იმას ნიშნავს, მე იღებს ცოტა ადგილის Stack.

634
00:51:55,590 --> 00:52:04,730
მაშინ array [5] გამოიყოფა, ასე შემდეგ 20 ბაიტი გამოიყოფა on Stack.

635
00:52:04,730 --> 00:52:08,400
ასე რომ იღებს გამოყოფილი პირველი, მაშინ ამ 20 ბაიტი მისაღებად გამოყოფილი.

636
00:52:08,400 --> 00:52:11,400
ასე რომ ხდება უფლება ადრე მასივი,

637
00:52:11,400 --> 00:52:19,230
და ამის გამო გზა, როგორიც მე გასულ კვირას განაცხადა, სადაც ტექნიკურად დასტის იზრდება down,

638
00:52:19,230 --> 00:52:28,520
როდესაც თქვენ ინდექსი შევიდა მასივი, ჩვენ გარანტირებული რომ 0th პოზიცია მასივი

639
00:52:28,520 --> 00:52:31,970
ყოველთვის ხდება ადრე პირველ პოზიციას მასივი.

640
00:52:31,970 --> 00:52:35,900
ეს არის ერთგვარი როგორ მიიპყრო იგი გასულ კვირას.

641
00:52:35,900 --> 00:52:42,210
გაითვალისწინეთ, რომ ბოლოში ჩვენ გვაქვს მისამართი 0 და ზედა გვაქვს მისამართი მაქს.

642
00:52:42,210 --> 00:52:44,880
დასტის ყოველთვის მზარდი ქვემოთ.

643
00:52:48,100 --> 00:52:53,500
ვთქვათ ჩვენ გამოყოფს მე.

644
00:52:53,500 --> 00:52:59,680
ჩვენ გამოყოფს რიცხვი i, რაც იმას ნიშნავს, მოდით უბრალოდ, ვამბობთ აქ მთელი მე იღებს გამოყოფილი.

645
00:52:59,680 --> 00:53:06,420
მაშინ ჩვენ გამოყოფს ჩვენი მასივი 5 რიცხვებით, რაც იმას ნიშნავს, რომ ქვევმოთ რომ,

646
00:53:06,420 --> 00:53:11,230
რადგან დასტის იზრდება ქვევით, იმ 5 რიცხვებით მისაღებად გამოყოფილი.

647
00:53:11,230 --> 00:53:15,900
მაგრამ როგორ კოლექტორები მუშაობა, ჩვენ გარანტირებულია, რომ პირველ პოზიციას მასივი

648
00:53:15,900 --> 00:53:22,260
ყოველთვის აქვს მისამართი ნაკლები მეორე რამ მასივი.

649
00:53:22,260 --> 00:53:28,270
ამიტომ მასივი თანამდებობა 0 ყოველთვის უნდა მოხდეს პირველი მეხსიერება,

650
00:53:28,270 --> 00:53:30,700
ხოლო მასივი პოზიცია 1 უნდა მოხდეს ამის შემდეგ

651
00:53:30,700 --> 00:53:33,310
და array პოზიცია 2 უნდა მოხდეს ამის შემდეგ,

652
00:53:33,310 --> 00:53:37,900
რაც იმას ნიშნავს, რომ მასივი თანამდებობა 0 მოხდებოდა სადღაც ქვევით აქ,

653
00:53:37,900 --> 00:53:40,690
array პოზიცია 1 მოხდებოდა ზემოთ რომ

654
00:53:40,690 --> 00:53:45,530
რადგან მოძრავი up ნიშნავს უმაღლესი მისამართები წლიდან მაქსიმალური მისამართი აქ.

655
00:53:45,530 --> 00:53:50,490
ამიტომ array [0] ქვევით აქ, array [1] აქ, array [2] აქ, array [3] აქ.

656
00:53:50,490 --> 00:53:55,620
შეამჩნევთ, თუ როგორ სანამ ჩვენ გამოყოფილი მთელი მე ყველა გზა აქ,

657
00:53:55,620 --> 00:54:01,040
როგორც ჩვენ გადაადგილება შემდგომი და შემდგომი ჩვენს მასივი, ჩვენ უახლოვდება და უფრო ახლოს ჩვენი რიცხვი მე.

658
00:54:01,040 --> 00:54:07,640
ეს უბრალოდ ისე ხდება, რომ მასივი [5], რომელიც არის ერთი პოზიცია მიღმა ჩვენი მასივი,

659
00:54:07,640 --> 00:54:13,010
სწორედ აქ მთელი მე მოხდა უნდა გამოიყოს.

660
00:54:13,010 --> 00:54:16,920
ასე რომ წერტილში, სადაც ჩვენ არ უნდა იყოს hitting სივრცე დასტის

661
00:54:16,920 --> 00:54:21,680
რომ გამოყოფილი მთელი მე და ჩვენ მიიღწევა, რომ 0.

662
00:54:21,680 --> 00:54:26,160
>> ასე რომ მუშაობს. კითხვები? Yeah.

663
00:54:26,160 --> 00:54:30,710
[სტუდენტი] არასოდეს გონება. Okay.

664
00:54:30,710 --> 00:54:33,090
[სტუდენტი] როგორ თავიდან ასაცილებლად ამ სახის შეცდომები?

665
00:54:33,090 --> 00:54:41,190
ეს ერთგვარი შეცდომები? არ გამოიყენოთ C როგორც თქვენი პროგრამირების ენა.

666
00:54:41,190 --> 00:54:45,840
გამოიყენეთ ენა რომ აქვს მასივი ფარგლებს შემოწმების.

667
00:54:45,840 --> 00:54:55,900
სანამ შენ ფრთხილად, თქვენ უბრალოდ უნდა თავიდან ავიცილოთ მიმდინარეობს წარსულის ფარგლებში თქვენი მასივი.

668
00:54:55,900 --> 00:54:58,300
[სტუდენტი] ასე აქ როდესაც წავედით წარსულში ფარგლებში თქვენი მასივი -

669
00:54:58,300 --> 00:55:01,840
[Bowden] სწორედ აქ რამ დაიწყება აპირებს არასწორია. >> [სტუდენტი] Oh, okay.

670
00:55:01,840 --> 00:55:05,730
როგორც თქვენ დარჩება ფარგლებში მეხსიერების გამოყოფილი თქვენი მასივი, თქვენ ჯარიმა.

671
00:55:05,730 --> 00:55:12,400
მაგრამ C არ დაუტოვებიათ შეცდომა შემოწმებისას. თუ array [1000], ის სიამოვნებით უბრალოდ ცვლილებები რაც არ უნდა მოხდეს -

672
00:55:12,400 --> 00:55:16,500
ეს ღებულობენ დასაწყისში მასივი, მაშინ იგი მიდის 1000 პოზიციები შემდეგ და ადგენს მას 0.

673
00:55:16,500 --> 00:55:20,000
იგი ამას არ გააკეთებს ნებისმიერი შემოწმება, რომ ოჰ, ეს ფაქტობრივად არ აქვს 1000 რამ იგი.

674
00:55:20,000 --> 00:55:22,750
1000 არის გზა მიღმა რა უნდა შეცვლა,

675
00:55:22,750 --> 00:55:26,940
ხოლო Java ან რამე წაიკითხონ მასივი ფარგლებს გარეთ ინდექსი

676
00:55:26,940 --> 00:55:29,820
ან ინდექსი ფარგლებს გარეთ გამონაკლისი.

677
00:55:29,820 --> 00:55:33,950
ამიტომ ბევრი უმაღლესი დონის ენებზე აქვს ეს ყველაფერი

678
00:55:33,950 --> 00:55:37,340
აქ თუ გასცდება ფარგლებში მასივი, თქვენ ვერ

679
00:55:37,340 --> 00:55:40,070
ასე რომ თქვენ ვერ შეცვლის ნივთები ქვევმოთ თქვენ

680
00:55:40,070 --> 00:55:42,590
და შემდეგ რამ წასვლა გაცილებით უარესი, ვიდრე უბრალოდ მიღების გამონაკლისი

681
00:55:42,590 --> 00:55:44,940
ვამბობთ, რომ თქვენ გასცდა ბოლოს მასივი.

682
00:55:44,940 --> 00:55:50,970
[სტუდენტი] და ასე უნდა ჩვენ ცოტა ხნის წინ შეიცვალა <= უბრალოდ <? >> [Bowden] Yeah.

683
00:55:50,970 --> 00:55:54,800
ეს უნდა იყოს <sizeof (მასივი) / sizeof (int);

684
00:55:54,800 --> 00:55:59,560
რადგან sizeof (Array) არის 20, მაგრამ ჩვენ მხოლოდ გვინდა 5. >> [სტუდენტი] მარჯვენა.

685
00:55:59,560 --> 00:56:04,060
სხვა კითხვები? Okay.

686
00:56:04,060 --> 00:56:07,380
>> [სტუდენტი] მე მაქვს შეკითხვა. >> Yeah.

687
00:56:07,380 --> 00:56:16,440
[სტუდენტი] რა არის ფაქტობრივი მასივი ცვლადი?

688
00:56:16,440 --> 00:56:20,000
[Bowden] Like რა არის მასივი?

689
00:56:20,000 --> 00:56:24,930
Array თავისთავად სიმბოლოა.

690
00:56:24,930 --> 00:56:31,490
უბრალოდ მისამართი დაწყების 20 ბაიტი, რომ ჩვენ referencing.

691
00:56:31,490 --> 00:56:38,070
თქვენ შეგიძლიათ ვფიქრობ, რომ ეს მაჩვენებელი, მაგრამ ეს მუდმივი მაჩვენებელი.

692
00:56:38,070 --> 00:56:44,140
როგორც კი რამ მისაღებად შედგენილი, ცვლადი მასივი აღარ არსებობს.

693
00:56:44,140 --> 00:56:48,210
[სტუდენტი] ასე როგორ მოვძებნოთ ზომა მასივი?

694
00:56:48,210 --> 00:56:54,130
ზომა მასივი ეხება ზომა, რომ ბლოკი, რომ სიმბოლო ეხება.

695
00:56:54,130 --> 00:57:01,240
როდესაც მე რაღაც მოსწონს printf ("% p \ n", array);

696
00:57:01,240 --> 00:57:05,140
მოდით გაუშვით.

697
00:57:12,960 --> 00:57:15,530
რა მე უბრალოდ არასწორად?

698
00:57:15,530 --> 00:57:19,220
Array 'array' განაცხადა აქ.

699
00:57:20,820 --> 00:57:23,200
ოჰ, აქ.

700
00:57:23,200 --> 00:57:31,250
Clang არის ჭკვიანი, და ეს მოხდება აღნიშვნა, რომ მე განაცხადა წყობის 5 ელემენტები

701
00:57:31,250 --> 00:57:34,540
მაგრამ მე ინდექსირებას შევიდა პოზიცია 1000.

702
00:57:34,540 --> 00:57:38,450
ეს შეგვიძლია გავაკეთოთ, რომ რადგან ეს უბრალოდ მუდმივები.

703
00:57:38,450 --> 00:57:43,370
ეს შეიძლება მხოლოდ იქ დღემდე დაენახა, რომ მე ვაპირებ მიღმა ფარგლებში მასივი.

704
00:57:43,370 --> 00:57:46,880
მაგრამ შეამჩნია ადრე, როდესაც ჩვენ გვქონდა მე იყოს არასწორი,

705
00:57:46,880 --> 00:57:51,040
მას არ შეუძლია შესაძლოა განსაზღვროს რამდენი ღირებულებების შემეძლო იღებს,

706
00:57:51,040 --> 00:57:55,540
ასე რომ ვერ განსაზღვრავს, რომ მე სცდება ბოლოს მასივი.

707
00:57:55,540 --> 00:57:59,430
ეს მხოლოდ Clang მყოფი ჭკვიანი.

708
00:57:59,430 --> 00:58:03,340
>> მაგრამ ახლა გააკეთოს buggy4. ასე რომ რა ვარ მე აკეთებს არასწორი?

709
00:58:03,340 --> 00:58:05,970
მინიშნებით გამოცხადების ბიბლიოთეკის ფუნქცია 'printf ".

710
00:58:05,970 --> 00:58:14,960
მე ვაპირებ გვინდა # მოიცავს <stdio.h>.

711
00:58:14,960 --> 00:58:18,710
Okay. კოალიციაში buggy4.

712
00:58:18,710 --> 00:58:24,840
პოლიგრაფიული ღირებულება მასივი მოსწონს მე აქ, ბეჭდვას, როგორც კურსორი

713
00:58:24,840 --> 00:58:30,060
ანაბეჭდები, რომ რაღაც ასე გამოიყურება - bfb8805c - რომელიც რამდენიმე მისამართი

714
00:58:30,060 --> 00:58:33,450
რომ წელს Stack-ish რეგიონში.

715
00:58:33,450 --> 00:58:41,820
Array თავისთავად მოსწონს მაჩვენებელი, მაგრამ ეს არ არის ფაქტობრივი მაჩვენებელი,

716
00:58:41,820 --> 00:58:45,410
რადგან რეგულარული მაჩვენებელი შეგვიძლია შევცვალოთ.

717
00:58:45,410 --> 00:58:54,700
Array არის რამოდენიმე მუდმივი. 20 ბლოკები მეხსიერების იწყება მისამართი 0xbfb8805c.

718
00:58:54,700 --> 00:59:09,020
ამიტომ bfb8805c მეშვეობით ამ მისამართზე +20- ან ვფიქრობ -20 -

719
00:59:09,020 --> 00:59:17,400
არის ყველა მეხსიერების გამოყოფილი ამ მასივი.

720
00:59:17,400 --> 00:59:20,350
Array, ცვლადი თავად არ ინახება არსად.

721
00:59:20,350 --> 00:59:27,660
როდესაც თქვენ შედგენის, შემდგენელი - ხელის ტალღა მას -

722
00:59:27,660 --> 00:59:33,060
მაგრამ შემდგენელი მხოლოდ გამოიყენოთ, სადაც ეს იცის მასივი იყოს.

723
00:59:33,060 --> 00:59:36,090
იგი დარწმუნებულია, სადაც ეს მასივი იწყება,

724
00:59:36,090 --> 00:59:40,910
ამიტომ ყოველთვის შეგიძლიათ უბრალოდ რამ თვალსაზრისით ჩათვლის, რომ დასაწყისია.

725
00:59:40,910 --> 00:59:43,960
მას არ დასჭირდება ცვლადი თავს წარმოადგენენ მასივი.

726
00:59:43,960 --> 00:59:53,730
მაგრამ როდესაც რაღაც მოსწონს int * p = array, ახლა P არის მაჩვენებელი, რომელიც მიუთითებს, რომ მასივი,

727
00:59:53,730 --> 00:59:57,830
და ახლა P რეალურად არ არსებობს Stack.

728
00:59:57,830 --> 01:00:01,950
მე თავისუფლად შეცვალოს გვ. შემიძლია p = malloc.

729
01:00:01,950 --> 01:00:06,500
ასე რომ თავდაპირველად აღნიშნა, რომ მასივი, ახლა ეს მიუთითებს ცოტა ადგილის ბევრი.

730
01:00:06,500 --> 01:00:09,620
მე ვერ array = malloc.

731
01:00:09,620 --> 01:00:13,710
თუ Clang არის ჭკვიანი, ის დაწეროთ at me უფლება off bat.

732
01:00:17,000 --> 01:00:21,430
სინამდვილეში, მე საკმაოდ დარწმუნებული gcc ყველაფერს გააკეთებს ამას.

733
01:00:21,430 --> 01:00:25,010
ამიტომ array ტიპის 'int [5] "არ არის assignable.

734
01:00:25,010 --> 01:00:28,040
თქვენ არ შეგიძლიათ დაავალოს რაღაც array ტიპის

735
01:00:28,040 --> 01:00:30,500
რადგან მასივი მხოლოდ მუდმივი.

736
01:00:30,500 --> 01:00:34,760
ეს არის სიმბოლო, რომელიც ცნობას იმ 20 ბაიტი. მე ვერ შეცვლის.

737
01:00:34,760 --> 01:00:37,690
>> [სტუდენტი] და სად არის ზომა მასივი ინახება?

738
01:00:37,690 --> 01:00:40,670
[Bowden] ეს არ ინახება არსად. ეს მაშინ, როდესაც ის შედგენა.

739
01:00:40,670 --> 01:00:46,310
ისე სად არის ზომა მასივი ინახება?

740
01:00:46,310 --> 01:00:51,870
თქვენ შეგიძლიათ გამოიყენოთ მხოლოდ sizeof (Array) შიგნით ფუნქცია მასივი გამოცხადებისთანავე.

741
01:00:51,870 --> 01:01:03,150
ასე რომ, თუ რაღაც ფუნქცია, foo, და გავაკეთე (int array [])

742
01:01:03,150 --> 01:01:10,450
printf ("% d \ n", sizeof (Array));

743
01:01:10,450 --> 01:01:21,330
და შემდეგ ქვევით აქ მოვუწოდებ foo (მასივი);

744
01:01:21,330 --> 01:01:24,840
შიგნით ამ ფუნქციის - მოდით გაუშვით.

745
01:01:34,200 --> 01:01:36,840
ეს არის Clang მყოფი ჭკვიანი ერთხელ.

746
01:01:36,840 --> 01:01:43,890
ის მეუბნებოდა, რომ sizeof on მასივი ფუნქციის პარამეტრი

747
01:01:43,890 --> 01:01:46,690
დაბრუნდება ზომა 'int *'.

748
01:01:46,690 --> 01:01:55,150
ეს იქნებოდა შეცდომა, თუ ის არ არის რაც მინდოდა მომხდარიყო.

749
01:01:55,150 --> 01:01:58,960
მოდით რეალურად გამორთეთ Werror.

750
01:02:14,950 --> 01:02:17,590
გაფრთხილება. გაფრთხილებები არის ჯარიმა.

751
01:02:17,590 --> 01:02:19,960
ის მაინც შეადგინოს სანამ მას გაფრთხილება.

752
01:02:19,960 --> 01:02:22,910
. / A.out აპირებს ბეჭდვა 4.

753
01:02:22,910 --> 01:02:28,650
გაფრთხილება, რომელიც გენერირდება არის ნათელი მაჩვენებელია, თუ რა წავიდა არასწორად.

754
01:02:28,650 --> 01:02:34,120
ეს int array მხოლოდ აპირებს ბეჭდვა sizeof (int *).

755
01:02:34,120 --> 01:02:39,790
მაშინაც კი, თუ მე ზუსტად array [5] აქ, მაინც უბრალოდ აპირებს ბეჭდვა sizeof (int *).

756
01:02:39,790 --> 01:02:47,440
ამიტომ, როგორც კი თქვენ გაივლის ის ფუნქცია, განსხვავება შორის კოლექტორები და მითითებები

757
01:02:47,440 --> 01:02:49,670
არის არარსებული.

758
01:02:49,670 --> 01:02:52,640
ეს ხდება იყოს მასივი, რომელიც გამოცხადებული დასტის,

759
01:02:52,640 --> 01:02:58,300
მაგრამ როგორც კი ჩვენ გაიაროს, რომ ღირებულება, რომ 0xbf blah, blah, blah ამ ფუნქციას,

760
01:02:58,300 --> 01:03:03,350
მაშინ ეს მაჩვენებელი მიუთითებს, რომ მასივი on Stack.

761
01:03:03,350 --> 01:03:08,310
ასე რომ, რაც იმას ნიშნავს, რომ sizeof მხოლოდ ეხება ფუნქცია მასივი გამოცხადდა,

762
01:03:08,310 --> 01:03:11,230
რაც იმას ნიშნავს, რომ როდესაც თქვენ შედგენის ამ ფუნქციის,

763
01:03:11,230 --> 01:03:17,330
როდესაც Clang გადის ამ ფუნქციის, ის ხედავს მასივი int მასივი ზომა 5.

764
01:03:17,330 --> 01:03:20,640
ასე რომ მაშინ ხედავს sizeof (მასივი). ისე, რომ 20.

765
01:03:20,640 --> 01:03:26,440
სწორედ პრაქტიკულად როგორ sizeof ძირითადად მუშაობს თითქმის ყველა შემთხვევაში.

766
01:03:26,440 --> 01:03:31,150
Sizeof არ არის ფუნქციის ის ოპერატორი.

767
01:03:31,150 --> 01:03:33,570
თქვენ არ მოვუწოდებთ sizeof ფუნქცია.

768
01:03:33,570 --> 01:03:38,280
Sizeof (int), შემდგენელი მხოლოდ თარგმნოს, რომ 4.

769
01:03:41,480 --> 01:03:43,700
Got it? Okay.

770
01:03:43,700 --> 01:03:47,520
>> [სტუდენტი] რა არის განსხვავება sizeof (Array) მთავარ და foo?

771
01:03:47,520 --> 01:03:52,840
ეს იმიტომ რომ ჩვენ ვამბობთ, sizeof (მასივი), რომელიც ტიპის int *,

772
01:03:52,840 --> 01:03:57,120
ხოლო მასივი ქვემოთ აქ არ არის ტიპის int *, ეს int მასივი.

773
01:03:57,120 --> 01:04:04,540
>> [სტუდენტი] ასე რომ, თუ თქვენ გქონდათ პარამეტრი array [] ნაცვლად int * array,

774
01:04:04,540 --> 01:04:09,230
იქნებოდა, რომ ნიშნავს, რომ თქვენ შეიძლება მაინც შეიცვალოს მასივი, ვინაიდან, ახლა ეს მაჩვენებელი?

775
01:04:09,230 --> 01:04:14,250
[Bowden] ასე? >> [სტუდენტი] Yeah. შეგიძლიათ შეცვალოთ მასივი ფარგლებში ფუნქცია არის?

776
01:04:14,250 --> 01:04:18,420
[Bowden] თქვენ შეიძლება შეიცვალოს მასივი ორივე შემთხვევაში.

777
01:04:18,420 --> 01:04:23,130
ორივე შემთხვევაში თქვენ თავისუფლად ვთქვა array [4] = 0.

778
01:04:23,130 --> 01:04:26,590
[სტუდენტი] მაგრამ შეგიძლიათ მასივი წერტილი რაღაც?

779
01:04:26,590 --> 01:04:30,230
[Bowden] Oh. Yeah. ორივე შემთხვევაში - >> [სტუდენტი] Yeah.

780
01:04:30,230 --> 01:04:38,410
[Bowden] განსხვავება შორის array [] და int * array, არსებობს არცერთი.

781
01:04:38,410 --> 01:04:42,570
ასევე შეგიძლიათ ზოგიერთი მრავალგანზომილებიანი მასივი აქ

782
01:04:42,570 --> 01:04:47,050
ზოგიერთი მოსახერხებელი სინტაქსი, მაგრამ მაინც მხოლოდ კურსორი.

783
01:04:47,050 --> 01:04:56,400
ეს ნიშნავს, რომ მე ვარ თავისუფალი გავაკეთოთ array = malloc (sizeof (int)) და ახლა აღვნიშნო სხვაგან.

784
01:04:56,400 --> 01:04:59,610
მაგრამ ისევე როგორც ეს მუშაობს სამუდამოდ და ყოველთვის,

785
01:04:59,610 --> 01:05:03,210
იცვლება ამ მასივი მიერ მიღების იგი აღვნიშნო, რომ რაღაც

786
01:05:03,210 --> 01:05:07,570
არ იცვლება ამ მასივი ქვემოთ აქ იმიტომ რომ ასლი არგუმენტი,

787
01:05:07,570 --> 01:05:10,780
ეს არ მომცეთ ეს არგუმენტი.

788
01:05:10,780 --> 01:05:16,070
და ფაქტობრივად, ისევე როგორც უფრო იმაზე მიანიშნებს, რომ ეს ზუსტად იგივე -

789
01:05:16,070 --> 01:05:21,100
ჩვენ უკვე ვნახეთ, რა ბეჭდვის მასივი ანაბეჭდები -

790
01:05:21,100 --> 01:05:31,410
რა თუ ჩვენ ბეჭდვა მისამართი მასივი ან მისამართი მისამართი მასივი

791
01:05:31,410 --> 01:05:36,290
ან იმ?

792
01:05:41,770 --> 01:05:45,220
მოდით იგნორირება ამ ერთ.

793
01:05:48,140 --> 01:05:51,660
Okay. ეს არის ჯარიმა. ეს არის გაშვებული. / A.out.

794
01:05:51,660 --> 01:06:00,220
ბეჭდვის მასივი, მაშინ ბეჭდვა მისამართი მასივი, არის იგივე.

795
01:06:00,220 --> 01:06:02,870
Array უბრალოდ არ არსებობს.

796
01:06:02,870 --> 01:06:08,190
იგი დარწმუნებულია, როდესაც თქვენ ბეჭდვა მასივი, თქვენ დაბეჭდვის სიმბოლო იმისა, რომ ეხება იმ 20 ბაიტი.

797
01:06:08,190 --> 01:06:11,940
პოლიგრაფიული მისამართი მასივი, ისევე, array არ არსებობს.

798
01:06:11,940 --> 01:06:17,200
არა აქვს მისამართი, ასე რომ უბრალოდ ბეჭდავს მისამართი იმ 20 ბაიტი.

799
01:06:20,820 --> 01:06:28,150
როგორც კი კომპილაციის ქვემოთ, ისევე როგორც თქვენი შედგენილი buggy4. / A.out,

800
01:06:28,150 --> 01:06:30,340
array არის არარსებული.

801
01:06:30,340 --> 01:06:33,640
პოინტერები არსებობს. მასივები არა.

802
01:06:34,300 --> 01:06:38,060
ბლოკები მეხსიერების წარმოადგენს მასივს კიდევ არსებობს,

803
01:06:38,060 --> 01:06:43,270
მაგრამ ცვლადი მასივი და ცვლადების ტიპის არ არსებობს.

804
01:06:46,260 --> 01:06:50,270
ეს ის მსგავსად ძირითადი განსხვავებები კოლექტორები და მითითებები

805
01:06:50,270 --> 01:06:55,590
მათ, როგორც კი თქვენ მიიღოს ფუნქცია მოუწოდებს, არ არსებობს განსხვავება.

806
01:06:55,590 --> 01:07:00,460
მაგრამ შიგნით ფუნქცია მასივი თავად განაცხადა, sizeof მუშაობს განსხვავებულად

807
01:07:00,460 --> 01:07:05,190
მას შემდეგ, რაც თქვენ დაბეჭდვის ზომის ბლოკები ნაცვლად ზომის ტიპის,

808
01:07:05,190 --> 01:07:08,950
და ვერ შეცვლის, რადგან ეს სიმბოლო.

809
01:07:08,950 --> 01:07:14,370
პოლიგრაფიული რამ და მისამართი რამ ბეჭდავს იგივე.

810
01:07:14,370 --> 01:07:18,480
და ეს საკმაოდ ბევრი იყო.

811
01:07:18,480 --> 01:07:20,820
[სტუდენტი] იქნებ ვთქვა, რომ კიდევ ერთხელ?

812
01:07:21,170 --> 01:07:24,170
მე შეიძლება გამომრჩა რაღაც.

813
01:07:24,170 --> 01:07:29,260
ბეჭდვის array და მისამართი მასივი ბეჭდავს იგივე,

814
01:07:29,260 --> 01:07:33,180
ხოლო თუ თქვენ ბეჭდვა მაჩვენებელი წინააღმდეგ მისამართი მაჩვენებელი,

815
01:07:33,180 --> 01:07:36,010
ერთი რამ ბეჭდავს მისამართი თუ რას მიუთითებს,

816
01:07:36,010 --> 01:07:40,360
სხვა ბეჭდავს მისამართი მაჩვენებელი on Stack.

817
01:07:40,360 --> 01:07:47,040
თქვენ შეგიძლიათ შეცვალოთ კურსორი, თქვენ ვერ შეცვლის მასივი სიმბოლო.

818
01:07:47,740 --> 01:07:53,270
და sizeof მაჩვენებელი აპირებს ბეჭდვა ზომის რომ მაჩვენებელი ტიპის.

819
01:07:53,270 --> 01:07:57,470
ასე int * p sizeof (P) აპირებს ბეჭდვა 4,

820
01:07:57,470 --> 01:08:04,110
მაგრამ int array [5] ბეჭდვითი sizeof (Array) აპირებს ბეჭდვა 20.

821
01:08:04,110 --> 01:08:07,480
[სტუდენტი] ასე int array [5] იქნება ბეჭდვა 20? >> დიახ.

822
01:08:07,480 --> 01:08:13,300
ამიტომ შიგნით buggy4 როდესაც იგი გამოყენებული იქნება sizeof (Array)

823
01:08:13,300 --> 01:08:16,660
ამ აკეთებდა მე <20, რომელიც არ არის, რაც გვინდოდა.

824
01:08:16,660 --> 01:08:20,880
ჩვენ გვინდა მე <5. >> [სტუდენტი] Okay.

825
01:08:20,880 --> 01:08:25,569
[Bowden] და მაშინ, როგორც კი თქვენ დაიწყოს გადადის ფუნქციების

826
01:08:25,569 --> 01:08:34,340
თითქოს ჩვენ აქ int * p = array;

827
01:08:34,340 --> 01:08:39,779
შიგნით ამ ფუნქციას, ჩვენ შეგვიძლია გამოვიყენოთ ძირითადად P და array ზუსტად იგივე გზა,

828
01:08:39,779 --> 01:08:43,710
გარდა sizeof პრობლემა და შეცვლის პრობლემა.

829
01:08:43,710 --> 01:08:49,810
მაგრამ P [0] = 1; იგივეა დაყრდნობით array [0] = 1;

830
01:08:49,810 --> 01:08:55,600
და როგორც კი ვამბობთ foo (მასივი); ან foo (P);

831
01:08:55,600 --> 01:08:59,760
შიგნით foo ფუნქცია, ეს არის იგივე ზარი ორჯერ.

832
01:08:59,760 --> 01:09:03,350
არ არსებობს განსხვავება შორის ამ ორი მოუწოდებს.

833
01:09:07,029 --> 01:09:11,080
>> ყველას კარგი რომ? Okay.

834
01:09:14,620 --> 01:09:17,950
ჩვენ გვყავს 10 წუთის განმავლობაში.

835
01:09:17,950 --> 01:09:28,319
>> ჩვენ შევეცდებით ვუკავშირდებოდი ამ Hacker Typer პროგრამა,

836
01:09:28,319 --> 01:09:32,350
ამ ნახვა, რომელიც გამოვიდა გასულ წელს ან რამე.

837
01:09:34,149 --> 01:09:41,100
უბრალოდ უნდა იყოს თქვენნაირი აკრიფოთ შემთხვევით და ეს ბეჭდავს out -

838
01:09:41,100 --> 01:09:46,729
როგორიც არ უნდა იყოს ფაილი ეს მოხდება, არ არის დატვირთული, თუ რას ჰგავს თქვენ აკრეფით.

839
01:09:46,729 --> 01:09:52,069
როგორც ჩანს რაღაც ოპერაციული სისტემის კოდი.

840
01:09:53,760 --> 01:09:56,890
რაც გვინდა, რომ განახორციელონ.

841
01:10:08,560 --> 01:10:11,690
თქვენ უნდა ჰქონდეს ორობითი შესრულებადი დაასახელა hacker_typer

842
01:10:11,690 --> 01:10:14,350
რომ იღებს ერთი არგუმენტი, ფაილი "Hacker ტიპის."

843
01:10:14,350 --> 01:10:16,480
Running შესრულებადი უნდა გარკვევას ეკრანზე

844
01:10:16,480 --> 01:10:20,850
და შემდეგ ამობეჭდოთ ერთი ხასიათი გაიარა-ში ფაილი ყოველ ჯერზე მომხმარებლის presses გასაღები.

845
01:10:20,850 --> 01:10:24,990
ასე რომ რაც არ უნდა გასაღები დააჭერთ, უნდა გადააგდებს და ნაცვლად ბეჭდვა ხასიათი ფაილი

846
01:10:24,990 --> 01:10:27,810
რომ არის არგუმენტი.

847
01:10:29,880 --> 01:10:34,350
მე საკმაოდ ბევრი გითხრათ, რა რამ ჩვენ ვაპირებთ უნდა იცოდეთ არიან.

848
01:10:34,350 --> 01:10:36,440
მაგრამ ჩვენ გვინდა, რომ შეამოწმეთ termios ბიბლიოთეკაში.

849
01:10:36,440 --> 01:10:44,840
მე არასოდეს გამოიყენება ამ ბიბლიოთეკის ჩემი მთელი ცხოვრება, ასე რომ მას აქვს ძალიან მინიმალური მიზნებისათვის.

850
01:10:44,840 --> 01:10:48,610
მაგრამ ეს იქნება ბიბლიოთეკის ჩვენ შეგვიძლია გამოვიყენოთ, რათა გადაყარეთ ხასიათი თქვენ მოხვდა

851
01:10:48,610 --> 01:10:52,390
როდესაც თქვენ აკრეფით შევიდა სტანდარტული სისტემაში

852
01:10:56,970 --> 01:11:05,840
ამიტომ hacker_typer.c, და ჩვენ ვაპირებთ გვინდა # მოიცავს <stdio.h>.

853
01:11:05,840 --> 01:11:12,870
ეძებს კაცს გვერდი termios - I'm გამოცნობა მისი ტერმინალური OS ან რაღაც -

854
01:11:12,870 --> 01:11:16,240
მე არ ვიცი როგორ წაიკითხავს.

855
01:11:16,240 --> 01:11:21,040
ეძებს ამ, ნათქვამია, რომ მოიცავს ეს 2 ფაილი, ამიტომ ჩვენ ყველაფერს გავაკეთებთ, რომ.

856
01:11:37,620 --> 01:11:46,820
>> პირველი, რაც პირველ რიგში, ჩვენ გვინდა, რომ მიიღოს ერთ არგუმენტად, რომელიც ფაილი უნდა გახსნა.

857
01:11:46,820 --> 01:11:52,420
ასე რომ რა გსურთ? როგორ შემიძლია შეამოწმეთ მაქვს ერთი არგუმენტი?

858
01:11:52,420 --> 01:11:56,480
[სტუდენტი] თუ argc შეადგენს იგი. >> [Bowden] Yeah.

859
01:11:56,480 --> 01:12:21,250
ასე რომ, თუ (argc = 2) printf ("გამოყენება:% s [ფაილის გასახსნელად]").

860
01:12:21,250 --> 01:12:32,750
ახლა თუ აწარმოებს ამ გარეშე მიწოდების მეორე არგუმენტი - Oh, მჭირდება ახალი ხაზი -

861
01:12:32,750 --> 01:12:36,240
დაინახავთ ნათქვამია გამოყენება:. / hacker_typer,

862
01:12:36,240 --> 01:12:39,770
და მაშინ მეორე არგუმენტი უნდა იყოს ფაილი მინდა გახსნა.

863
01:12:58,430 --> 01:13:01,260
ახლა რა ვქნათ?

864
01:13:01,260 --> 01:13:08,490
მინდა წაკითხვის ამ ფაილის. როგორ შემიძლია წაკითხვის ფაილი?

865
01:13:08,490 --> 01:13:11,920
[სტუდენტი] ვხსნით მას პირველი. >> Yeah.

866
01:13:11,920 --> 01:13:15,010
ამიტომ fopen. რას fopen გამოიყურებოდეს?

867
01:13:15,010 --> 01:13:22,980
[სტუდენტი] Filename. >> [Bowden] Filename იქნება argv [1].

868
01:13:22,980 --> 01:13:26,110
[სტუდენტი] და მერე რა გსურთ შუაში იყო, ასე რომ - >> [Bowden] Yeah.

869
01:13:26,110 --> 01:13:28,740
ასე რომ, თუ თქვენ არ გახსოვთ, თქვენ შეიძლება უბრალოდ კაცი fopen,

870
01:13:28,740 --> 01:13:32,960
სადაც ეს იქნება const char * გეზი, სადაც ბილიკი არის ფაილის სახელი,

871
01:13:32,960 --> 01:13:34,970
const char * რეჟიმში.

872
01:13:34,970 --> 01:13:38,660
თუ ემართება არ გახსოვთ რა რეჟიმში, მაშინ გადახედეთ რეჟიმში.

873
01:13:38,660 --> 01:13:44,660
შიგნით კაცი გვერდებზე, ირიბის ხასიათი არის ის, რაც შეგიძლიათ გამოიყენოთ მოძებნოთ ნივთები.

874
01:13:44,660 --> 01:13:49,790
ასე რომ, მე Type / რეჟიმში მოძიების რეჟიმში.

875
01:13:49,790 --> 01:13:57,130
N და N არიან რა შეგიძლიათ გამოიყენოთ ციკლის გავლით ძებნა მატჩები.

876
01:13:57,130 --> 01:13:59,800
აქ ნათქვამია არგუმენტი რეჟიმში მიუთითებს სიმებიანი

877
01:13:59,800 --> 01:14:01,930
დაწყებული ერთი შემდეგი sequences.

878
01:14:01,930 --> 01:14:06,480
ამიტომ R, ღია ტექსტი ფაილი მოსმენით. რაც გვინდა, რომ გავაკეთოთ.

879
01:14:08,930 --> 01:14:13,210
კითხულობს, და მინდა, რომ შესანახად.

880
01:14:13,210 --> 01:14:18,720
რამ იქნება ფაილ *. ახლა რა გსურთ?

881
01:14:18,720 --> 01:14:21,200
მომეცი მეორე.

882
01:14:28,140 --> 01:14:30,430
Okay. ახლა რა გსურთ?

883
01:14:30,430 --> 01:14:32,940
[სტუდენტი] შეამოწმეთ თუ null. >> [Bowden] Yeah.

884
01:14:32,940 --> 01:14:38,690
ნებისმიერ დროს გახსნა ფაილი, დარწმუნდით, რომ თქვენ წარმატებით შეუძლიათ გახსნან.

885
01:14:58,930 --> 01:15:10,460
>> ახლა მინდა გავაკეთოთ, რომ termios პერსონალის სადაც მინდა პირველი წაიკითხა ჩემი მიმდინარე პარამეტრების

886
01:15:10,460 --> 01:15:14,050
და გადარჩენა იმ შევიდა რაღაც, მაშინ მინდა, რომ შევცვალო ჩემი პარამეტრების

887
01:15:14,050 --> 01:15:19,420
to გადაყარეთ ნებისმიერი ხასიათი რომ მე ტიპის,

888
01:15:19,420 --> 01:15:22,520
და შემდეგ მინდა განაახლოს იმ პარამეტრების.

889
01:15:22,520 --> 01:15:27,250
და შემდეგ დასასრულს პროგრამა, მინდა რომ შეიცვალოს თავში ჩემი ორიგინალური პარამეტრები.

890
01:15:27,250 --> 01:15:32,080
ამიტომ struct იქნება ტიპის termios, და მე ვაპირებ მინდა ორი იმ.

891
01:15:32,080 --> 01:15:35,600
პირველი იქნება ჩემი current_settings,

892
01:15:35,600 --> 01:15:42,010
და მაშინ იქნება ჩემი hacker_settings.

893
01:15:42,010 --> 01:15:48,070
პირველი, მე ვაპირებ მინდა გადარჩენა ჩემი მიმდინარე პარამეტრების,

894
01:15:48,070 --> 01:15:53,790
მაშინ მე ვაპირებ გსურთ განაახლოთ hacker_settings,

895
01:15:53,790 --> 01:16:01,570
და შემდეგ გზა დასასრულს ჩემი პროგრამა, მინდა დაუბრუნდება არსებული პარამეტრები.

896
01:16:01,570 --> 01:16:08,660
ამიტომ გადარჩენის მიმდინარე პარამეტრების, ისე, რომ მუშაობს, ჩვენ კაცს termios.

897
01:16:08,660 --> 01:16:15,810
ჩვენ ვხედავთ, რომ ჩვენ გვაქვს ეს int tcsetattr, int tcgetattr.

898
01:16:15,810 --> 01:16:22,960
მე კორიდორი termios struct მისი მაჩვენებელი.

899
01:16:22,960 --> 01:16:30,640
გზა ამ გამოიყურება არის - I've უკვე დაავიწყდათ, რა ფუნქცია ეწოდა.

900
01:16:30,640 --> 01:16:34,930
დააკოპირეთ და ჩასვით იგი.

901
01:16:39,150 --> 01:16:45,500
ამიტომ tcgetattr, მაშინ მინდა კორიდორი struct რომ მე გადარჩენის ინფორმაციას,

902
01:16:45,500 --> 01:16:49,650
რომელიც იქნება current_settings,

903
01:16:49,650 --> 01:16:59,120
და პირველი არგუმენტი არის ფაილის descriptor ამისთვის რამ მინდა გადარჩენა ატრიბუტები.

904
01:16:59,120 --> 01:17:04,360
რა ფაილი descriptor არის ჰგავს ნებისმიერ დროს გახსნა ფაილი, ის იღებს ფაილს descriptor.

905
01:17:04,360 --> 01:17:14,560
როდესაც მე fopen argv [1], იგი იღებს ფაილის descriptor რომელიც თქვენ referencing

906
01:17:14,560 --> 01:17:16,730
მაშინ, როცა გნებავთ წაკითხვის ან ჩაწერის იგი.

907
01:17:16,730 --> 01:17:19,220
ეს არ არის ფაილის descriptor მინდა აქ.

908
01:17:19,220 --> 01:17:21,940
არსებობს სამი ფაილი აღწერებს გაქვთ ჩვეულებრივ,

909
01:17:21,940 --> 01:17:24,310
რომლებიც სტანდარტს, სტანდარტული, და სტანდარტული შეცდომა.

910
01:17:24,310 --> 01:17:29,960
ჩვეულებრივ, მე ვფიქრობ, სტანდარტი არის 0, სტანდარტული გარეთ არის 1, და სტანდარტული შეცდომა 2.

911
01:17:29,960 --> 01:17:33,980
ასე რომ რა გსურთ შეცვალოთ პარამეტრები?

912
01:17:33,980 --> 01:17:37,370
მინდა შეიცვალოს პარამეტრების როდესაც მე მოხვდა ხასიათი,

913
01:17:37,370 --> 01:17:41,590
მინდა ეს იმისათვის, რომ ხასიათი მოშორებით ნაცვლად დაბეჭდვის მას ეკრანზე.

914
01:17:41,590 --> 01:17:45,960
რა ნაკადი - სტანდარტი, სტანდარტული მათგანი, ან სტანდარტული შეცდომა -

915
01:17:45,960 --> 01:17:52,050
პასუხობს რამ როცა აკრიფეთ კლავიატურაზე? >> [სტუდენტი] სტანდარტული შემოსული >> Yeah.

916
01:17:52,050 --> 01:17:56,450
ასე, რომ შეიძლება არც გააკეთონ 0 ან შემიძლია stdin.

917
01:17:56,450 --> 01:17:59,380
მე მიღების current_settings სტანდარტული სისტემაში

918
01:17:59,380 --> 01:18:01,720
>> ახლა მინდა განაახლოს იმ პარამეტრების,

919
01:18:01,720 --> 01:18:07,200
ამიტომ პირველ მე კოპირება შევიდა hacker_settings რა ჩემი current_settings არიან.

920
01:18:07,200 --> 01:18:10,430
და როგორ structs მუშაობა იქნება გადააკოპირეთ.

921
01:18:10,430 --> 01:18:14,510
ეს აკოპირებს ყველა სფეროში, როგორც თქვენ მოელოდა.

922
01:18:14,510 --> 01:18:17,410
>> ახლა მინდა განაახლოთ ზოგიერთი სფეროებში.

923
01:18:17,410 --> 01:18:21,670
ეძებს termios, თქვენ უნდა წაიკითხოთ ბევრი რამ ამ

924
01:18:21,670 --> 01:18:24,110
მხოლოდ ვხედავ, რაც თქვენ სურს, ვეძებოთ,

925
01:18:24,110 --> 01:18:28,210
მაგრამ დროშები თქვენ აპირებს გვინდა ვეძებოთ არიან ეხო,

926
01:18:28,210 --> 01:18:33,110
ასე ეხო ეხო შეყვანის სიმბოლო.

927
01:18:33,110 --> 01:18:37,710
პირველი მინდა Set - I've უკვე დაავიწყდათ რა დარგები.

928
01:18:45,040 --> 01:18:47,900
ეს არის ის, რაც struct ჰგავს.

929
01:18:47,900 --> 01:18:51,060
ამიტომ შეყვანის რეჟიმები ვფიქრობ ჩვენ გვინდა, რომ შეიცვალოს.

930
01:18:51,060 --> 01:18:54,210
ჩვენ შევხედოთ გადაწყვეტა დავრწმუნდეთ, რომ ის, რაც ჩვენ გვინდა, რომ შეიცვალოს.

931
01:19:04,060 --> 01:19:12,610
ჩვენ გვინდა, რომ შეიცვალოს lflag პრევენციის მიზნით სჭირდება გაეცნონ ყველა ამ.

932
01:19:12,610 --> 01:19:14,670
ჩვენ გვინდა, რომ შეიცვალოს ადგილობრივი რეჟიმები.

933
01:19:14,670 --> 01:19:17,710
თქვენ უნდა წაიკითხოთ მეშვეობით მთელი უნდა გავითვალისწინოთ სადაც ყველაფერი ეკუთვნის

934
01:19:17,710 --> 01:19:19,320
რომ ჩვენ გვინდა, რომ შეიცვალოს.

935
01:19:19,320 --> 01:19:24,120
მაგრამ ეს შიგნით ადგილობრივი რეჟიმები, სადაც ჩვენ ვაპირებთ გსურთ შეცვალოთ, რომ.

936
01:19:27,080 --> 01:19:33,110
ამიტომ hacker_settings.cc_lmode არის რასაც ის მოუწოდა.

937
01:19:39,630 --> 01:19:43,020
c_lflag.

938
01:19:49,060 --> 01:19:52,280
ეს არის სადაც ჩვენ შეღწევას bitwise ოპერატორები.

939
01:19:52,280 --> 01:19:54,860
ჩვენ სახის გარეთ, მაგრამ ჩვენ გავლა ეს რეალური სწრაფი.

940
01:19:54,860 --> 01:19:56,600
ეს არის სადაც ჩვენ შეღწევას bitwise ოპერატორები,

941
01:19:56,600 --> 01:19:59,950
აქ ვფიქრობ, განაცხადა ერთ დროს დიდი ხნის წინ, რომ როდესაც თქვენ დავიწყოთ საქმე დროშები,

942
01:19:59,950 --> 01:20:03,370
თქვენ უნდა გამოყენებით bitwise ოპერატორი ლოტი.

943
01:20:03,370 --> 01:20:08,240
თითოეული წვლილი დროშა შეესაბამება გარკვეული ქმედებები.

944
01:20:08,240 --> 01:20:14,090
ასე რომ აქ, ამ დროშის bunch სხვადასხვა ნივთები, სადაც ყველა მათგანი ნიშნავს რაიმე განსხვავებული.

945
01:20:14,090 --> 01:20:18,690
მაგრამ რა მინდა გააკეთოთ უბრალოდ გამორთეთ ცოტა რაც შეესაბამება ეხო.

946
01:20:18,690 --> 01:20:25,440
ასე რომ ჩართოთ, რომ off გავაკეთო და = ¬ ECHO.

947
01:20:25,440 --> 01:20:30,110
სინამდვილეში, ვფიქრობ, როგორიცაა tECHO ან რამე. მე უბრალოდ აპირებს შეამოწმოს ერთხელ.

948
01:20:30,110 --> 01:20:34,050
შემიძლია termios იგი. უბრალოდ ეხო.

949
01:20:34,050 --> 01:20:38,440
ECHO იქნება ერთი ცოტა.

950
01:20:38,440 --> 01:20:44,230
¬ ECHO აპირებს ნიშნავს ყველა ბიტი უეჭველია, რომ 1, რაც ნიშნავს ყველა დროშები მითითებული 'ჭეშმარიტი

951
01:20:44,230 --> 01:20:47,140
გარდა ECHO bit.

952
01:20:47,140 --> 01:20:53,830
By დამთავრებული ჩემი ადგილობრივი დროშები ამისა, ეს ნიშნავს ყველა დროშები, რომლებიც გაკეთებული მითითებული 'ჭეშმარიტი

953
01:20:53,830 --> 01:20:56,520
იქნება მითითებული 'ჭეშმარიტი.

954
01:20:56,520 --> 01:21:03,240
თუ ჩემი ECHO დროშა არის მითითებული, რომ ასეა, მაშინ ეს არის აუცილებლად მითითებული ყალბი on ECHO დროშა.

955
01:21:03,240 --> 01:21:07,170
ასე რომ, ეს ხაზი კოდი უბრალოდ თიშავს ECHO დროშა.

956
01:21:07,170 --> 01:21:16,270
სხვა ხაზების კოდი, მე გადააკოპირეთ მათ ინტერესი დრო და შემდეგ აუხსნას მათ.

957
01:21:27,810 --> 01:21:30,180
In გადაწყვეტა, მისი თქმით 0.

958
01:21:30,180 --> 01:21:33,880
ალბათ უკეთესი მკაფიოდ ამბობენ stdin.

959
01:21:33,880 --> 01:21:42,100
>> გაითვალისწინეთ, რომ მე ასევე აკეთებს ECHO | ICANON აქ.

960
01:21:42,100 --> 01:21:46,650
ICANON ეხება რაღაც ცალკე, რაც იმას ნიშნავს, კანონიკური რეჟიმში.

961
01:21:46,650 --> 01:21:50,280
რა კანონიკურ რეჟიმში საშუალებები ჩვეულებრივ, როდესაც თქვენ აკრეფით გარეთ ბრძანება ხაზი,

962
01:21:50,280 --> 01:21:54,670
სტანდარტი არ გადაამუშავებს არაფერი სანამ არ მოხვდა სტრიქონების გადატანით.

963
01:21:54,670 --> 01:21:58,230
ასე რომ, როდესაც თქვენ ჩვენგან GetString, თქვენ ტიპი bunch რამ, მაშინ მოხვდა სტრიქონების გადატანით.

964
01:21:58,230 --> 01:22:00,590
სწორედ მაშინ ის იგზავნება სტანდარტული სისტემაში

965
01:22:00,590 --> 01:22:02,680
სწორედ იყოს.

966
01:22:02,680 --> 01:22:05,830
როდესაც მე გამორთეთ კანონიკურ რეჟიმში, ახლა თითოეული ხასიათი დააჭერთ

967
01:22:05,830 --> 01:22:10,910
არის ის, რაც ხდება დამუშავებული, რაც, როგორც წესი, სახის ცუდი იმიტომ რომ ნელი დავამუშავოთ ეს ყველაფერი,

968
01:22:10,910 --> 01:22:14,330
ამიტომ კარგია ბუფერში შესანახი იგი მთელი ხაზები.

969
01:22:14,330 --> 01:22:16,810
მაგრამ მე მინდა ყოველ ხასიათის დამუშავდება

970
01:22:16,810 --> 01:22:18,810
რადგან არ მინდა ეს ლოდინი ჩემთვის მოხვდა სტრიქონების გადატანით

971
01:22:18,810 --> 01:22:21,280
სანამ ამუშავებს ყველა გმირები მე აკრეფით.

972
01:22:21,280 --> 01:22:24,760
ეს თიშავს კანონიკურ რეჟიმში.

973
01:22:24,760 --> 01:22:31,320
ამ პერსონალის უბრალოდ ნიშნავს, როდესაც ის რეალურად ანხორციელებს სიმბოლო.

974
01:22:31,320 --> 01:22:35,830
ეს ნიშნავს, გადაამუშავებს მათ მაშინვე, როგორც კი მე აკრეფით მათ, გადაამუშავებს მათ.

975
01:22:35,830 --> 01:22:42,510
და ეს არის ფუნქცია რომელიც განახლებას ჩემი პარამეტრების სტანდარტი,

976
01:22:42,510 --> 01:22:45,480
და TCSA საშუალებებით ამის გაკეთება ახლავე.

977
01:22:45,480 --> 01:22:50,310
სხვა ოფციები დაველოდოთ ყველაფერი, რაც ამჟამად ნაკადი დამუშავება.

978
01:22:50,310 --> 01:22:52,030
რომ ნამდვილად არ აქვს.

979
01:22:52,030 --> 01:22:56,920
Just ახლავე შევცვალო ჩემი პარამეტრების უნდა იყოს რაც ამჟამად hacker_typer_settings.

980
01:22:56,920 --> 01:23:02,210
ვფიქრობ მე უწოდა hacker_settings, მოდით შეცვლის.

981
01:23:09,610 --> 01:23:13,500
შეიცვალოს ყველაფერი hacker_settings.

982
01:23:13,500 --> 01:23:16,870
>> ახლა დასასრულს ჩვენი პროგრამის ჩვენ ვაპირებთ გსურთ გააუქმოთ

983
01:23:16,870 --> 01:23:20,210
თუ რა არის გაკეთებული შიგნით normal_settings,

984
01:23:20,210 --> 01:23:26,560
რომელიც აპირებს მხოლოდ ჰგავს და normal_settings.

985
01:23:26,560 --> 01:23:30,650
გაითვალისწინეთ მე არ შეცვლილა ნებისმიერი ჩემი normal_settings წლიდან თავდაპირველად მისაღებად მას.

986
01:23:30,650 --> 01:23:34,520
მაშინ უბრალოდ შეცვალოს ისინი უკან, მე გაივლის მათ უკან დასასრულს.

987
01:23:34,520 --> 01:23:38,390
ეს იყო განახლება. Okay.

988
01:23:38,390 --> 01:23:43,900
>> ახლა შიგნით აქ მე მხოლოდ ახსნას კოდი ინტერესი დრო.

989
01:23:43,900 --> 01:23:46,350
ეს არ არის, რომ ბევრი რამ კოდი.

990
01:23:50,770 --> 01:24:03,750
ჩვენ ვხედავთ, ვკითხულობთ ხასიათი ფაილი. ჩვენ მას ვ.

991
01:24:03,750 --> 01:24:07,850
ახლა თქვენ შეგიძლიათ მამაკაცის fgetc, მაგრამ როგორ fgetc იმუშავებს

992
01:24:07,850 --> 01:24:11,910
მხოლოდ ის დაბრუნებას აპირებს ხასიათი რომ უბრალოდ წაიკითხა ან EOF,

993
01:24:11,910 --> 01:24:15,680
რაც შეესაბამება ფაილის ბოლოში, ან რაიმე შეცდომა ხდება.

994
01:24:15,680 --> 01:24:19,900
ჩვენ looping აგრძელებს წაკითხვის ერთჯერადი ხასიათი ფაილი,

995
01:24:19,900 --> 01:24:22,420
სანამ ჩვენ ამოიწურა გმირები წაიკითხოს.

996
01:24:22,420 --> 01:24:26,650
და ეს მაშინ როდესაც ვაკეთებთ, რომ ველოდებით ერთ ხასიათი სტანდარტული სისტემაში

997
01:24:26,650 --> 01:24:29,090
თითოეული დროს თქვენ აკრიფოთ რაღაც ბრძანებათა ზოლს,

998
01:24:29,090 --> 01:24:32,820
რომ კითხულობს in ხასიათი სტანდარტული სისტემაში

999
01:24:32,820 --> 01:24:38,330
მაშინ putchar უბრალოდ გეგმავს char ვკითხულობთ აქ საწყისი ფაილის სტანდარტულ out.

1000
01:24:38,330 --> 01:24:42,890
მაშინ კაცი putchar, მაგრამ ეს მხოლოდ აყენებს სტანდარტულ out, ის ბეჭდვას რომ ხასიათი.

1001
01:24:42,890 --> 01:24:51,600
თქვენ შეიძლება ასევე უბრალოდ printf ("% c", გ); იგივე იდეას.

1002
01:24:53,330 --> 01:24:56,670
რომ აპირებს ნაყარი ჩვენი მუშაობის.

1003
01:24:56,670 --> 01:25:00,300
>> ბოლო რამ ჩვენ ვაპირებთ გსურთ მხოლოდ fclose ჩვენი ფაილი.

1004
01:25:00,300 --> 01:25:03,310
თუ არ fclose, რომ მეხსიერების გაჟონვის.

1005
01:25:03,310 --> 01:25:06,680
ჩვენ გვინდა fclose ფაილის ჩვენ თავდაპირველად გაიხსნა, და მე ვფიქრობ, რომ ეს არის ის.

1006
01:25:06,680 --> 01:25:13,810
თუ ჩვენ გვექნება, რომ, მე უკვე პრობლემები აქვს.

1007
01:25:13,810 --> 01:25:17,260
ვნახოთ.

1008
01:25:17,260 --> 01:25:19,960
რა ეს უჩივიან?

1009
01:25:19,960 --> 01:25:30,220
მოსალოდნელი იყო 'int', მაგრამ არგუმენტი ტიპის 'struct _IO_FILE *'.

1010
01:25:36,850 --> 01:25:39,370
ჩვენ დავინახავთ, თუ რომ მუშაობს.

1011
01:25:45,210 --> 01:25:53,540
ნებადართულია მხოლოდ c99. Augh. Okay, მიიღოს hacker_typer.

1012
01:25:53,540 --> 01:25:57,760
ახლა ჩვენ უფრო სასარგებლო აღწერილობებიდან.

1013
01:25:57,760 --> 01:25:59,900
ასე რომ გამოიყენოთ გამოუცხადებელი იდენტიფიკატორი 'normal_settings'.

1014
01:25:59,900 --> 01:26:04,170
მე არ ეძახით normal_settings. მე მას current_settings.

1015
01:26:04,170 --> 01:26:12,090
მოდით შეცვალოს ყველა რომ.

1016
01:26:17,920 --> 01:26:21,710
ახლა ავლით არგუმენტი.

1017
01:26:26,290 --> 01:26:29,500
გავაკეთებ ამ 0 ახლა.

1018
01:26:29,500 --> 01:26:36,720
Okay. . / Hacker_typer cp.c.

1019
01:26:36,720 --> 01:26:39,590
მე ასევე არ გარკვევას ეკრანზე დასაწყისში.

1020
01:26:39,590 --> 01:26:42,960
მაგრამ შეგიძლიათ ვიხსენებთ რომ ბოლო პრობლემა კომპლექტი დაინახოს, თუ როგორ გარკვევა ეკრანზე.

1021
01:26:42,960 --> 01:26:45,160
უბრალოდ ბეჭდვა ზოგიერთი გმირები

1022
01:26:45,160 --> 01:26:47,210
ხოლო ეს აკეთებს რაც მე მინდა ამის გაკეთება.

1023
01:26:47,210 --> 01:26:48,900
Okay.

1024
01:26:48,900 --> 01:26:55,280
და ფიქრი, ამიტომ ეს საჭირო იქნება 0 ნაცვლად stdin,

1025
01:26:55,280 --> 01:27:00,560
რაც უნდა განისაზღვროს # 0,

1026
01:27:00,560 --> 01:27:03,890
ეს პრეტენზიებს, რომ -

1027
01:27:13,150 --> 01:27:19,360
სანამ, როდესაც ვთქვი, რომ არსებობს ფაილური აღწერებს მაგრამ მაშინ თქვენ ასევე აქვს თქვენი ფაილი *,

1028
01:27:19,360 --> 01:27:23,210
ფაილი descriptor არის მხოლოდ ერთი რიცხვი,

1029
01:27:23,210 --> 01:27:26,970
ხოლო ი * აქვს მთელი bunch პერსონალის ასოცირდება იგი.

1030
01:27:26,970 --> 01:27:30,380
მიზეზი გვჭირდება ვთქვა 0 ნაცვლად stdin

1031
01:27:30,380 --> 01:27:37,480
არის, რომ stdin არის ფაილის * რაც მიუთითებს, რაც referencing ფაილი descriptor 0.

1032
01:27:37,480 --> 01:27:45,070
ისე კი აქ როცა გავაკეთო fopen (argv [1], მე მიღების ფაილ * უკან.

1033
01:27:45,070 --> 01:27:51,180
მაგრამ სადღაც რომ FILE * არის რამ შესაბამისი ფაილის descriptor რომ ფაილი.

1034
01:27:51,180 --> 01:27:57,430
თუ გადავხედავთ კაცი გვერდზე ღია, ასე ვფიქრობ, თქვენ უნდა გავაკეთოთ Man 3 ღია - nope -

1035
01:27:57,430 --> 01:27:59,380
კაცი 2 ღია - Yeah.

1036
01:27:59,380 --> 01:28:06,250
თუ გადავხედავთ გვერდზე ღია, ღია ჰგავს ქვედა დონის fopen,

1037
01:28:06,250 --> 01:28:09,350
და ეს დაბრუნების ფაქტობრივი ფაილი descriptor.

1038
01:28:09,350 --> 01:28:12,050
fopen აკეთებს bunch პერსონალის თავზე ღია,

1039
01:28:12,050 --> 01:28:17,640
რაც დაბრუნების ნაცვლად უბრალოდ რომ ფაილი descriptor ბრუნდება მთელი ფაილის კურსორი *

1040
01:28:17,640 --> 01:28:20,590
შიგნით რაც არის ჩვენი პატარა ფაილი descriptor.

1041
01:28:20,590 --> 01:28:25,020
ამიტომ სტანდარტის ეხება ფაილ * რამ,

1042
01:28:25,020 --> 01:28:29,120
ხოლო 0 ეხება მხოლოდ ფაილის descriptor სტანდარტული თავისთავად.

1043
01:28:29,120 --> 01:28:32,160
>> კითხვები?

1044
01:28:32,160 --> 01:28:35,930
[იცინის] ააფეთქეს მეშვეობით რომ.

1045
01:28:35,930 --> 01:28:39,140
ყველა უფლება. ჩვენ გავაკეთეთ. [იცინის]

1046
01:28:39,140 --> 01:28:42,000
>> [CS50.TV]