1
00:00:00,000 --> 00:00:02,730
[Powered by Google Translate] [ნაწილი 5: ნაკლები კომფორტული]

2
00:00:02,730 --> 00:00:05,180
[Nate Hardison, ჰარვარდის უნივერსიტეტი]

3
00:00:05,180 --> 00:00:08,260
[ეს არის CS50.] [CS50.TV]

4
00:00:08,260 --> 00:00:11,690
ასე რომ კეთილი იყოს უკან, ბიჭები.

5
00:00:11,690 --> 00:00:16,320
კეთილი იყოს განყოფილებაში 5.

6
00:00:16,320 --> 00:00:20,220
ამ ეტაპზე, რომელმაც დაასრულა ინტელექტუალური 0 და მას უნახავს, ​​როგორ გავაკეთეთ,

7
00:00:20,220 --> 00:00:25,770
იმედია გრძნობთ მართლაც კარგია, რადგან ძალიან მოეწონა ქულით ამ სექციაში.

8
00:00:25,770 --> 00:00:28,050
ჩვენი ონლაინ მაყურებელი, ჩვენ გვქონდა რამდენიმე კითხვები

9
00:00:28,050 --> 00:00:33,680
დაახლოებით ბოლო ორი პრობლემები პრობლემა კომპლექტი - ან ინტელექტუალური, საკმაოდ.

10
00:00:33,680 --> 00:00:39,690
ამიტომ, ჩვენ ვაპირებთ წასვლა იმ მართლაც სწრაფად, ისე, რომ ყველას ხედავს, თუ რა მოხდა

11
00:00:39,690 --> 00:00:45,060
და როგორ გავლა ფაქტობრივი გადაწყვეტა, ვიდრე უბრალოდ ათვალიერებენ გადაწყვეტა თავად.

12
00:00:45,060 --> 00:00:50,330
ჩვენ ვაპირებთ წასვლა უკანასკნელი რამდენიმე პრობლემები მართლაც სწრაფად, 32 და 33.

13
00:00:50,330 --> 00:00:53,240
უბრალოდ, კიდევ ერთხელ, ასე რომ ონლაინ მაყურებელი ვხედავთ ამ.

14
00:00:53,240 --> 00:00:59,080
>> თუ თქვენ ჩართოთ თქვენს პრობლემას 32, რომელიც გვერდზე 13,

15
00:00:59,080 --> 00:01:02,730
13 out of 16, პრობლემა 32 ყველაფერი არის გაცვლებს.

16
00:01:02,730 --> 00:01:05,010
ეს იყო ყველაფერი შევცვალე ორი რიცხვებით.

17
00:01:05,010 --> 00:01:08,740
ეს პრობლემა, რომ ჩვენ გვინდა წავიდა მეტი რამდენიმე ჯერ ლექცია.

18
00:01:08,740 --> 00:01:13,590
და აქ, რასაც ჩვენ ვითხოვდით თქვენ უნდა გააკეთოთ სწრაფი მეხსიერების კვალი.

19
00:01:13,590 --> 00:01:17,000
შევსება ღირებულებებს ცვლადები როგორც ისინი დასტის

20
00:01:17,000 --> 00:01:20,250
როგორც კოდი გადის ამ swap ფუნქცია.

21
00:01:20,250 --> 00:01:24,500
კერძოდ, ის, რაც ჩვენ ვეძებთ at - I'm გეგმავს ამ iPad Down -

22
00:01:24,500 --> 00:01:29,650
კერძოდ, რა ჩვენ შევხედავთ ეს ხაზი დანომრილი 6 უფლება აქ.

23
00:01:29,650 --> 00:01:36,740
და ეს დანომრილი 6 მხოლოდ contiguity, წინა პრობლემა.

24
00:01:36,740 --> 00:01:41,720
რაც გვინდა გააკეთოთ არიან ან წარწერა სახელმწიფო მეხსიერების

25
00:01:41,720 --> 00:01:46,090
როგორც ეს იმ დროს, როდესაც ჩვენ შეასრულოს ამ ხაზის ნომერი 6,

26
00:01:46,090 --> 00:01:52,540
რომელიც ეფექტურად დაბრუნების ჩვენი swap ფუნქციის უფლება აქ.

27
00:01:52,540 --> 00:01:59,450
თუ ჩვენ გადახვევა ქვემოთ აქ, დავინახეთ, რომ მისამართები ყველაფერი მეხსიერების გაეწია ჩვენთვის.

28
00:01:59,450 --> 00:02:02,540
ეს არის ძალიან გასაღები; ჩვენ დავბრუნდებით მას რაღაც მომენტში.

29
00:02:02,540 --> 00:02:09,240
და შემდეგ ქვევით აქ ბოლოში, ჩვენ გვქონდა პატარა მეხსიერება დიაგრამაზე, რომ ჩვენ ვაპირებთ ეხება.

30
00:02:09,240 --> 00:02:12,490
მე არ კეთდება ამ გარეთ ჩემი iPad.

31
00:02:12,490 --> 00:02:20,720
ამიტომ მე ვაპირებ ალტერნატიული უკან და მეოთხე შორის iPad და ამ კოდექსით მხოლოდ მითითება.

32
00:02:20,720 --> 00:02:26,540
>> დავიწყოთ. თავიდან, მოდით ფოკუსირება პირველი რამდენიმე ხაზების ძირითადი უფლება აქ.

33
00:02:26,540 --> 00:02:30,220
დასაწყებად, ჩვენ ვაპირებთ ინიციალიზაცია x to 1 და Y-დან 2.

34
00:02:30,220 --> 00:02:33,040
ასე რომ გვაქვს ორი რიცხვი ცვლადები, ისინი ორივე აპირებს განთავსდება Stack.

35
00:02:33,040 --> 00:02:36,050
ჩვენ ვაპირებთ დააყენა 1 და 2 მათში.

36
00:02:36,050 --> 00:02:43,150
ასე რომ, თუ მე Flip მეტი ჩემი iPad, იმედია, ვნახოთ -

37
00:02:43,150 --> 00:02:48,660
Apple TV რეზერვაციის, და იქ წასვლა. Okay.

38
00:02:48,660 --> 00:02:51,670
ასე რომ, თუ მე Flip მეტი ჩემი iPad,

39
00:02:51,670 --> 00:02:56,220
მინდა ინიციალიზაცია x to 1 და Y-დან 2.

40
00:02:56,220 --> 00:03:00,580
ჩვენ ამას ვაკეთებთ, რომ საკმაოდ უბრალოდ წერა 1 ყუთში აღინიშნება x

41
00:03:00,580 --> 00:03:07,730
და 2 ყუთში აღინიშნება წ. საკმაოდ მარტივია.

42
00:03:07,730 --> 00:03:11,620
ახლა მოდით დავუბრუნდეთ ლეპტოპი, ვნახოთ, რა მოხდება მომდევნო.

43
00:03:11,620 --> 00:03:15,810
ასე რომ, ეს მეორე ხაზზე, სადაც რამ კიდევ სახიფათო.

44
00:03:15,810 --> 00:03:28,110
ჩვენ გაიაროს მისამართი x და მისამართი Y როგორც პარამეტრების და ბ swap ფუნქცია.

45
00:03:28,110 --> 00:03:32,380
მისამართი x და მისამართი Y ის საკითხებია, რომლებზეც ჩვენ არ შეგვიძლია გამოვთვალოთ

46
00:03:32,380 --> 00:03:36,360
გარეშე გულისხმობდა ამ ტყვია მიუთითებს უფლება ქვემოთ აქ.

47
00:03:36,360 --> 00:03:39,750
და საბედნიეროდ, პირველი ორი ტყვია რაოდენობა გვითხრათ ზუსტად რა პასუხი.

48
00:03:39,750 --> 00:03:44,740
მისამართი x მეხსიერებაში არის 10, და მისამართი Y მეხსიერებაში არის 14.

49
00:03:44,740 --> 00:03:51,870
ასე რომ ეს ის ღირებულებები, რომ მიიღოთ წელს მიღებული როგორც და ბ up დაბრუნება ჩვენს swap ფუნქცია.

50
00:03:51,870 --> 00:04:00,760
ასე რომ კიდევ ერთხელ, კომუტაციის უკან ჩვენი სქემა, შემიძლია წერენ 10 წლის

51
00:04:00,760 --> 00:04:07,400
და 14 წლის ბ.

52
00:04:07,400 --> 00:04:11,610
ახლა, ამ ეტაპზე არის, სადაც ჩვენ გააგრძელოს swap.

53
00:04:11,610 --> 00:04:14,520
ამიტომ flipping თავში ლეპტოპი ერთხელ,

54
00:04:14,520 --> 00:04:21,079
ჩვენ ვხედავთ, რომ გზა swap მუშაობს არის მე პირველად dereference და შენახვის შედეგად tmp.

55
00:04:21,079 --> 00:04:27,650
ამიტომ dereference ოპერატორი ამბობს, "Hey. Treat შინაარსი ცვლადი როგორც მისამართზე.

56
00:04:27,650 --> 00:04:33,830
გადავიდეთ რაც ინახება, რომ მისამართი, და ჩატვირთეთ იგი. "

57
00:04:33,830 --> 00:04:41,720
რა ჩატვირთვა გარეთ ცვლადი აპირებს ინახება ჩვენს tmp ცვლადი.

58
00:04:41,720 --> 00:04:45,150
Flipping თავში iPad.

59
00:04:45,150 --> 00:04:51,690
თუ ჩვენ მივდივართ მივმართო 10, ჩვენ ვიცით, რომ მისამართი 10 არის varible x

60
00:04:51,690 --> 00:04:55,480
რადგან გვითხრეს, ჩვენი ტყვია პუნქტიანი რომ მისამართს x მეხსიერებაში არის 10.

61
00:04:55,480 --> 00:05:00,180
ასე რომ ჩვენ შეგვიძლია წავიდეთ იქ, კიდევ ღირებულების ის, რომელიც 1, როგორც ვხედავთ ჩვენს iPad,

62
00:05:00,180 --> 00:05:06,300
და ჩატვირთეთ რომ შევიდა tmp.

63
00:05:06,300 --> 00:05:08,250
ისევ და ისევ, ეს არ არის საბოლოო შინაარსს.

64
00:05:08,250 --> 00:05:14,350
ჩვენ ვაპირებთ გავლა და ჩვენ კიდევ ჩვენი საბოლოო სახელმწიფო პროგრამის დასასრულს.

65
00:05:14,350 --> 00:05:17,210
მაგრამ ახლა, ჩვენ გვაქვს ღირებულება 1 შენახული tmp.

66
00:05:17,210 --> 00:05:19,210
>> წინ კიდევ ერთი სწრაფი საკითხი აქ.

67
00:05:19,210 --> 00:05:23,980
[ალექსანდრე] არის dereference ოპერატორი - ეს მხოლოდ ვარსკვლავი თვალწინ ცვლადი?

68
00:05:23,980 --> 00:05:27,600
>> დიახ. ამიტომ dereference ოპერატორი, როგორც ჩვენ Flip უკან ჩვენი ლეპტოპი კიდევ ერთხელ,

69
00:05:27,600 --> 00:05:33,780
ეს ვარსკვლავი თვალწინ.

70
00:05:33,780 --> 00:05:37,460
ამ თვალსაზრისით, ეს არის - თქვენ განსხვავებით იგი გამრავლების ოპერატორი

71
00:05:37,460 --> 00:05:42,400
რაც მოითხოვს ორი რამ; dereference ოპერატორი unary ოპერატორს.

72
00:05:42,400 --> 00:05:46,130
Just მიმართა ერთ ღირებულება განსხვავებით ორობითი ოპერატორი,

73
00:05:46,130 --> 00:05:48,810
სადაც თქვენ ვრცელდება ორ სხვადასხვა ღირებულებებს.

74
00:05:48,810 --> 00:05:52,080
ასე რომ, რა მოხდება ამ ხაზის.

75
00:05:52,080 --> 00:05:58,390
ჩვენ დატვირთული ღირებულება 1 და ინახება იგი ჩვენი დროებითი რიცხვი ცვლადი.

76
00:05:58,390 --> 00:06:05,800
შემდეგი ხაზი, ჩვენ ვინახავთ შინაარსი ბ შევიდა -

77
00:06:05,800 --> 00:06:12,630
ან, უფრო სწორად, ჩვენ ვინახავთ შინაარსი რომ B არის მიუთითებს შევიდა იმ ადგილას, სადაც არის მიუთითებს.

78
00:06:12,630 --> 00:06:17,690
თუ გავაანალიზებთ ამ მარჯვნიდან მარცხნივ, ჩვენ ვაპირებთ dereference ბ,

79
00:06:17,690 --> 00:06:23,580
ჩვენ ვაპირებთ მივმართო 14, ჩვენ ვაპირებთ დაიბრუნოს მთელი რიცხვი, რომელიც იქ,

80
00:06:23,580 --> 00:06:26,900
და მაშინ ჩვენ ვაპირებთ წასვლა მისამართი 10,

81
00:06:26,900 --> 00:06:34,240
და ჩვენ ვაპირებთ ჩააგდოს შედეგი ჩვენი dereference of ბ შევიდა, რომ სივრცეში.

82
00:06:34,240 --> 00:06:40,080
Flipping უკან ჩვენი iPad, სადაც შეგვიძლია, რომ ეს ცოტა უფრო კონკრეტული,

83
00:06:40,080 --> 00:06:44,070
ეს შესაძლოა, დაეხმაროს თუ ვწერ ნომრები ყველა მისამართები აქ.

84
00:06:44,070 --> 00:06:53,820
ასე რომ, ჩვენ ვიცით, რომ Y, ჩვენ ვიმყოფებით მისამართი 14, x არის მისამართი 10.

85
00:06:53,820 --> 00:07:00,180
როდესაც ჩვენ იწყება B, ჩვენ dereference ბ, ჩვენ ვაპირებთ დაიბრუნოს ღირებულება 2.

86
00:07:00,180 --> 00:07:08,320
ჩვენ ვაპირებთ, რომ დაიბრუნოს ამ მნიშვნელობის რადგან ეს ღირებულება, რომელიც ცხოვრობს მისამართი 14.

87
00:07:08,320 --> 00:07:15,700
და ჩვენ ვაპირებთ დააყენა იგი ცვლადი რომ ცხოვრობს მისამართი 10,

88
00:07:15,700 --> 00:07:19,160
რაც უფლება არსებობს, შესაბამისი ჩვენი ცვლადი x.

89
00:07:19,160 --> 00:07:21,810
ასე რომ ჩვენ შეგვიძლია გავაკეთოთ ცოტა overwriting აქ

90
00:07:21,810 --> 00:07:35,380
სადაც ჩვენ დავაღწიოთ ჩვენი 1 და ნაცვლად ჩვენ წერენ 2.

91
00:07:35,380 --> 00:07:39,560
ასე რომ ყველა არის კარგად და კარგი მსოფლიოში, მიუხედავად იმისა, რომ ჩვენ ინსტალერის x ახლა.

92
00:07:39,560 --> 00:07:44,890
ჩვენ შენახული x ძველი ღირებულება ჩვენს tmp ცვლადი.

93
00:07:44,890 --> 00:07:50,210
ასე რომ ჩვენ შეგვიძლია დავასრულოთ swap მომდევნო ხაზი.

94
00:07:50,210 --> 00:07:53,030
Flipping უკან ჩვენი ლეპტოპი.

95
00:07:53,030 --> 00:07:58,150
ახლა ყველა რომ რჩება მიიღოს შინაარსი ჩვენი დროებითი რიცხვი ცვლადი

96
00:07:58,150 --> 00:08:05,630
და ვინახავთ მათ ცვლადი რომ ცხოვრობს, მისამართზე, რომ ბ მართავს.

97
00:08:05,630 --> 00:08:10,230
ამიტომ, ჩვენ ვაპირებთ ეფექტურად dereference ბ მისაღებად ხელმისაწვდომობის ცვლადი

98
00:08:10,230 --> 00:08:14,340
რომ არის, მისამართზე, რომ ბ ფლობს მას,

99
00:08:14,340 --> 00:08:19,190
და ჩვენ ვაპირებთ პერსონალის ღირებულება რომ tmp მართავს მივანიჭო.

100
00:08:19,190 --> 00:08:23,280
Flipping თავში iPad კიდევ ერთხელ.

101
00:08:23,280 --> 00:08:31,290
შემიძლია წაშლას მნიშვნელობა აქ, 2,

102
00:08:31,290 --> 00:08:41,010
და ნაცვლად ჩვენ კოპირება უფლება 1 მივანიჭო.

103
00:08:41,010 --> 00:08:43,059
მაშინ მეორე ხაზზე, რომ ახორციელებს, რა თქმა უნდა -

104
00:08:43,059 --> 00:08:47,150
თუ ჩვენ Flip თავში ლეპტოპი - არის ამ ეტაპზე 6,

105
00:08:47,150 --> 00:08:52,500
რაც წერტილი სადაც გვინდოდა გვაქვს ჩვენი სქემა მთლიანად შევსებული.

106
00:08:52,500 --> 00:08:58,940
ამიტომ flipping თავში iPad კიდევ ერთხელ, უბრალოდ, ასე რომ თქვენ შეგიძლიათ ნახოთ შევსებული სქემა,

107
00:08:58,940 --> 00:09:06,610
თქვენ ხედავთ, რომ ჩვენ გვყავს 10 წელს, 14 წელს ბ, 1 წლის tmp, 2, x, და 1 წლის წ.

108
00:09:06,610 --> 00:09:11,000
არსებობს რაიმე კითხვები შესახებ?

109
00:09:11,000 --> 00:09:14,640
ამჯამად ამ უფრო გრძნობა, რომელმაც ფეხით ისეირნა ეს?

110
00:09:14,640 --> 00:09:24,850
ჩადება ნაკლები გრძნობა? იმედია არ. Okay.

111
00:09:24,850 --> 00:09:28,230
>> მითითებები ძალიან სახიფათო სათაური.

112
00:09:28,230 --> 00:09:33,420
ერთი ბიჭები ვმუშაობთ აქვს ძალიან ხშირი განაცხადა:

113
00:09:33,420 --> 00:09:36,590
"ამის გასაგებად გჭირდებათ, თქვენ უნდა გვესმოდეს, პირველი პოინტერები".

114
00:09:36,590 --> 00:09:40,530
რაც, ჩემი აზრით არის ძალიან ნამდვილი. ეს არ მიიღოს ხოლო მისაღებად გამოიყენება იგი.

115
00:09:40,530 --> 00:09:45,360
ვხატავთ უამრავი სურათები, გრაფიკა უამრავი მეხსიერების დიაგრამების მსგავსი ძალიან გამოსადეგი,

116
00:09:45,360 --> 00:09:49,480
და შემდეგ თქვენ გავლა მაგალითად შემდეგ მაგალითი შემდეგ მაგალითად,

117
00:09:49,480 --> 00:09:54,450
ეს დავიწყებთ, რათა ცოტა მეტი აზრი და ცოტა მეტი გრძნობა და ცოტა მეტი გაგებით.

118
00:09:54,450 --> 00:10:01,560
და ბოლოს, ერთ დღეს, თქვენ ეს ყველაფერი მთლიანად აითვისა.

119
00:10:01,560 --> 00:10:13,800
ნებისმიერი კითხვები სანამ ჩვენ გადასვლა მომდევნო პრობლემა? ყველა უფლება.

120
00:10:13,800 --> 00:10:18,840
ამიტომ Flip თავში ლეპტოპი.

121
00:10:18,840 --> 00:10:23,300
შემდეგი პრობლემა გვაქვს არის პრობლემა ნომერი 33 წლის ფაილის I / O.

122
00:10:23,300 --> 00:10:26,350
მიუახლოვდით ამ ცოტა.

123
00:10:26,350 --> 00:10:28,710
პრობლემა 33 - დიახ?

124
00:10:28,710 --> 00:10:32,110
>> [დანიელ] მე უბრალოდ ჰქონდა სწრაფი კითხვა. ეს ვარსკვლავი, ან ვარსკვლავი,

125
00:10:32,110 --> 00:10:35,590
ეს მოუწოდა dereferencing როდესაც თქვენ იყენებთ ვარსკვლავი წინაშე.

126
00:10:35,590 --> 00:10:38,820
რა არის ერთ როდესაც თქვენ იყენებთ ampersand წინაშე?

127
00:10:38,820 --> 00:10:43,140
>> Ampersand ადრე არის მისამართზე-ოპერატორის.

128
00:10:43,140 --> 00:10:45,880
მოდით გადახვევა უკან მდე.

129
00:10:45,880 --> 00:10:49,310
Oops. მე Zoom რეჟიმში მე ვერ გადახვევა.

130
00:10:49,310 --> 00:10:52,780
თუ დავაკვირდებით ამ კოდექსით მართლაც სწრაფად სწორედ აქ,

131
00:10:52,780 --> 00:10:54,980
ერთხელ, იგივე ხდება.

132
00:10:54,980 --> 00:10:59,180
თუ დავაკვირდებით ამ კოდექსით უფლება აქ, ამ ხაზის სადაც ჩვენ მიიღოს ზარი სვოპ,

133
00:10:59,180 --> 00:11:10,460
ampersand უბრალოდ რომ "კიდევ მისამართი სადაც ცვლადი x ცხოვრებაში."

134
00:11:10,460 --> 00:11:14,460
როდესაც თქვენი შემდგენელი ადგენს თქვენი კოდი,

135
00:11:14,460 --> 00:11:20,590
მას რეალურად ფიზიკურად გამოვყოფდით ადგილი მეხსიერებაში ყველა თქვენი ცვლადები ცხოვრება.

136
00:11:20,590 --> 00:11:24,910
და მერე რა შემდგენელი შეგიძლიათ მაშინ ნუ ერთხელ ის შედგენილი ყველაფერი,

137
00:11:24,910 --> 00:11:31,110
იგი დარწმუნებულია, "ოჰ, მე ზუსტად x საათზე მისამართი 10. მე Y ზე მისამართი 14."

138
00:11:31,110 --> 00:11:34,640
მას შეუძლია შემდეგ შეავსონ ამ ღირებულებების თქვენთვის.

139
00:11:34,640 --> 00:11:44,740
ასე, რომ თქვენ შეგიძლიათ შემდეგ - ეს შეიძლება მაშინ გაივლის ამ წელს და უღელტეხილზე & y in ისევე.

140
00:11:44,740 --> 00:11:50,730
ეს ბიჭები კიდევ მისამართი, არამედ, როცა გაივლის მათ swap ფუნქციის,

141
00:11:50,730 --> 00:11:55,690
ამ ტიპის ინფორმაციას, ამ int * უფლება აქ, ეუბნება შემდგენელი,

142
00:11:55,690 --> 00:12:01,350
"Okay, ჩვენ ვაპირებთ იყოს წერით ამ მისამართზე, როგორც მისამართი რიცხვი ცვლადი."

143
00:12:01,350 --> 00:12:05,900
როგორც მისამართი int, რომელიც განსხვავდება მისამართი ხასიათი ცვლადი

144
00:12:05,900 --> 00:12:09,930
რადგან int იკავებს, on 32-bit მანქანა, იკავებს 4 ბაიტს სივრცეში,

145
00:12:09,930 --> 00:12:13,310
ხოლო ხასიათი მხოლოდ იღებს up 1 byte სივრცეში.

146
00:12:13,310 --> 00:12:17,310
ამიტომ მნიშვნელოვანია ვიცოდეთ, თუ რა არის - რა ცხოვრება, რა ტიპის ღირებულება

147
00:12:17,310 --> 00:12:20,340
მცხოვრები მისამართზე, რომელიც კონკრეტულად გაიარა სისტემაში

148
00:12:20,340 --> 00:12:22,020
ან მისამართი, რომ თქვენ საქმე.

149
00:12:22,020 --> 00:12:29,020
ამ გზით, თქვენ იცით, რამდენი ბაიტი ინფორმაციის რეალურად ჩატვირთვა out თქვენი RAM.

150
00:12:29,020 --> 00:12:31,780
და მაშინ, დიახ, ეს dereference ოპერატორი, თქვენნაირი ითხოვდნენ,

151
00:12:31,780 --> 00:12:37,200
მიდის და ხელმისაწვდომი ინფორმაციის კონკრეტულ მისამართზე.

152
00:12:37,200 --> 00:12:42,820
ასე რომ ამბობს, ამ ცვლადის აქ, მკურნალობა შინაარსი როგორც მისამართი,

153
00:12:42,820 --> 00:12:47,880
წასვლა, რომ მისამართი, და გაიყვანოს, ჩატვირთვა შევიდა პროცესორი, დატვირთვის შევიდა რეგისტრაცია

154
00:12:47,880 --> 00:12:56,340
ფაქტობრივი ღირებულებების ან შინაარსი, რომ ცხოვრობენ, რომ მისამართზე.

155
00:12:56,340 --> 00:12:59,620
ნებისმიერი უფრო მეტი შეკითხვა? ეს არის კარგი შეკითხვა.

156
00:12:59,620 --> 00:13:01,650
ეს ბევრი ახალი ტერმინოლოგია ძალიან.

157
00:13:01,650 --> 00:13:09,800
ასევე სახის ხმაურიანი, ხედავს და და * სხვადასხვა ადგილებში.

158
00:13:09,800 --> 00:13:13,180
>> ყველა უფლება.

159
00:13:13,180 --> 00:13:18,530
ასე რომ თავში პრობლემა 33, ფაილის I / O.

160
00:13:18,530 --> 00:13:22,540
ეს იყო ერთი იმ პრობლემებს, რომელიც ვფიქრობ, რამდენიმე რამ მოხდა.

161
00:13:22,540 --> 00:13:25,400
ერთი, ეს საკმაოდ ახალი თემის.

162
00:13:25,400 --> 00:13:30,590
ის არის წარმოდგენილი საკმაოდ მალე სანამ ვიქტორინა,

163
00:13:30,590 --> 00:13:33,400
და მაშინ მე ვფიქრობ, რომ ეს იყო ერთგვარი მოსწონს ერთი იმ სიტყვას პრობლემები მათემატიკის

164
00:13:33,400 --> 00:13:39,720
სადაც ისინი მოგცემთ უამრავ ინფორმაციას, მაგრამ თქვენ ნამდვილად არ დასრულდება მდე მქონე გამოიყენოს ტონა იგი.

165
00:13:39,720 --> 00:13:44,060
პირველი ნაწილი ამ პრობლემას აღწერს რა CSV ფაილი.

166
00:13:44,060 --> 00:13:50,620
ახლა, CSV ფაილი თანახმად, აღწერა, არის მძიმით-გამოყოფილი მნიშვნელობები ფაილის.

167
00:13:50,620 --> 00:13:55,300
მიზეზი ეს არის ყველა საინტერესო იყო და მიზეზი ოდესმე მათი გამოყენება,

168
00:13:55,300 --> 00:14:00,800
არის, რადგან, რამდენი თქვენ ოდესმე გამოიყენება პერსონალის მოსწონს Excel?

169
00:14:00,800 --> 00:14:03,240
ფიგურა ყველაზე მეტად თქვენ არ, ალბათ, ან გამოიყენებს რაღაც მომენტში თქვენს ცხოვრებაში.

170
00:14:03,240 --> 00:14:06,430
თქვენ გამოიყენებთ რაღაც Excel.

171
00:14:06,430 --> 00:14:10,940
იმისათვის, რომ მიიღოთ მონაცემები გარეთ Excel-ის რაიმე სახის დამუშავება მასთან,

172
00:14:10,940 --> 00:14:17,240
თუ უნდოდა დაწერა C პროგრამის ან პითონი პროგრამა, Java პროგრამა,

173
00:14:17,240 --> 00:14:20,070
გამკლავება მონაცემები თქვენ არ ინახება იქ,

174
00:14:20,070 --> 00:14:23,170
ერთი ყველაზე გავრცელებული გზა მისაღებად მას out არის CSV ფაილი.

175
00:14:23,170 --> 00:14:26,850
და შეგიძლიათ გახსენით Excel და როდესაც მიდიხარ 'შეინახე როგორც "დიალოგის,

176
00:14:26,850 --> 00:14:32,840
შეგიძლიათ გავიდნენ ფაქტობრივი CSV ფაილი.

177
00:14:32,840 --> 00:14:35,890
>> Handy იცოდეს როგორ გაუმკლავდეს ეს ყველაფერი.

178
00:14:35,890 --> 00:14:42,010
გზა მუშაობს ის არის, რომ ეს მსგავსი - ვგულისხმობ, ის არსებითად mimicking ცხრილების,

179
00:14:42,010 --> 00:14:47,590
სადაც, როგორც ვხედავთ აქ, ძალიან დაუტოვებიათ-საუკეთესო პიესა,

180
00:14:47,590 --> 00:14:49,910
ჩვენ გვაქვს ყველა გვარი.

181
00:14:49,910 --> 00:14:54,670
ამიტომ Malan, მაშინ Hardison და შემდეგ Bowden, MacWilliam და შემდეგ Chan.

182
00:14:54,670 --> 00:14:59,470
ყველა გვარი. და შემდეგ მძიმით ჰყოფს გვარი პირველი სახელები.

183
00:14:59,470 --> 00:15:02,970
დავით, Nate, რობ, ტომი, და Zamyla.

184
00:15:02,970 --> 00:15:06,850
მე ყოველთვის აღრევას Robby და ტომ.

185
00:15:06,850 --> 00:15:10,940
და მაშინ, საბოლოოდ, მესამე სვეტის არის მისამართს.

186
00:15:10,940 --> 00:15:18,500
ერთხელ თქვენ გვესმის, რომ, დანარჩენი პროგრამა საკმაოდ მარტივია განახორციელოს.

187
00:15:18,500 --> 00:15:23,850
რაც ჩვენ გავაკეთეთ იმისათვის, რომ mimic ეს იგივე სტრუქტურა ჩვენს C პროგრამის

188
00:15:23,850 --> 00:15:27,510
არის ჩვენ გამოყენებული სტრუქტურა.

189
00:15:27,510 --> 00:15:30,520
ჩვენ დავიწყებთ თამაშს ამ ცოტა მეტი ასევე.

190
00:15:30,520 --> 00:15:35,790
ჩვენ ვნახეთ მათ პირველად ცოტა პრობლემების კომპლექტი 3, როდესაც საქმე გვქონდა ლექსიკონები.

191
00:15:35,790 --> 00:15:40,290
მაგრამ ეს პერსონალის struct ინახავს გვარი, სახელი და ელ.

192
00:15:40,290 --> 00:15:44,500
ისევე, როგორც ჩვენი CSV ფაილი შენახვას.

193
00:15:44,500 --> 00:15:47,950
ასე რომ, ეს უბრალოდ კონვერტირებას ერთი ფორმატი სხვა.

194
00:15:47,950 --> 00:15:54,630
ჩვენ უნდა გარდაქმნას, ამ შემთხვევაში, პერსონალი struct შევიდა ხაზი,

195
00:15:54,630 --> 00:15:59,060
მძიმით გამოყოფილი-ხაზი, ისევე, როგორც, რომ.

196
00:15:59,060 --> 00:16:01,500
ამჯამად რომ აზრი? თქვენ ბიჭები არ ყველა მიღებული ვიქტორინა,

197
00:16:01,500 --> 00:16:07,680
ამიტომ წარმოიდგინეთ თქვენ მინიმუმ ჰქონდა გარკვეული დრო ვიფიქროთ ამ.

198
00:16:07,680 --> 00:16:16,410
>> In დაქირავება ფუნქცია, პრობლემა გვთხოვს მიიღოს in - we'll მიუახლოვდით ამ ცოტა -

199
00:16:16,410 --> 00:16:22,480
მიიღოს თანამშრომლები სტრუქტურა, პერსონალი struct, სახელწოდებით s,

200
00:16:22,480 --> 00:16:30,900
და დამატება მისი შინაარსი ჩვენს staff.csv ფაილი.

201
00:16:30,900 --> 00:16:34,230
თურმე ეს საკმაოდ მარტივია გამოიყენოს.

202
00:16:34,230 --> 00:16:37,430
ჩვენ სახის თამაშობენ გარშემო ამ ფუნქციების ცოტა მეტი დღეს.

203
00:16:37,430 --> 00:16:44,510
მაგრამ ამ შემთხვევაში, fprintf ფუნქცია მართლაც გასაღები.

204
00:16:44,510 --> 00:16:51,960
ამრიგად fprintf, ჩვენ შეგვიძლია ბეჭდვა, ისევე, როგორც თქვენ ბიჭები არ იყენებს printf ამ მთელი ვადით.

205
00:16:51,960 --> 00:16:55,050
შეგიძლია printf ხაზი ფაილი.

206
00:16:55,050 --> 00:16:59,030
ასე რომ ნაცვლად მხოლოდ მიღების ჩვეულ printf ზარის სადაც თქვენ მისცეს მას სტრიქონში

207
00:16:59,030 --> 00:17:05,380
და მაშინ შეცვლის ყველა ცვლადები შემდეგი არგუმენტები,

208
00:17:05,380 --> 00:17:11,290
ერთად fprintf, თქვენი პირველივე არგუმენტი ნაცვლად ფაილი გსურთ ჩაწერა.

209
00:17:11,290 --> 00:17:21,170
თუ ჩვენ უნდა შევხედოთ ამ მოწყობილობის, მაგალითად, ადამიანი fprintf,

210
00:17:21,170 --> 00:17:25,980
ვხედავთ განსხვავება printf და fprintf.

211
00:17:25,980 --> 00:17:28,960
მე მიუახლოვდით აქ ცოტა.

212
00:17:28,960 --> 00:17:33,140
ამრიგად printf, ვაძლევთ მას სტრიქონში, ხოლო შემდეგ მომდევნო არგუმენტები

213
00:17:33,140 --> 00:17:37,580
ყველა ცვლადები ჩანაცვლებაზე ან ჩანაცვლებითი ჩვენს სტრიქონში.

214
00:17:37,580 --> 00:17:47,310
ვინაიდან ერთად fprintf, პირველი არგუმენტი მართლაც ამ ფაილის * მოუწოდა ნაკადი.

215
00:17:47,310 --> 00:17:51,800
>> Moving უკან მეტი აქ ჩვენი დაქირავება,

216
00:17:51,800 --> 00:17:54,550
ჩვენ უკვე ჩვენი ფაილი * ნაკადი გაიხსნა ჩვენთვის.

217
00:17:54,550 --> 00:17:57,810
სწორედ ამ პირველი ხაზი არ; იხსნება staff.csv ფაილი,

218
00:17:57,810 --> 00:18:01,690
იხსნება ის დამატება რეჟიმში, და ყველა რომ დაუტოვებიათ ჩვენთვის გააკეთოთ

219
00:18:01,690 --> 00:18:08,640
წერენ თანამშრომლები სტრუქტურა, რათა ფაილი.

220
00:18:08,640 --> 00:18:10,870
და, ვნახოთ, ნუ მინდა iPad?

221
00:18:10,870 --> 00:18:17,900
მე გამოიყენოთ iPad. ჩვენ გვყავს ბათილად - მოდით დააყენა ამ მაგიდაზე ისე შეგიძლიათ დაწეროთ ცოტა უკეთესი -

222
00:18:17,900 --> 00:18:33,680
ბათილად დაქირავება და სჭირდება ერთ არგუმენტად, თანამშრომლები სტრუქტურა მოუწოდა s.

223
00:18:33,680 --> 00:18:44,120
Got ჩვენი braces, გვაქვს ჩვენი ფაილი * მოუწოდა ფაილი,

224
00:18:44,120 --> 00:18:48,380
ჩვენ გვაქვს ჩვენი fopen ხაზის მოცემული ჩვენთვის,

225
00:18:48,380 --> 00:18:51,890
და მე უბრალოდ წერენ, როგორც წერტილების რადგან უკვე pedia.

226
00:18:51,890 --> 00:19:00,530
და მერე ჩვენი მომავალი ხაზი, ჩვენ ვაპირებთ ზარი fprintf

227
00:19:00,530 --> 00:19:03,700
და ჩვენ ვაპირებთ კორიდორი ფაილი რომ ჩვენ გვინდა ბეჭდვა,

228
00:19:03,700 --> 00:19:10,290
და მაშინ ჩვენი სტრიქონში, რომელიც -

229
00:19:10,290 --> 00:19:14,300
მე მოგცემთ ბიჭებს მითხრათ რა გამოიყურება.

230
00:19:14,300 --> 00:19:20,500
როგორ შესახებ თქვენ, Stella? იცით, რა პირველი ნაწილი სტრიქონში ჰგავს?

231
00:19:20,500 --> 00:19:24,270
[Stella] არ ვარ დარწმუნებული. >> შეგიძლიათ ვთხოვო ჯიმი.

232
00:19:24,270 --> 00:19:27,690
იცით, ჯიმი?

233
00:19:27,690 --> 00:19:31,000
[Jimmy] უნდა იყოს მხოლოდ ბოლო? მე არ ვიცი. მე არ ვარ დარწმუნებული მთლიანად.

234
00:19:31,000 --> 00:19:39,020
>> Okay. როგორ შესახებ, საერთოდ ვინმე ამ სწორი on გამოცდა?

235
00:19:39,020 --> 00:19:41,770
პოსტები ყველა უფლება.

236
00:19:41,770 --> 00:19:47,920
თურმე აქ ყველა ჩვენ უნდა გავაკეთოთ არის გვინდა თითოეული ნაწილი ჩვენი თანამშრომლები სტრუქტურა

237
00:19:47,920 --> 00:19:53,290
უნდა დაიბეჭდოს, როგორც სიმებიანი ჩვენს ფაილი.

238
00:19:53,290 --> 00:19:59,900
ჩვენ მხოლოდ გამოიყენოთ სიმებიანი ჩანაცვლებითი ხასიათი სამი სხვადასხვა დროს, რადგან ჩვენ გვაქვს გვარი

239
00:19:59,900 --> 00:20:07,160
მოჰყვა მძიმით, მაშინ სახელი მოჰყვა მძიმე,

240
00:20:07,160 --> 00:20:12,430
და მაშინ საბოლოოდ Email მისამართი, რომელიც მოსდევს - რომელიც არ არის

241
00:20:12,430 --> 00:20:15,140
fitting ჩემს ეკრანზე - მაგრამ ეს მოჰყვა სტრიქონების გადატანით ხასიათი.

242
00:20:15,140 --> 00:20:20,060
ამიტომ მე ვაპირებ წერენ უბრალოდ დახვდა.

243
00:20:20,060 --> 00:20:23,560
და შემდეგ შემდეგ ჩვენი სტრიქონში,

244
00:20:23,560 --> 00:20:27,880
ჩვენ უბრალოდ უნდა substitutions, რომელიც ჩვენ შედიხართ გამოყენებით dot ნოტაცია

245
00:20:27,880 --> 00:20:31,370
რომ ვნახეთ პრობლემა კომპლექტი 3.

246
00:20:31,370 --> 00:20:48,820
ჩვენ შეგვიძლია გამოვიყენოთ s.last, s.first და s.email

247
00:20:48,820 --> 00:20:58,990
შემცვლელად იმ სამი ღირებულებებს ჩვენს სტრიქონში.

248
00:20:58,990 --> 00:21:06,190
ასე რომ, როგორ, რომ წავიდეთ? აზრი?

249
00:21:06,190 --> 00:21:09,700
დიახ? არარის? შესაძლოა? Okay.

250
00:21:09,700 --> 00:21:14,180
>> საბოლოო რამ, რასაც ჩვენ ვაკეთებთ შემდეგ ჩვენ დაბეჭდილი და შემდეგ ჩვენ გახსნა ჩვენი ფაილი:

251
00:21:14,180 --> 00:21:17,370
როდესაც ჩვენ გახსნა ფაილი, ჩვენ ყოველთვის უნდა გვახსოვდეს, დახუროს იგი.

252
00:21:17,370 --> 00:21:19,430
რადგან, წინააღმდეგ შემთხვევაში ჩვენ დასრულდება მდე ჩამოდის მეხსიერება,

253
00:21:19,430 --> 00:21:22,500
გამოყენებით up ფაილი აღწერებს.

254
00:21:22,500 --> 00:21:25,950
ასე რომ დახუროს ეს, რომელიც ფუნქციას ვიყენებთ? დანიელ?

255
00:21:25,950 --> 00:21:30,120
[დანიელ] fclose? >> Fclose, ზუსტად.

256
00:21:30,120 --> 00:21:37,520
ასე რომ ბოლო ნაწილი ამ პრობლემას იყო სათანადოდ დახურვა ფაილი, გამოყენებით fclose ფუნქცია,

257
00:21:37,520 --> 00:21:40,370
რომელიც უბრალოდ ჰგავს, რომ.

258
00:21:40,370 --> 00:21:43,880
არც ისე გიჟები.

259
00:21:43,880 --> 00:21:46,990
ზემოთ.

260
00:21:46,990 --> 00:21:49,520
ასე რომ პრობლემა 33 წლის ვიქტორინა.

261
00:21:49,520 --> 00:21:52,480
გვექნება აუცილებლად მეტი ფაილის I / O ახლოვდება.

262
00:21:52,480 --> 00:21:55,130
ჩვენ ყველაფერს გავაკეთებთ ცოტა მეტი ლექცია დღეს, ან ნაწილში დღეს,

263
00:21:55,130 --> 00:22:01,710
იმიტომ, რომ ის, რაც ხდება შექმნას ნაყარი ამ დაგეგმილ pset.

264
00:22:01,710 --> 00:22:05,020
მოდით გადაადგილება საწყისი Quiz ამ ეტაპზე. დიახ?

265
00:22:05,020 --> 00:22:10,880
>> [Charlotte]] რატომ fclose (ფაილი) ნაცვლად fclose (staff.csv)?

266
00:22:10,880 --> 00:22:19,100
>> Ah. რადგან გამოდის, რომ - ასე კითხვა, რომელიც დიდი ერთი,

267
00:22:19,100 --> 00:22:27,800
ამიტომ, როდესაც ჩვენ წერენ fclose, ჩვენ წერილობით fclose (ფაილი) ვარსკვლავი ცვლადი

268
00:22:27,800 --> 00:22:33,680
როგორც ეწინააღმდეგებოდა ფაილის სახელი, staff.csv? არის ის, რომ სწორი? Yeah.

269
00:22:33,680 --> 00:22:39,570
მოდით შევხედოთ. თუ მე გადართოთ თავში ჩემი ლეპტოპი,

270
00:22:39,570 --> 00:22:45,040
და მოდით შევხედოთ fclose ფუნქცია.

271
00:22:45,040 --> 00:22:51,460
ამიტომ fclose ფუნქცია ხურავს ნაკადი და სჭირდება წელს მომცეთ ნაკადი, რომ ჩვენ გვინდა დახურვა,

272
00:22:51,460 --> 00:22:57,010
როგორც ეწინააღმდეგებოდა ფაქტობრივი ფაილის სახელი რომ ჩვენ გვინდა დახურვა.

273
00:22:57,010 --> 00:23:01,620
და ეს იმიტომ კულისებში, როდესაც თქვენ გააკეთებთ ზარი fopen,

274
00:23:01,620 --> 00:23:12,020
როდესაც თქვენ გახსენით ფაილი, თქვენ რეალურად გამოყოფის მეხსიერება ინფორმაციის შესანახად ფაილის.

275
00:23:12,020 --> 00:23:16,380
ასე რომ თქვენ არ ფაილის მაჩვენებელი, გააჩნია ინფორმაციას ფაილის,

276
00:23:16,380 --> 00:23:23,080
როგორიცაა ის ღია, მისი ზომა, სადაც თქვენ ამჟამად ფაილის,

277
00:23:23,080 --> 00:23:29,100
ასე რომ თქვენ შეუძლია კითხვა და წერა ზარები, რომ განსაკუთრებული ადგილი ფარგლებში ფაილი.

278
00:23:29,100 --> 00:23:38,060
თქვენ დასრულდება up დახურვის კურსორის ნაცვლად დახურვის ფაილის სახელი.

279
00:23:38,060 --> 00:23:48,990
>> დიახ? [დანიელ] ასე რათა დაქირავება, იტყვით - როგორ მიიღოთ მომხმარებლის შეყვანის?

280
00:23:48,990 --> 00:23:53,830
ამჯამად fprintf ვმოქმედებთ GetString იმ გაგებით, რომ იგი ყველაფერს უბრალოდ დაველოდოთ მომხმარებლის შეყვანის

281
00:23:53,830 --> 00:23:57,180
და გთხოვთ აკრიფოთ ამ - ან დაველოდოთ თქვენ აკრიფოთ ეს სამი რამ?

282
00:23:57,180 --> 00:24:00,480
ან თქვენ უნდა გამოვიყენოთ რაღაც განახორციელოს დაქირავება?

283
00:24:00,480 --> 00:24:04,100
>> Yeah. ასე რომ ჩვენ არა ვართ - კითხვა, როგორ უნდა მიიღოს მომხმარებლის შეყვანის

284
00:24:04,100 --> 00:24:09,220
განსახორციელებლად დაქირავება? და რა გვაქვს აქ Caller of დაქირავება,

285
00:24:09,220 --> 00:24:17,690
გაიარა ამ პერსონალის struct ყველა მონაცემები ინახება struct უკვე.

286
00:24:17,690 --> 00:24:22,990
ამიტომ fprintf შეუძლია მხოლოდ წერენ, რომ მონაცემები პირდაპირ ფაილი.

287
00:24:22,990 --> 00:24:25,690
იქ არ არის ველოდები მომხმარებლის შეყვანის.

288
00:24:25,690 --> 00:24:32,110
მომხმარებლის უკვე მისცა შეყვანის მიერ სათანადოდ აყენებს მას ამ პერსონალის struct.

289
00:24:32,110 --> 00:24:36,510
და რამ, რა თქმა უნდა, რომ შესვენება, თუ ნებისმიერი იმ პოინტერები იყვნენ null,

290
00:24:36,510 --> 00:24:40,370
ამიტომ ჩვენ გადახვევა უკან აქ და შევხედავთ ჩვენი struct.

291
00:24:40,370 --> 00:24:43,640
ჩვენ გვყავს სიმებიანი ბოლო, string პირველი, string ელ.

292
00:24:43,640 --> 00:24:48,530
ახლა ჩვენ ვიცით, რომ ყველა იმ მართლაც, ქვეშ Hood, არის char * ცვლადები.

293
00:24:48,530 --> 00:24:53,470
რომლებიც შეიძლება იყოს ან არ იყოს მიუთითებს null.

294
00:24:53,470 --> 00:24:55,800
ისინი შეიძლება მიუთითებს მეხსიერების შესახებ ბევრი,

295
00:24:55,800 --> 00:24:59,650
იქნებ მეხსიერების on Stack.

296
00:24:59,650 --> 00:25:04,580
ჩვენ ნამდვილად არ ვიცით, მაგრამ თუ რომელიმე ამ მითითებები null, ან არასწორი,

297
00:25:04,580 --> 00:25:08,120
რომ ნამდვილად ავარიული ჩვენი დაქირავება ფუნქცია.

298
00:25:08,120 --> 00:25:11,050
ეს იყო ის, რაც იყო ერთგვარი სცილდება გამოცდა.

299
00:25:11,050 --> 00:25:16,440
ჩვენ არ შემაშფოთებელია შესახებ, რომ.

300
00:25:16,440 --> 00:25:22,170
დიდი. Okay. ასე რომ მოძრავი საწყისი ვიქტორინა.

301
00:25:22,170 --> 00:25:25,760
>> მოდით დახურვა ბიჭი, და ჩვენ ვაპირებთ შევხედოთ pset 4.

302
00:25:25,760 --> 00:25:34,700
ასე რომ, თუ თქვენ ბიჭები შევხედოთ pset Spec, ერთხელ შეგიძლიათ ვებგვერდზე, cs50.net/quizzes,

303
00:25:34,700 --> 00:25:42,730
ჩვენ ვაპირებთ გავლა რამდენიმე მონაკვეთზე პრობლემებზე დღეს.

304
00:25:42,730 --> 00:25:52,240
მე სენსორული Down - მონაკვეთზე კითხვები იწყება მესამე გვერდზე pset სპეც.

305
00:25:52,240 --> 00:25:57,800
და პირველი ნაწილი მოგთხოვთ წავიდეთ და უყუროთ მოკლე on გადამისამართება და მილები.

306
00:25:57,800 --> 00:26:02,820
რომელიც სახის Cool შემოკლებული, გიჩვენებთ რამდენიმე ახალი, გრილ command line tricks რომ თქვენ შეგიძლიათ გამოიყენოთ.

307
00:26:02,820 --> 00:26:06,050
და შემდეგ ჩვენ მივიღეთ რამდენიმე კითხვები თქვენთვის ისევე.

308
00:26:06,050 --> 00:26:10,860
ეს პირველი შეკითხვა ნაკადს, რომლის printf წერს ჩვეულებრივ,

309
00:26:10,860 --> 00:26:15,920
ჩვენ სახის შეეხო მხოლოდ ცოტა მომენტში წინ.

310
00:26:15,920 --> 00:26:22,380
ეს fprintf, რომ ჩვენ უბრალოდ მსჯელობენ იღებს in file * ნაკადი როგორც თავისი არგუმენტი.

311
00:26:22,380 --> 00:26:26,580
fclose იღებს in file * ნაკადი ისევე,

312
00:26:26,580 --> 00:26:32,660
და დაბრუნების ღირებულება fopen გაძლევთ ფაილის * ნაკადი ისევე.

313
00:26:32,660 --> 00:26:36,060
მიზეზი ჩვენ არ მინახავს იმ ადრე, როდესაც ჩვენ შეეხო printf

314
00:26:36,060 --> 00:26:39,450
ეს იმიტომ printf აქვს რა ნაკადი.

315
00:26:39,450 --> 00:26:41,810
და რა ნაკადი რომელსაც იგი წერს

316
00:26:41,810 --> 00:26:45,190
თქვენ გაეცნოთ მოკლე.

317
00:26:45,190 --> 00:26:50,080
ასე რომ აუცილებლად შევხედოთ მას.

318
00:26:50,080 --> 00:26:53,010
>> დღევანდელ მონაკვეთზე, ჩვენ ვაპირებთ გაიგო ცოტა შესახებ GDB,

319
00:26:53,010 --> 00:26:57,720
მას შემდეგ, რაც მეტი ნაცნობი თქვენ მას, მეტი პრაქტიკა თქვენ მასთან ერთად

320
00:26:57,720 --> 00:27:01,390
უკეთესი შეუძლია თქვენ რეალურად ნადირობის down შეცდომებს თქვენი საკუთარი კოდი.

321
00:27:01,390 --> 00:27:05,540
ეს სიჩქარის პროცესის გამართვის up საოცრად.

322
00:27:05,540 --> 00:27:09,230
ასე გამოყენებით printf, ყველა დროის გავაკეთოთ, რომ თქვენ უნდა recompile თქვენი კოდი,

323
00:27:09,230 --> 00:27:13,000
თქვენ უნდა გაუშვათ ისევ, ზოგჯერ თქვენ უნდა გადავიდეთ printf ზარის გარშემო,

324
00:27:13,000 --> 00:27:17,100
კომენტარის გარეთ კოდი, უბრალოდ იღებს ხოლო.

325
00:27:17,100 --> 00:27:20,850
ჩვენი მიზანია ცდილობენ და დარწმუნება იმაში, რომ GDB, შეგიძლიათ არსებითად

326
00:27:20,850 --> 00:27:26,810
printf არაფერი ნებისმიერი პუნქტი თქვენი კოდი და თქვენ არასოდეს არ recompile იგი.

327
00:27:26,810 --> 00:27:35,120
თქვენ არასოდეს არ უნდა დაიწყოს და შენარჩუნებას გამოცნობა სად printf შემდეგი.

328
00:27:35,120 --> 00:27:40,910
პირველი, რაც უნდა გააკეთოთ გადააკოპირეთ ეს ხაზი და მიიღოთ მონაკვეთის კოდი გამორთვა ვებგვერდი.

329
00:27:40,910 --> 00:27:47,530
მე გადაწერა ეს ხაზი კოდი, რომ ამბობს, "wget ​​http://cdn.cs50.net".

330
00:27:47,530 --> 00:27:49,510
მე ვაპირებ კოპირება.

331
00:27:49,510 --> 00:27:55,950
მე ვაპირებ წასვლა მეტი ჩემს ელექტრო მოწყობილობების, დააშორებს ასე რომ თქვენ შეგიძლიათ ნახოთ თუ რა მე ვაკეთებ,

332
00:27:55,950 --> 00:28:01,890
pasting ეს იქ, და როდესაც მე დააჭიროთ, ეს wget ბრძანება სიტყვასიტყვით არის ვებ მისაღებად.

333
00:28:01,890 --> 00:28:06,210
იგი აპირებს გაიყვანოს ქვემოთ ამ ფაილის გამორთვა ინტერნეტი,

334
00:28:06,210 --> 00:28:11,790
და ის აპირებს შეინახავთ მას მიმდინარე დირექტორია.

335
00:28:11,790 --> 00:28:21,630
არის თუ ჩასვათ ჩემი მიმდინარე დირექტორიაში თქვენ ხედავთ, რომ მაქვს ამ section5.zip ფაილი უფლება იქ.

336
00:28:21,630 --> 00:28:25,260
გზა გაუმკლავდეთ, რომ ბიჭი არის unzip იგი,

337
00:28:25,260 --> 00:28:27,650
რომელიც შეგიძლიათ გავაკეთოთ ბრძანება ხაზი, უბრალოდ მოსწონს ეს.

338
00:28:27,650 --> 00:28:31,880
Section5.zip.

339
00:28:31,880 --> 00:28:36,980
რომ ყველაფერს unzip იგი, საქაღალდის შექმნა ჩემთვის,

340
00:28:36,980 --> 00:28:40,410
inflate ყველა შინაარსი, დაუსვან მათ იქ.

341
00:28:40,410 --> 00:28:47,410
ახლა შემიძლია წასვლას ჩემი განყოფილებაში 5 დირექტორია გამოყენებით CD ბრძანება.

342
00:28:47,410 --> 00:28:58,310
წმინდა ეკრანზე გამოყენებით წმინდა. ასე რომ ნათელი ეკრანზე.

343
00:28:58,310 --> 00:29:02,280
ახლა მაქვს ლამაზი სუფთა ტერმინალში გამკლავება.

344
00:29:02,280 --> 00:29:06,200
>> არის თუ სიაში ყველა ფაილი, რომელიც მე ვერ ვხედავ ამ დირექტორიაში,

345
00:29:06,200 --> 00:29:12,270
ხედავთ, რომ მაქვს ოთხი თამაშები: buggy1, buggy2, buggy3 და buggy4.

346
00:29:12,270 --> 00:29:16,180
მე ასევე მივიღე მათი შესაბამისი. გ files.

347
00:29:16,180 --> 00:29:20,400
ჩვენ არ ვაპირებთ შევხედოთ. გ ფაილი არის.

348
00:29:20,400 --> 00:29:24,140
სამაგიეროდ, ჩვენ ვაპირებთ მათ გამოყენებას, როდესაც ჩვენ გახსენით GDB.

349
00:29:24,140 --> 00:29:28,220
ჩვენ ინახება მათ გარშემო ისე, რომ ჩვენ გვაქვს წვდომა ფაქტობრივი კოდის როდესაც ჩვენ გამოყენებით GDB,

350
00:29:28,220 --> 00:29:32,740
მაგრამ მიზანი ამ ნაწილის მონაკვეთის არის Tinker გარშემო GDB

351
00:29:32,740 --> 00:29:40,370
და ვნახოთ, როგორ შეგვიძლია გამოვიყენოთ რომ გაერკვნენ, რა ხდება ცუდი თითოეულ ამ ოთხი buggy პროგრამები.

352
00:29:40,370 --> 00:29:43,380
ასე რომ ჩვენ უბრალოდ აპირებს გარშემო ოთახში მართლაც სწრაფად,

353
00:29:43,380 --> 00:29:47,000
და მე ვაპირებ ვკითხო ვინმეს გასაშვებად ერთი buggy პროგრამების,

354
00:29:47,000 --> 00:29:54,730
და მაშინ ჩვენ წავიდეთ როგორც ჯგუფის მეშვეობით GDB და ვნახავთ, თუ რა შეგვიძლია გავაკეთოთ დაფიქსირება ამ პროგრამების,

355
00:29:54,730 --> 00:29:58,460
ან მინიმუმ იდენტიფიცირება რა ხდება არასწორი თითოეულ მათგანს.

356
00:29:58,460 --> 00:30:04,760
დავიწყოთ მეტი აქ დენიელ. თუ თქვენ აწარმოებს buggy1? ვნახოთ, რა მოხდება.

357
00:30:04,760 --> 00:30:09,470
[დანიელ] განცხადებაში ნათქვამია, იქ განაცხადის ბრალია. >> Yeah. სწორედ.

358
00:30:09,470 --> 00:30:12,460
ასე რომ, თუ მე აწარმოებს buggy1, მივიღებ seg ბრალია.

359
00:30:12,460 --> 00:30:16,210
ამ ეტაპზე, მე ვერ წავიდეს და გახსენით buggy1.c,

360
00:30:16,210 --> 00:30:19,450
სცადეთ და გაერკვნენ, თუ რა ხდება არასწორი,

361
00:30:19,450 --> 00:30:22,000
მაგრამ ერთ ერთი ყველაზე ObnoXious რამ ამ seg ბრალია შეცდომა

362
00:30:22,000 --> 00:30:27,610
ის არის, რომ ეს არ გითხრათ რა ხაზის პროგრამის რამ რეალურად წავიდა არასწორია და გატეხა.

363
00:30:27,610 --> 00:30:29,880
თქვენ სახის უნდა შევხედოთ კოდი

364
00:30:29,880 --> 00:30:33,990
და გაერკვნენ გამოყენებით ამოიცნობთ და შემოწმება ან printf დაინახოს რა ხდება არასწორი.

365
00:30:33,990 --> 00:30:37,840
ერთი coolest რამ GDB ის არის, რომ ეს მართლაც, მართლაც ადვილი

366
00:30:37,840 --> 00:30:42,170
გაერკვნენ ხაზი, რომლის დროსაც თქვენი პროგრამის დამსხვრევაზე.

367
00:30:42,170 --> 00:30:46,160
ეს სრულიად ღირს მის გამოყენებას, მაშინაც კი, თუ მხოლოდ, რომ.

368
00:30:46,160 --> 00:30:56,190
ასე რომ ჩატვირთვისას up GDB, I ტიპის GDB, და მერე მისცეს მას გეზი შესრულებადი რომ მინდა აწარმოებს.

369
00:30:56,190 --> 00:31:01,960
აქ მე აკრეფის GDB ./buggy1.

370
00:31:01,960 --> 00:31:06,600
'Enter. მაძლევს ყველა ამ საავტორო უფლებების შესახებ ინფორმაციის

371
00:31:06,600 --> 00:31:13,000
და ქვევით აქ თქვენ ნახავთ ამ ხაზის რომ ამბობს, "წაკითხვის სიმბოლიკა საწყისი / მთავარი /

372
00:31:13,000 --> 00:31:17,680
jharvard/section5/buggy1. "

373
00:31:17,680 --> 00:31:22,060
და თუ ყველაფერი კარგად იქნება, თქვენ ნახავთ ეს ამობეჭდოთ გაგზავნა, რომ ასე გამოიყურება.

374
00:31:22,060 --> 00:31:25,500
იგი ყველაფერს წაიკითხა სიმბოლიკა, ეს კიდე ამბობენ "მე კითხულობს სიმბოლიკა თქვენი შესრულებადი ფაილი"

375
00:31:25,500 --> 00:31:29,900
და მაშინ ექნება ამ "კეთდება" გაგზავნა მეტი აქ.

376
00:31:29,900 --> 00:31:35,410
თუ ხედავთ რაიმე სხვა ვარიაცია ამ, ან ხედავთ იგი ვერ იპოვა სიმბოლიკა

377
00:31:35,410 --> 00:31:41,460
ან რამე მაგდაგვარს, რა, რაც იმას ნიშნავს, რომ თქვენ უბრალოდ არ შედგენილი თქვენი შესრულებადი სათანადოდ.

378
00:31:41,460 --> 00:31:49,980
როდესაც ჩვენ კომპილაციის პროგრამების გამოყენება GDB, ჩვენ უნდა გამოვიყენოთ, რომ სპეციალური გ დროშა,

379
00:31:49,980 --> 00:31:54,540
და ეს გაკეთდეს იყოს თუ კომპილაციის თქვენი პროგრამების, უბრალოდ აკრეფით მიიღოს

380
00:31:54,540 --> 00:31:59,320
ან buggy ან ფეხზე, ნებისმიერი იმ.

381
00:31:59,320 --> 00:32:07,800
მაგრამ თუ თქვენ შედგენის ხელით Clang, მაშინ თქვენ უნდა წავიდეს და მოიცავს რომ-G დროშა.

382
00:32:07,800 --> 00:32:10,310
>> ამ ეტაპზე, არის, რომ ჩვენ გვაქვს ჩვენი GDB სწრაფი,

383
00:32:10,310 --> 00:32:12,310
ეს საკმაოდ მარტივი პროგრამის გაშვება.

384
00:32:12,310 --> 00:32:19,740
ჩვენ შეგიძლიათ აკრიფოთ პერსპექტივაში, ან ჩვენ შეგვიძლია უბრალოდ აკრიფეთ R.

385
00:32:19,740 --> 00:32:22,820
ყველაზე GDB ბრძანებები შეიძლება შემოკლებით.

386
00:32:22,820 --> 00:32:25,940
ჩვეულებრივ მხოლოდ ერთი ან რამდენიმე ასოს, რომელიც საკმაოდ ლამაზი.

387
00:32:25,940 --> 00:32:30,980
ამიტომ Saad, თუ Type R და დააჭიროთ, რა ხდება?

388
00:32:30,980 --> 00:32:39,390
[Saad] მე მივიღე SIGSEGV, სეგმენტაცია ბრალია, და შემდეგ ყველა ამ gobbledygook.

389
00:32:39,390 --> 00:32:43,650
>> Yeah.

390
00:32:43,650 --> 00:32:47,990
მსგავსად ჩვენ ვხედავთ ეკრანზე ახლავე, და მოსწონს Saad განაცხადა,

391
00:32:47,990 --> 00:32:53,430
როდესაც ვწერთ run ან R და დააჭიროთ, ჩვენ მაინც იგივე seg ბრალია.

392
00:32:53,430 --> 00:32:55,830
ასე გამოყენებით GDB არ გადაჭრას ჩვენი პრობლემა.

393
00:32:55,830 --> 00:32:59,120
მაგრამ ეს გვაძლევს რამდენიმე gobbledygook, და აღმოჩნდება, რომ ამ gobbledygook

394
00:32:59,120 --> 00:33:03,080
ფაქტობრივად გვეუბნება, სადაც ეს ხდება.

395
00:33:03,080 --> 00:33:10,680
გარჩევის ამ ცოტა, ამ პირველი bit არის ფუნქცია, რომელიც ყველაფერს ხდება არასწორი.

396
00:33:10,680 --> 00:33:20,270
არსებობს ამ __ strcmp_sse4_2, და ეს გვეუბნება, რომ ეს ხდება ამ ფაილის

397
00:33:20,270 --> 00:33:29,450
მოუწოდა sysdeps/i386, ეს ყველაფერი, ისევ და ისევ, სახის არეულობა - მაგრამ ხაზი 254.

398
00:33:29,450 --> 00:33:31,670
სწორედ ამგვარი მძიმე გარჩევის. ჩვეულებრივ, როდესაც თქვენ ხედავთ, პერსონალის მოსწონს,

399
00:33:31,670 --> 00:33:38,770
რაც იმას ნიშნავს, რომ ის seg faulting ერთ სისტემის ბიბლიოთეკებს.

400
00:33:38,770 --> 00:33:43,220
ასე რომ რაღაც არ უკავშირდება strcmp. თქვენ ბიჭები ვნახეთ strcmp ადრე.

401
00:33:43,220 --> 00:33:52,730
არც ისე გიჟები, მაგრამ ნიშნავს ეს რომ strcmp ბრალია ან რომ არსებობს პრობლემა strcmp?

402
00:33:52,730 --> 00:33:57,110
როგორ ფიქრობთ, ალექსანდრე?

403
00:33:57,110 --> 00:34:04,890
[ალექსანდრე] არის, რომ - არის 254 სტრიქონში? და - არა ორობითი, მაგრამ არა მათი ჭერი,

404
00:34:04,890 --> 00:34:10,590
და შემდეგ იქ სხვა ენაზე თითოეული ფუნქცია. ის არის, რომ 254 წელს, რომ ფუნქცია, ან -?

405
00:34:10,590 --> 00:34:21,460
>> ეს ხაზი 254. როგორც ჩანს ამ. ფაილური, ამიტომ ასამბლეა კოდი ალბათ.

406
00:34:21,460 --> 00:34:25,949
>> მაგრამ, ვფიქრობ, კიდევ უფრო მწვავე რამ არის, რადგან ჩვენ მიღებული seg ბრალია,

407
00:34:25,949 --> 00:34:29,960
და როგორც ჩანს ის მოდის strcmp ფუნქცია,

408
00:34:29,960 --> 00:34:38,030
ამჯამად ამ გულისხმობს, მაშინ, რომ strcmp ბრალია?

409
00:34:38,030 --> 00:34:42,290
ეს არ უნდა, იმედია. ასე მხოლოდ იმიტომ, რომ თქვენ გაქვთ სეგმენტაცია ბრალია

410
00:34:42,290 --> 00:34:49,480
ერთ სისტემის ფუნქციები, როგორც წესი, ეს იმას ნიშნავს რომ თქვენ უბრალოდ არ უწოდა სწორად.

411
00:34:49,480 --> 00:34:52,440
სწრაფი რამ რაც უნდა გააკეთოთ, რათა გაერკვნენ, რა რეალურად მიმდინარეობს

412
00:34:52,440 --> 00:34:55,500
როდესაც ხედავთ რაღაც Crazy მოსწონს, როცა ხედავთ seg ბრალია,

413
00:34:55,500 --> 00:34:59,800
განსაკუთრებით იმ შემთხვევაში, თუ თქვენ გაქვთ პროგრამა, რომელიც იყენებს მხოლოდ ძირითად,

414
00:34:59,800 --> 00:35:03,570
გამოყენება backtrace.

415
00:35:03,570 --> 00:35:13,080
მე abbreviate backtrace წერილობით BT, როგორც ეწინააღმდეგებოდა სრული backtrace სიტყვა.

416
00:35:13,080 --> 00:35:16,510
მაგრამ შარლოტა, რა მოხდება მაშინ, როდესაც თქვენ ტიპი BT და დააჭიროთ?

417
00:35:16,510 --> 00:35:23,200
[Charlotte] აქედან ჩანს, ჩემთვის ორ ხაზს, ხაზის 0 და ხაზი 1.

418
00:35:23,200 --> 00:35:26,150
>> Yeah. ასე ხაზის 0 და ხაზი 1.

419
00:35:26,150 --> 00:35:34,560
ეს არის ფაქტობრივი დასტის ფარგლებში, რომლებიც ამჟამად პიესა როდესაც თქვენი პროგრამის შეეჯახა.

420
00:35:34,560 --> 00:35:42,230
დაწყებული ზედოთ მდებარე ჩარჩო, ჩარჩოში 0, და აპირებს ქვედა საუკეთესო, რომელიც ჩარჩოში 1.

421
00:35:42,230 --> 00:35:45,140
ჩვენი ზედოთ მდებარე ჩარჩო არის strcmp ჩარჩო.

422
00:35:45,140 --> 00:35:50,080
შეგიძლიათ წარმოიდგინოთ, რომ ეს მსგავსი პრობლემა ჩვენ უბრალოდ აკეთებდა Quiz ერთად პოინტერები,

423
00:35:50,080 --> 00:35:54,890
სადაც ჩვენ გვქონდა სვოპ დასტის ჩარჩოს თავზე ძირითადი დასტის ჩარჩო,

424
00:35:54,890 --> 00:35:59,700
და ჩვენ გვქონდა ცვლადები რომ swap იყენებდა თავზე ცვლადები, რომ მთავარი იყო გამოყენებით.

425
00:35:59,700 --> 00:36:08,440
აქ ჩვენი კრახი მოხდა ჩვენი strcmp ფუნქცია, რომელიც ეწოდა ჩვენი მთავარი ფუნქცია,

426
00:36:08,440 --> 00:36:14,370
და backtrace გვაძლევს არა მხოლოდ ფუნქციების რომელშიც რამ ვერ მოახერხა,

427
00:36:14,370 --> 00:36:16,440
მაგრამ ასევე გვეუბნება სადაც ყველაფერი დამირეკეს.

428
00:36:16,440 --> 00:36:18,830
ასე რომ, თუ მე გადახვევა მეტი ცოტა მეტი მარჯვნივ,

429
00:36:18,830 --> 00:36:26,110
ვხედავთ, რომ ჰო, ვიყავით on line 254 ამ strcmp-sse4.s ფაილი.

430
00:36:26,110 --> 00:36:32,540
მაგრამ ზარის გაკეთდა buggy1.c, ხაზის 6.

431
00:36:32,540 --> 00:36:35,960
ასე რომ, რაც იმას ნიშნავს, რომ ჩვენ შეგვიძლია გავაკეთოთ - არის შეგვიძლია უბრალოდ შეამოწმეთ და ვნახოთ რა ხდებოდა

432
00:36:35,960 --> 00:36:39,930
ზე buggy1.c, ხაზის 6.

433
00:36:39,930 --> 00:36:43,780
ერთხელ, არის რამდენიმე გზა ამის გაკეთება. ერთი არის გასასვლელად გარეთ GDB

434
00:36:43,780 --> 00:36:49,460
ან აქვს თქვენი კოდი გაიხსნება მეორე ფანჯარა და ჯვარი მინიშნება.

435
00:36:49,460 --> 00:36:54,740
, რომ და თავისთავად არის საკმაოდ მოსახერხებელი, ვინაიდან, ახლა, თუ თქვენ ოფისში საათის

436
00:36:54,740 --> 00:36:57,220
და თქვენ მოხვდით seg ბრალია და თქვენი TF ის გაინტერესებთ, სადაც ყველაფერი იყო დარღვევის,

437
00:36:57,220 --> 00:36:59,710
შეგიძლიათ უბრალოდ, ვამბობთ, "ო, ხაზის 6. არ ვიცი რა ხდება,

438
00:36:59,710 --> 00:37:03,670
მაგრამ რაღაც შესახებ ხაზი 6 რამ გამოიწვია ჩემი პროგრამა მოხსნა. "

439
00:37:03,670 --> 00:37:10,430
სხვა გზა ამის გასაკეთებლად არის შეგიძლიათ გამოიყენოთ ეს ბრძანება მოუწოდა სიაში GDB.

440
00:37:10,430 --> 00:37:13,650
თქვენ ასევე შეგიძლიათ abbreviate იგი ლ.

441
00:37:13,650 --> 00:37:18,910
ასე რომ, თუ ჩვენ მოხვდა ლ, რას მივიღებთ აქ?

442
00:37:18,910 --> 00:37:21,160
ჩვენ კიდევ მთელი bunch of უცნაური ნივთები.

443
00:37:21,160 --> 00:37:26,030
ეს არის ფაქტობრივი ასამბლეის კოდი

444
00:37:26,030 --> 00:37:29,860
რომ არის strcmp_sse4_2.

445
00:37:29,860 --> 00:37:32,440
ეს გამოიყურება სახის ხმაურიანი,

446
00:37:32,440 --> 00:37:36,520
და მიზეზი ჩვენ ვიღებთ ეს იმიტომ ახლავე,

447
00:37:36,520 --> 00:37:40,160
GDB აქვს ჩვენთვის ჩარჩო 0.

448
00:37:40,160 --> 00:37:43,070
>> ასე რომ ნებისმიერ დროს შევხედავთ ცვლადები, ნებისმიერ დროს შევხედავთ კოდებს,

449
00:37:43,070 --> 00:37:50,530
ჩვენ შევხედავთ კოდის რომ ეხება დასტის ჩარჩო ჩვენ გაკეთებული სისტემაში

450
00:37:50,530 --> 00:37:53,200
ასე მისაღებად არაფერი აზრიანი, ჩვენ უნდა

451
00:37:53,200 --> 00:37:57,070
გადასვლის დასტის ჩარჩო ხდის უფრო გრძნობა.

452
00:37:57,070 --> 00:38:00,180
ამ შემთხვევაში, მთავარ დასტის ჩარჩო გახდის უფრო გრძნობა,

453
00:38:00,180 --> 00:38:02,680
იმიტომ, რომ იყო ფაქტიურად კოდი, რომ ჩვენ წერდა.

454
00:38:02,680 --> 00:38:05,330
არ strcmp კოდი.

455
00:38:05,330 --> 00:38:08,650
გზით თქვენ შეგიძლიათ გადაადგილება შორის ფარგლებში, ამ შემთხვევაში, იმიტომ რომ ჩვენ გვაქვს ორი,

456
00:38:08,650 --> 00:38:10,430
ჩვენ გვყავს 0 და 1,

457
00:38:10,430 --> 00:38:13,650
თქვენ აკეთებთ, რომ up და down ბრძანებები.

458
00:38:13,650 --> 00:38:18,480
თუ მე გადაადგილება ერთ ჩარჩოში,

459
00:38:18,480 --> 00:38:21,770
ახლა მე ძირითად დასტის ჩარჩო.

460
00:38:21,770 --> 00:38:24,330
შემიძლია ქვევით დაბრუნდეს იქ, სადაც მე ვიყავი,

461
00:38:24,330 --> 00:38:32,830
ახვიდეთ ერთხელ, ქვევით კიდევ ერთხელ, და წავიდეთ ისევ.

462
00:38:32,830 --> 00:38:39,750
თუ თქვენ ოდესმე გააკეთოს თქვენი პროგრამის GDB, თქვენ ავარიის, თქვენ backtrace,

463
00:38:39,750 --> 00:38:42,380
და ხედავთ, რომ ზოგიერთ ფაილი, რომ თქვენ არ ვიცი რა ხდება.

464
00:38:42,380 --> 00:38:45,460
თქვენ ცდილობენ სია, კოდი არ გამოიყურება ნაცნობი თქვენ,

465
00:38:45,460 --> 00:38:48,150
შეხედეთ თქვენს ფარგლებში და გაერკვნენ, სადაც ხართ.

466
00:38:48,150 --> 00:38:51,010
თქვენ ალბათ არასწორი დასტის ჩარჩო.

467
00:38:51,010 --> 00:38:58,760
ან თუნდაც თქვენ დასტის ჩარჩო რომ არ არის ერთი, რომ შეგიძლიათ ნამდვილად გამართვის.

468
00:38:58,760 --> 00:39:03,110
არის, რომ ჩვენ შესაბამის დასტის ჩარჩო, ჩვენ მთავარ,

469
00:39:03,110 --> 00:39:08,100
ახლა ჩვენ შეგვიძლია გამოვიყენოთ სია ბრძანება გაერკვნენ, რა ხაზი.

470
00:39:08,100 --> 00:39:13,590
და შეგიძლიათ მისი დანახვა; მას დაბეჭდილი ეს ჩვენთვის უფლება აქ.

471
00:39:13,590 --> 00:39:19,470
მაგრამ ჩვენ შეგვიძლია მოხვდა სიაში ყველა იგივე, და სიაში გვაძლევს ამ ლამაზი ამონაწერი

472
00:39:19,470 --> 00:39:23,920
ფაქტობრივი კოდის რომ ხდება აქ.

473
00:39:23,920 --> 00:39:26,420
>> კერძოდ, ჩვენ შეგვიძლია შევხედოთ ხაზის 6.

474
00:39:26,420 --> 00:39:29,330
ჩვენ ვხედავთ, რა ხდება აქ.

475
00:39:29,330 --> 00:39:31,250
და როგორც ჩანს ჩვენ მიღების სიმებიანი შედარებით

476
00:39:31,250 --> 00:39:41,050
შორის სტრიქონი "CS50 კლდეები" და argv [1].

477
00:39:41,050 --> 00:39:45,700
რაღაც ამ წელს crashing.

478
00:39:45,700 --> 00:39:54,120
ამიტომ მისის, გაქვთ რაიმე მოსაზრებები იმის შესახებ, თუ რა შეიძლება იყოს ხდება?

479
00:39:54,120 --> 00:39:59,400
[Missy] არ ვიცი, რატომ ის crashing. >> თქვენ არ ვიცი რატომ ის crashing?

480
00:39:59,400 --> 00:40:02,700
ჯიმი, ნებისმიერი აზრები?

481
00:40:02,700 --> 00:40:06,240
[Jimmy] მე არ ვარ მთლიანად დარწმუნებული, მაგრამ ბოლო დროს ჩვენ გამოიყენება სტრინგის შევადარებთ,

482
00:40:06,240 --> 00:40:10,260
ან strcmp, გვქონდა, როგორიც სამი სხვადასხვა შემთხვევებში მის ქვეშ.

483
00:40:10,260 --> 00:40:12,800
ჩვენ არ გვქონდა ==, მე არ ვფიქრობ, სწორედ რომ პირველ ხაზზე.

484
00:40:12,800 --> 00:40:16,700
ამის ნაცვლად იგი დაყოფილია სამ, ხოლო ერთი იყო == 0,

485
00:40:16,700 --> 00:40:19,910
ერთი იყო <0, ვფიქრობ, და ერთი იყო> 0.

486
00:40:19,910 --> 00:40:22,590
იქნებ რამე მაგდაგვარს? >> Yeah. ასე რომ არსებობს ამ საკითხის

487
00:40:22,590 --> 00:40:27,200
საქართველოს ვაკეთებთ შედარებით სწორად?

488
00:40:27,200 --> 00:40:31,660
Stella? ნებისმიერი აზრები?

489
00:40:31,660 --> 00:40:38,110
[Stella] არ ვარ დარწმუნებული. >> დარწმუნებული არ არის. დანიელ? ფიქრები? Okay.

490
00:40:38,110 --> 00:40:44,770
თურმე რა ხდება სწორედ აქ არის, როდესაც ჩვენ გაიქცა პროგრამა

491
00:40:44,770 --> 00:40:48,370
და მივიღეთ seg ბრალია, როდესაც თქვენ გაიქცა პროგრამა პირველად, დანიელ,

492
00:40:48,370 --> 00:40:50,800
არ მისცეს მას ნებისმიერი ბრძანების ხაზი არგუმენტები?

493
00:40:50,800 --> 00:40:58,420
[დანიელ] მდებარ >> პოსტები ამ შემთხვევაში, რა არის ღირებულება argv [1]?

494
00:40:58,420 --> 00:41:00,920
>> არ არსებობს ღირებულება. >> მარჯვენა.

495
00:41:00,920 --> 00:41:06,120
ისე, არ არსებობს შესაბამისი სიმებიანი ღირებულება.

496
00:41:06,120 --> 00:41:10,780
თუმცა, არსებობს გარკვეული მნიშვნელობა. რა არის ღირებულება რომ იღებს შენახული იქ?

497
00:41:10,780 --> 00:41:15,130
>> ნაგვის მნიშვნელობა? >> ეს არც ნაგვის ღირებულება ან, ამ შემთხვევაში,

498
00:41:15,130 --> 00:41:19,930
ბოლოს argv მასივი ყოველთვის წყდება ერთად null.

499
00:41:19,930 --> 00:41:26,050
ასე რომ, რეალურად რა გაბმულ შენახული არსებობს null.

500
00:41:26,050 --> 00:41:30,810
სხვა გზა მოსაგვარებლად, ვიდრე ფიქრი ის მეშვეობით,

501
00:41:30,810 --> 00:41:33,420
ასეთია ბეჭდვას ის.

502
00:41:33,420 --> 00:41:35,880
ეს არის სადაც მე ამბობდა, რომ გამოყენებით GDB დიდია,

503
00:41:35,880 --> 00:41:40,640
იმიტომ, რომ თქვენ შეგიძლიათ ამობეჭდოთ ყველა ცვლადები, ყველა ღირებულებები, რომ გსურთ

504
00:41:40,640 --> 00:41:43,230
გამოყენებით ამ მოსახერხებელი-Dandy P ბრძანება.

505
00:41:43,230 --> 00:41:48,520
ასე რომ, თუ მე აკრიფოთ P და მერე აკრიფოთ ღირებულების ცვალებად და სახელით ცვლადი,

506
00:41:48,520 --> 00:41:55,320
ამბობენ, argc, ვხედავ, რომ argc არის 1.

507
00:41:55,320 --> 00:42:01,830
თუკი მინდა ამობეჭდოთ argv [0], მე შემიძლია ამის გაკეთება, ისევე, როგორც, რომ.

508
00:42:01,830 --> 00:42:04,840
და როგორც ვნახეთ, argv [0] ყოველთვის სახელი თქვენი პროგრამა,

509
00:42:04,840 --> 00:42:06,910
ყოველთვის სახელით გაშვება.

510
00:42:06,910 --> 00:42:09,740
აქ ხედავთ ის მივიღე სრული გეზი სახელი.

511
00:42:09,740 --> 00:42:15,920
შემიძლია ასევე ამობეჭდოთ argv [1] და ვნახოთ, რა მოხდება.

512
00:42:15,920 --> 00:42:20,890
>> აქ მივიღეთ ამგვარი მისტიკური მნიშვნელობა.

513
00:42:20,890 --> 00:42:23,890
ჩვენ ამ 0x0.

514
00:42:23,890 --> 00:42:27,850
დამახსოვრება დასაწყისში ტერმინი, როდესაც ჩვენ ვისაუბრეთ თექვსმეტობითი ციფრები?

515
00:42:27,850 --> 00:42:34,680
ან რომ პატარა შეკითხვა დასასრულს pset 0 შესახებ, თუ როგორ უნდა წარმოადგინოს 50 in hex?

516
00:42:34,680 --> 00:42:39,410
გზა ჩვენ წერენ hex ნომრები CS, მხოლოდ იმიტომ, რომ არ აღრეული საკუთარ თავს

517
00:42:39,410 --> 00:42:46,080
ერთად ათობითი რიცხვები, არის ჩვენ ყოველთვის პრეფიქსი მათ 0x.

518
00:42:46,080 --> 00:42:51,420
ასე რომ, ეს პრეფიქსი 0x ყოველთვის მხოლოდ იმას ნიშნავს, ინტერპრეტაცია ნომერზე როგორც რიცხვი,

519
00:42:51,420 --> 00:42:57,400
არა როგორც ტექსტი, არა როგორც ათობითი რიცხვი, არა როგორც ორობითი რიცხვი.

520
00:42:57,400 --> 00:43:02,820
მას შემდეგ, რაც ხმების 5-0 არის სწორი ნომერი თექვსმეტობითი.

521
00:43:02,820 --> 00:43:06,240
და ეს ნომერი ათობითი, 50.

522
00:43:06,240 --> 00:43:10,050
ასე რომ, ეს არის, თუ რამდენად ჩვენ disambiguate.

523
00:43:10,050 --> 00:43:14,860
ასე 0x0 საშუალებით თექვსმეტობითი 0, რომელიც არის ასევე ათობითი 0, ორობითი 0.

524
00:43:14,860 --> 00:43:17,030
უბრალოდ ღირებულება 0.

525
00:43:17,030 --> 00:43:22,630
თურმე ეს რა null არის, ფაქტობრივად, მეხსიერებაში.

526
00:43:22,630 --> 00:43:25,940
Null მხოლოდ 0.

527
00:43:25,940 --> 00:43:37,010
აქ ელემენტს ინახება argv [1] არის null.

528
00:43:37,010 --> 00:43:45,220
ამიტომ, ჩვენ ვცდილობთ შედარების ჩვენი "CS50 კლდეები" string to null სიმებიანი.

529
00:43:45,220 --> 00:43:48,130
ამიტომ dereferencing null, ცდილობს შედიხართ რამ საათზე null,

530
00:43:48,130 --> 00:43:55,050
იმ ტიპიურად აპირებს გამოიწვიოს გარკვეული სეგმენტაცია ბრალია ან სხვა ცუდი რამ მოხდეს.

531
00:43:55,050 --> 00:43:59,350
და აღმოჩნდება, რომ strcmp არ შეამოწმეთ

532
00:43:59,350 --> 00:44:04,340
თუ არა თქვენ წელს მიღებული ღირებულების რომ null.

533
00:44:04,340 --> 00:44:06,370
პირიქით, ის მხოლოდ მიდის წინ, ცდილობს თავისი ნივთი,

534
00:44:06,370 --> 00:44:14,640
და თუ ეს seg ხარვეზებით, ეს seg ხარვეზებით, და ეს თქვენი პრობლემაა. თქვენ უნდა წავიდეს გაასწორონ ის.

535
00:44:14,640 --> 00:44:19,730
მართლაც სწრაფად, როგორ შეიძლება ჩვენ დაფიქსირება ამ პრობლემას? Charlotte?

536
00:44:19,730 --> 00:44:23,540
[Charlotte] თქვენ შეგიძლიათ შეამოწმოთ გამოყენებით, თუ.

537
00:44:23,540 --> 00:44:32,240
ასე რომ, თუ argv [1] არის null, == 0, მაშინ დაბრუნდებიან 1, ან რაღაც [გაუგებარია].

538
00:44:32,240 --> 00:44:34,590
>> Yeah. ასე რომ ერთი დიდი გზა ამის გაკეთება, როგორც შეგვიძლია შეამოწმეთ,

539
00:44:34,590 --> 00:44:39,230
ღირებულება ჩვენ შესახებ გაიაროს შევიდა strcmp, argv [1], რომელიც მას null?

540
00:44:39,230 --> 00:44:45,830
თუ ეს null, მაშინ შეგვიძლია ვთქვათ, okay, შეწყვეტილია.

541
00:44:45,830 --> 00:44:49,450
>> გავრცელებული გზა ამის გამოყენება argc ღირებულება.

542
00:44:49,450 --> 00:44:52,040
თქვენ ხედავთ, სწორედ აქ დასაწყისში ძირითად,

543
00:44:52,040 --> 00:44:58,040
ჩვენ გამოტოვებული რომ პირველი გამოცდა რომ ჩვენ, როგორც წესი, როდესაც ჩვენ ვიყენებთ command line არგუმენტები,

544
00:44:58,040 --> 00:45:05,240
რაც შესამოწმებლად თუ არა ჩვენი argc ღირებულება არის ის, რაც ჩვენ ველით.

545
00:45:05,240 --> 00:45:10,290
ამ შემთხვევაში, ჩვენ ველოდებით მინიმუმ ორი არგუმენტები,

546
00:45:10,290 --> 00:45:13,660
პროგრამის დასახელება პლუს ერთი სხვა.

547
00:45:13,660 --> 00:45:17,140
იმის გამო, რომ ჩვენ უნდა გამოვიყენოთ მეორე არგუმენტი უფლება აქ.

548
00:45:17,140 --> 00:45:21,350
ასე რომ გარკვეული სახის ტესტი წინასწარ, სანამ ჩვენი strcmp ზარის

549
00:45:21,350 --> 00:45:37,390
რომ ტესტები თუ არა argv მინიმუმ 2, ასევე იგივე სახის რამ.

550
00:45:37,390 --> 00:45:40,620
ჩვენ ვხედავთ, თუ, რომელიც მუშაობს მიერ გაშვებული პროგრამა ერთხელ.

551
00:45:40,620 --> 00:45:45,610
თქვენ ყოველთვის შეგიძლიათ გადატვირთეთ პროგრამა ფარგლებში GDB, რომელიც მართლაც ლამაზი.

552
00:45:45,610 --> 00:45:49,310
თქვენ შეგიძლიათ აწარმოებს, და როდესაც თქვენ კორიდორი არგუმენტები თქვენი პროგრამა,

553
00:45:49,310 --> 00:45:53,060
თქვენ გაივლით მათ როცა რეკავთ აწარმოებს, არ როდესაც თქვენ ჩატვირთვისას up GDB.

554
00:45:53,060 --> 00:45:57,120
ამ გზით თქვენ შეგიძლიათ შეინახოთ თქვენი ხელმძღვანელობა არა მარტო აპელირებს პროგრამის სხვადასხვა არგუმენტები ყოველ ჯერზე.

555
00:45:57,120 --> 00:46:08,080
ასე აწარმოებს, ან ისევ და ისევ, მე შემიძლია Type R, და ვნახოთ რა მოხდება, თუ ჩვენ აკრიფოთ "Hello".

556
00:46:08,080 --> 00:46:11,140
იგი ყოველთვის გკითხოთ, თუ გნებავთ დაიწყოთ იგი თავიდანვე ერთხელ.

557
00:46:11,140 --> 00:46:17,490
ჩვეულებრივ, თქვენ გვინდა, რომ დაიწყოს ის დასაწყისში კვლავ.

558
00:46:17,490 --> 00:46:25,010
და ამ ეტაპზე, ეს restarts კიდევ ერთხელ, ეს ბეჭდავს out

559
00:46:25,010 --> 00:46:28,920
პროგრამა, რომელიც ჩვენ გაშვებული, buggy1, ერთად არგუმენტი Hello,

560
00:46:28,920 --> 00:46:32,720
და ეს ბეჭდავს ამ სტანდარტის გარეთ, ის ამბობს: "თქვენ მიიღეთ D," სამწუხარო სახე.

561
00:46:32,720 --> 00:46:37,610
მაგრამ ჩვენ არ seg ბრალია. მისი თქმით, პროცესის დასრულების ნორმალურად.

562
00:46:37,610 --> 00:46:39,900
ასე რომ გამოიყურება საკმაოდ კარგი.

563
00:46:39,900 --> 00:46:43,050
არა seg ბრალია, ჩვენ გახადა წარსულში,

564
00:46:43,050 --> 00:46:48,190
ასე გამოიყურება, რომ მართლაც seg ბრალია bug რომ ჩვენ იღებდნენ.

565
00:46:48,190 --> 00:46:51,540
სამწუხაროდ, გვეუბნება, რომ ჩვენ ვიღებთ დ

566
00:46:51,540 --> 00:46:54,090
>> ჩვენ შეგვიძლია უკან და შევხედოთ კოდი და ვნახოთ რა ხდებოდა იქ

567
00:46:54,090 --> 00:46:57,980
გაერკვნენ, თუ რა იყო - რატომ გახდა გვეუბნებოდა, რომ ჩვენ მივიღეთ დ

568
00:46:57,980 --> 00:47:03,690
ვნახოთ, აქ იყო ამ printf ვამბობ, რომ შენ დ

569
00:47:03,690 --> 00:47:08,540
თუ ჩვენ ტიპების სიას, როგორც თქვენ გაქვთ აკრეფით სიაში, ის ინახავს iterating ქვემოთ საშუალებით თქვენი პროგრამა,

570
00:47:08,540 --> 00:47:10,940
ასე რომ შენ გაჩვენებ პირველი რამდენიმე ხაზი თქვენი პროგრამა.

571
00:47:10,940 --> 00:47:15,450
მაშინ შენ გაჩვენებ მომდევნო რამდენიმე ხაზით და შემდეგი ბლოკი და შემდეგი ბლოკი.

572
00:47:15,450 --> 00:47:18,240
და ეს გავაგრძელებთ ცდილობს დაცემას.

573
00:47:18,240 --> 00:47:21,180
და ახლა ჩვენ მისაღებად "ხაზის ნომერზე 16 არის საზღვრებს სცილდება."

574
00:47:21,180 --> 00:47:23,940
იმიტომ, რომ ეს მხოლოდ 15 ხაზები.

575
00:47:23,940 --> 00:47:30,310
თუ თქვენ გაქვთ ამ წერტილი და თქვენი გაინტერესებთ, "რა გავაკეთო?" თქვენ შეგიძლიათ გამოიყენოთ დახმარება ბრძანება.

576
00:47:30,310 --> 00:47:34,340
დახმარება და შემდეგ მისცეს მას სახელით ბრძანება.

577
00:47:34,340 --> 00:47:36,460
და ხედავთ GDB გვაძლევს ყველა ამ სახის ნივთები.

578
00:47:36,460 --> 00:47:43,870
იგი ამბობს: "ერთად არ არგუმენტი, ჩამოთვლილია ათი მეტი ხაზების შემდეგ ან გარშემო წინა ჩამონათვალი.

579
00:47:43,870 --> 00:47:47,920
სია - ჩამოთვლილია ათი ხაზები ადრე - "

580
00:47:47,920 --> 00:47:52,960
მოდით სცადეთ სია მინუს.

581
00:47:52,960 --> 00:47:57,000
და რომ ჩამოთვლილია 10 ხაზები წინა; შეგიძლიათ ითამაშოთ გარშემო სია ცოტა.

582
00:47:57,000 --> 00:48:02,330
ამის გაკეთება შეგიძლიათ სია, სია - თქვენ შეგიძლიათ კიდევ მისცეს სიაში ნომერი, როგორიც სიაში 8,

583
00:48:02,330 --> 00:48:07,500
და ეს კიდე სიაში 10 ხაზები გარშემო ხაზი 8.

584
00:48:07,500 --> 00:48:10,290
და თქვენ შეგიძლიათ ნახოთ თუ რა ხდება აქ თქვენ მოხვდით მარტივი, თუ სხვაგან.

585
00:48:10,290 --> 00:48:13,980
თუ თქვენ აკრიფოთ CS50 კლდეები, იგი ბეჭდავს out "თქვენ ა"

586
00:48:13,980 --> 00:48:16,530
წინააღმდეგ შემთხვევაში ეს ბეჭდავს out "თქვენ დ"

587
00:48:16,530 --> 00:48:23,770
Bummer ქალაქში. ყველა უფლება. დიახ?

588
00:48:23,770 --> 00:48:26,730
>> [დანიელ] ასე რომ, როდესაც მე შევეცადე აკეთებს CS50 ქანების გარეშე შეთავაზებები,

589
00:48:26,730 --> 00:48:29,290
იგი ამბობს: "შენ კიდევ დ"

590
00:48:29,290 --> 00:48:32,560
მჭირდებოდა შეთავაზებები მიიღოს ეს მუშაობა, რატომ არის, რომ?

591
00:48:32,560 --> 00:48:38,490
>> Yeah. თურმე, როდესაც - ეს არის კიდევ ერთი პატარა fun tidbit -

592
00:48:38,490 --> 00:48:47,900
როდესაც თქვენ აწარმოებს პროგრამა, თუ ჩვენ გაუშვით და ჩვენ აკრიფოთ CS50 კლდეები,

593
00:48:47,900 --> 00:48:50,800
ისევე, როგორც დანიელ ამბობდა მან გააკეთა, და თქვენ 'Enter,

594
00:48:50,800 --> 00:48:52,870
ის კვლავ აცხადებს, მივიღებთ დ

595
00:48:52,870 --> 00:48:55,580
და კითხვაზე, თუ რატომ არის ეს?

596
00:48:55,580 --> 00:49:02,120
და აღმოჩნდება, რომ ორივე ჩვენი ტერმინალი და GDB გარჩევის ეს როგორც ორი დამოუკიდებელი არგუმენტები.

597
00:49:02,120 --> 00:49:04,800
რადგან, როდესაც არსებობს სივრცე, რომ იგულისხმება როგორც

598
00:49:04,800 --> 00:49:08,730
პირველი არგუმენტი დასრულდა; შემდეგი არგუმენტი დაიწყო.

599
00:49:08,730 --> 00:49:13,260
გზა დააკავშიროთ იმ ორ, ან უკაცრავად, ერთ არგუმენტს,

600
00:49:13,260 --> 00:49:18,510
გამოყენება შეთავაზებები.

601
00:49:18,510 --> 00:49:29,560
ახლა, თუ ჩვენ დააყენოს ის შეთავაზებები და გაუშვით ერთხელ, მივიღებთ ა

602
00:49:29,560 --> 00:49:38,780
ასე რომ მხოლოდ recap, არ შეთავაზებები, CS50 და კლდეები, გაანალიზება, როგორც ორი დამოუკიდებელი არგუმენტები.

603
00:49:38,780 --> 00:49:45,320
With შეთავაზებები, ის გაანალიზება, როგორც ერთი არგუმენტი საერთოდ.

604
00:49:45,320 --> 00:49:53,070
>> ჩვენ ვხედავთ ამ breakpoint.

605
00:49:53,070 --> 00:49:54,920
აქამდე ჩვენ გაშვებული ჩვენი პროგრამა და ეს უკვე გაშვებულია

606
00:49:54,920 --> 00:49:58,230
სანამ არც ის seg ხარვეზებით ან Hits შეცდომა

607
00:49:58,230 --> 00:50:05,930
ან სანამ იგი აღელვებული ადევნებს თვალყურს და ყველა მთლიანად ჯარიმა.

608
00:50:05,930 --> 00:50:08,360
ეს არ არის აუცილებლად საუკეთესო გამოსადეგი რამ, რადგან ზოგჯერ

609
00:50:08,360 --> 00:50:11,840
თქვენ გაქვთ შეცდომა თქვენს პროგრამაში, მაგრამ ეს არ იწვევს სეგმენტაცია ბრალია.

610
00:50:11,840 --> 00:50:16,950
ეს არ იწვევს თქვენი პროგრამის შეჩერება ან არაფერი რომ.

611
00:50:16,950 --> 00:50:20,730
გზა GDB პაუზის თქვენი პროგრამის განსაკუთრებული წერტილი

612
00:50:20,730 --> 00:50:23,260
არის მითითებული breakpoint.

613
00:50:23,260 --> 00:50:26,520
თქვენ შეგიძლიათ ან ამის გაკეთება მიიღწევა breakpoint on ფუნქციის სახელი

614
00:50:26,520 --> 00:50:30,770
ან თქვენ დააჭერთ breakpoint კონკრეტულ ხაზი კოდი.

615
00:50:30,770 --> 00:50:34,450
მე მიყვარს მითითებული breakpoints on ფუნქციის სახელები, რადგან - ადვილად დასამახსოვრებელი,

616
00:50:34,450 --> 00:50:37,700
და თუ თქვენ ნამდვილად წავიდეს და შეცვალოს თქვენი კოდის up ცოტა,

617
00:50:37,700 --> 00:50:42,020
მაშინ თქვენი breakpoint რეალურად დარჩება ერთი და იგივე ადგილზე განმავლობაში თქვენი კოდი.

618
00:50:42,020 --> 00:50:44,760
ხოლო თუ თქვენ იყენებთ ხაზის ნომრები და ხაზის ნომრები შეიცვლება

619
00:50:44,760 --> 00:50:51,740
იმიტომ, რომ თქვენ დაამატოთ ან წაშალოთ რამდენიმე კოდი, მაშინ თქვენი breakpoints ყველა მთლიანად ბრალია.

620
00:50:51,740 --> 00:50:58,590
ერთი ყველაზე გავრცელებული რამ გავაკეთო არის მითითებული breakpoint მთავარ ფუნქციას.

621
00:50:58,590 --> 00:51:05,300
ხშირად მე ჩატვირთვისას up GDB, მე აკრიფოთ ბ მთავარ, დააჭიროთ და რომ ნახავთ მითითებული breakpoint

622
00:51:05,300 --> 00:51:10,630
მთავარ ფუნქციას, რომელიც მხოლოდ ამბობს: "პაუზის პროგრამა, როგორც კი თქვენ დაიწყოს გაშვებული,"

623
00:51:10,630 --> 00:51:17,960
და რომ გზა, როცა აწარმოებს ჩემი პროგრამა, ვთქვათ, CS50 ქანების როგორც ორი არგუმენტები

624
00:51:17,960 --> 00:51:24,830
და 'Enter, იგი იღებს ძირითად ფუნქციას და იგი შეწყვეტს უფლება პირველივე ხაზი,

625
00:51:24,830 --> 00:51:30,620
უფლება სანამ აფასებს strcmp ფუნქცია.

626
00:51:30,620 --> 00:51:34,940
>> მას შემდეგ, რაც მე ათვისება, ახლა შემიძლია დაიწყოს mucking გარშემო და ხედავს რა ხდება

627
00:51:34,940 --> 00:51:40,250
ყველა ცვლადის სხვადასხვა, რომლებიც შევიდა ჩემი პროგრამა.

628
00:51:40,250 --> 00:51:43,670
აქ შეგიძლიათ ამობეჭდოთ argc და ვნახოთ რა ხდება.

629
00:51:43,670 --> 00:51:50,030
ვხედავთ, რომ argc არის 3, იმიტომ რომ მიიღო 3 სხვადასხვა ღირებულებების იგი.

630
00:51:50,030 --> 00:51:54,060
ეს სახელწოდება მიიღეს პროგრამის, ის მივიღე პირველი არგუმენტი და მეორე არგუმენტი.

631
00:51:54,060 --> 00:52:09,330
ჩვენ შეგვიძლია ბეჭდვა იმ მიერ ეძებს argv [0], argv [1], და argv [2].

632
00:52:09,330 --> 00:52:12,030
ახლა თქვენ შეგიძლიათ ასევე, თუ რატომ ეს strcmp ზარის აპირებს ვერ,

633
00:52:12,030 --> 00:52:21,650
რადგან ხედავთ, რომ ეს გაყოფილი up CS50 და ქანების ორ ცალკე არგუმენტები.

634
00:52:21,650 --> 00:52:27,250
ამ ეტაპზე, რომ ერთხელ თქვენ მოხვდა breakpoint, შეგიძლიათ გაგრძელდება დახევას საშუალებით თქვენი პროგრამა

635
00:52:27,250 --> 00:52:32,920
ხაზს, როგორც ეწინააღმდეგებოდა დაწყებული თქვენი პროგრამის ერთხელ.

636
00:52:32,920 --> 00:52:35,520
ასე რომ, თუ თქვენ არ გსურთ დაიწყოს თქვენი პროგრამის ერთხელ და მხოლოდ გაგრძელდება, აქ

637
00:52:35,520 --> 00:52:41,970
თქვენ შეგიძლიათ გამოიყენოთ გაგრძელდეს ბრძანება და გაგრძელდება მიიღებს პროგრამის ბოლომდე.

638
00:52:41,970 --> 00:52:45,010
ისევე, როგორც ეს მოხდა აქ.

639
00:52:45,010 --> 00:52:54,880
თუმცა, თუ მე გადატვირთეთ პროგრამა, CS50 კლდეები, ეს ურტყამს ჩემი breakpoint ერთხელ,

640
00:52:54,880 --> 00:52:59,670
და ამ დროს, თუ არ გვინდა, უბრალოდ წავიდეთ ყველა გზა მეშვეობით დანარჩენი პროგრამა,

641
00:52:59,670 --> 00:53:08,040
მე შეიძლება გამოიყენოს შემდეგი ბრძანება, რომელიც მე ასევე abbreviate ერთად n.

642
00:53:08,040 --> 00:53:12,960
და ეს იქნება დაიხევს მეშვეობით პროგრამა ხაზს.

643
00:53:12,960 --> 00:53:17,530
ასე, რომ თქვენ შეგიძლიათ უყუროთ როგორც რამ შეასრულოს, როგორც ცვლადებს ენის, როგორც რამ მიიღებთ განახლება.

644
00:53:17,530 --> 00:53:21,550
რომელიც საკმაოდ ლამაზი.

645
00:53:21,550 --> 00:53:26,570
სხვა cool რამ არის ვიდრე იმეორებს იმავე ბრძანების გამო და უსასრულოდ,

646
00:53:26,570 --> 00:53:30,670
თუ თქვენ უბრალოდ დააჭირეთ - აქ ხედავთ მე არ აკრეფილი არაფერი -

647
00:53:30,670 --> 00:53:33,780
თუ უბრალოდ დააჭიროთ, ის გაიმეოროს წინა ბრძანება,

648
00:53:33,780 --> 00:53:36,900
ან წინა GDB ბრძანება, რომ მე უბრალოდ დააყენა სისტემაში

649
00:53:36,900 --> 00:53:56,000
შემიძლია შენარჩუნება hitting შეიყვანეთ და ეს გავაგრძელებთ სტეპინგზე მეშვეობით ჩემი კოდი ხაზს.

650
00:53:56,000 --> 00:53:59,310
მინდა მოგიწოდებთ თქვენ ბიჭებს წასვლა შეამოწმეთ სხვა buggy პროგრამების ასევე.

651
00:53:59,310 --> 00:54:01,330
ჩვენ არ გვაქვს დრო, რომ მიიღოთ მეშვეობით ყველა მათგანი დღეს ნაწილში.

652
00:54:01,330 --> 00:54:05,890
კოდის არსებობს, ასე რომ თქვენ შეგიძლიათ სახის ხედავთ რა ხდება

653
00:54:05,890 --> 00:54:07,730
კულისებში თუ თქვენ გაქვთ დავრჩებოდით, ნამდვილად,

654
00:54:07,730 --> 00:54:11,940
მაგრამ სულ მცირე, უბრალოდ პრაქტიკაში ჩატვირთვისას up GDB,

655
00:54:11,940 --> 00:54:13,940
გაშვებული პროგრამის სანამ არღვევს თქვენ,

656
00:54:13,940 --> 00:54:18,260
მიღების backtrace, მჭიდროდაა გარეთ რა ფუნქცია ავარიის იყო,

657
00:54:18,260 --> 00:54:24,450
რა ხაზის ეს იყო, დაბეჭდვისას რამდენიმე ცვლადი ღირებულებებს,

658
00:54:24,450 --> 00:54:30,140
უბრალოდ, ასე რომ თქვენ მიიღოთ შეგრძნებას, რადგან, რომელიც ნამდვილად დაგეხმარებათ წინსვლის.

659
00:54:30,140 --> 00:54:36,340
ამ ეტაპზე, ჩვენ ვაპირებთ დატოვა გარეთ GDB, რომელიც თქვენ ჩვენგან გამოყენებით დატოვა ან უბრალოდ Q.

660
00:54:36,340 --> 00:54:40,460
თუ თქვენი პროგრამა შუა გაშვებული მაინც, და ეს არ იწურება ვადა,

661
00:54:40,460 --> 00:54:43,510
იგი ყოველთვის გკითხოთ, "დარწმუნებული ხართ რომ გინდათ გასვლა?"

662
00:54:43,510 --> 00:54:48,770
შეგიძლიათ უბრალოდ მოხვდა დიახ.

663
00:54:48,770 --> 00:54:55,250
>> ახლა ჩვენ ვაპირებთ შევხედოთ შემდეგი პრობლემა გვაქვს, რომელიც cat პროგრამა.

664
00:54:55,250 --> 00:54:59,880
თუ თქვენ უყურებთ მოკლე on გადამისამართება და მილები, დაინახავთ, რომ Tommy იყენებს ამ პროგრამას

665
00:54:59,880 --> 00:55:07,540
რომ ძირითადად ბეჭდავს ყველა გამოშვება ფაილი ეკრანზე.

666
00:55:07,540 --> 00:55:12,660
ასე რომ, თუ მე აწარმოებს კატა, ეს არის რეალურად ჩამონტაჟებული პროგრამის ელექტრო მოწყობილობების,

667
00:55:12,660 --> 00:55:16,860
და თუ თქვენ გაქვთ Macs ამისათვის თქვენს Mac ძალიან, თუ თქვენ გახსენით ტერმინალი.

668
00:55:16,860 --> 00:55:25,630
და ჩვენ - კატა, ასე ვთქვათ, cp.c, და დააჭიროთ.

669
00:55:25,630 --> 00:55:29,640
რა ეს ასე, თუ ჩვენ გადახვევა up ცოტა და ვნახოთ, სადაც ჩვენ გაიქცა ხაზი,

670
00:55:29,640 --> 00:55:40,440
ან თუ გაიქცა cat ბრძანება, ეს სიტყვასიტყვით უბრალოდ ამობეჭდილი შინაარსი cp.c ჩვენს ეკრანზე.

671
00:55:40,440 --> 00:55:44,140
ჩვენ შეგვიძლია გაუშვით ერთხელ და თქვენ შეგიძლიათ განათავსოთ რამდენიმე ფაილი ერთად.

672
00:55:44,140 --> 00:55:49,880
ასე რომ შეგიძლიათ გააკეთოთ cat cp.c და შემდეგ ჩვენ შეგვიძლია ასევე concatenate cat.c ფაილი,

673
00:55:49,880 --> 00:55:53,250
რაც პროგრამის ჩვენ შესახებ დაწერა,

674
00:55:53,250 --> 00:55:58,140
და ეს კიდე ბეჭდვა ორივე ფაილი თავში დაბრუნება ჩვენი ეკრანზე.

675
00:55:58,140 --> 00:56:05,490
ასე რომ, თუ ჩვენ გადახვევა up ცოტა, ჩვენ ვხედავთ, რომ როდესაც ჩვენ გაიქცა ამ cat cp.c, cat.c,

676
00:56:05,490 --> 00:56:17,110
პირველი ეს ამობეჭდილი CP ფაილი, ხოლო შემდეგ ქვემოთ, ეს ამობეჭდილი cat.c ფაილი უფლება ქვემოთ აქ.

677
00:56:17,110 --> 00:56:19,650
ჩვენ ვაპირებთ გამოვიყენოთ ეს უბრალოდ ფეხზე სველი.

678
00:56:19,650 --> 00:56:25,930
თამაში გარშემო მარტივი ბეჭდვის to ტერმინალი, ვნახოთ, როგორ მუშაობს, რომ.

679
00:56:25,930 --> 00:56:39,170
თუ ბიჭები გახსენით ერთად gedit cat.c, დააჭიროთ,

680
00:56:39,170 --> 00:56:43,760
ხედავთ პროგრამა, რომელიც ჩვენ შესახებ დაწერა.

681
00:56:43,760 --> 00:56:48,980
ჩვენ შედის ამ ლამაზი საქვაბე Plate, ამიტომ ჩვენ არ გვაქვს დროის გასატარებლად აკრეფის ყველა რომ.

682
00:56:48,980 --> 00:56:52,310
ჩვენ ასევე შეამოწმოს რაოდენობის არგუმენტები გაიარა სისტემაში

683
00:56:52,310 --> 00:56:56,910
ჩვენ ამობეჭდოთ ლამაზი გამოყენების გაგზავნა.

684
00:56:56,910 --> 00:57:00,950
>> ეს არის ერთგვარი, რაც, კიდევ ერთხელ, ისევე როგორც ჩვენ ვსაუბრობთ,

685
00:57:00,950 --> 00:57:04,490
ეს თითქმის ისევე, როგორც კუნთების მეხსიერება.

686
00:57:04,490 --> 00:57:07,190
უბრალოდ მახსოვს აკეთეთ იგივე სახის პერსონალი

687
00:57:07,190 --> 00:57:11,310
და ყოველთვის დაბეჭდვისას გარკვეული გამოსადეგი გაგზავნა

688
00:57:11,310 --> 00:57:17,670
ისე, რომ ადამიანმა იცის როგორ აწარმოებს თქვენი პროგრამის.

689
00:57:17,670 --> 00:57:21,630
With კატა, იგი საკმაოდ მარტივია, ჩვენ უბრალოდ აპირებს გავლა ყველა განსხვავებული არგუმენტები

690
00:57:21,630 --> 00:57:24,300
რომ გადაეცა ჩვენი პროგრამა, და ჩვენ ვაპირებთ ბეჭდვა

691
00:57:24,300 --> 00:57:29,950
მათი შინაარსის, რათა ეკრანზე ერთ დროს.

692
00:57:29,950 --> 00:57:35,670
იმისათვის, რომ ბეჭდვა ფაილი აღმოჩნდება ეკრანზე, ჩვენ ვაპირებთ, რომ რამე ძალიან ჰგავს

693
00:57:35,670 --> 00:57:38,120
თუ რა გავაკეთეთ დასასრულს ვიქტორინა.

694
00:57:38,120 --> 00:57:45,350
დასასრულს ვიქტორინა, რომ აყვანის პროგრამა, მოგვიწია გახსენით ფაილი,

695
00:57:45,350 --> 00:57:48,490
და მაშინ მოგვიწია ბეჭდვა მას.

696
00:57:48,490 --> 00:57:54,660
ამ შემთხვევაში, ჩვენ ვაპირებთ გახსენით ფაილი და ჩვენ ვაპირებთ წაკითხვის მაგივრად.

697
00:57:54,660 --> 00:58:00,630
მაშინ ჩვენ ვაპირებთ ბეჭდვა, ნაცვლად რომ ფაილი, ჩვენ ვაპირებთ ბეჭდვა ეკრანზე.

698
00:58:00,630 --> 00:58:05,830
ასე ბეჭდვას, რათა ეკრანზე თქვენ ყველა გაკეთდეს ადრე ერთად printf.

699
00:58:05,830 --> 00:58:08,290
ასე რომ ეს არ არის ძალიან გიჟები.

700
00:58:08,290 --> 00:58:12,190
მაგრამ კითხულობს ფაილი სახის უცნაური.

701
00:58:12,190 --> 00:58:17,300
ჩვენ გავლა, რომ ცოტა დროს.

702
00:58:17,300 --> 00:58:20,560
თუ ბიჭები დაბრუნდეს, რომ ბოლო პრობლემა თქვენს ვიქტორინა, პრობლემა 33,

703
00:58:20,560 --> 00:58:27,280
პირველი ხაზი, რომ ჩვენ ვაპირებთ აქ გახსნა ფაილი, ძალიან ჰგავს იმას, რაც გავაკეთეთ იქ.

704
00:58:27,280 --> 00:58:36,370
ამიტომ Stella, რას ხაზის ჰგავს, როდესაც ჩვენ გახსნა ფაილი?

705
00:58:36,370 --> 00:58:47,510
[Stella] Capital ფაილ *, ფაილი - >> Okay. >> - უდრის fopen. >> Yup.

706
00:58:47,510 --> 00:58:55,980
რაც ამ შემთხვევაში არის? ეს ოფიციალურ კომენტარში.

707
00:58:55,980 --> 00:59:06,930
>> ეს in კომენტარი? argv [i] და ს?

708
00:59:06,930 --> 00:59:11,300
>> ზუსტად. უფლება. ამიტომ Stella სრულიად უფლება.

709
00:59:11,300 --> 00:59:13,720
ეს არის ის, რაც ხაზს ჰგავს.

710
00:59:13,720 --> 00:59:19,670
ჩვენ ვაპირებთ, რომ მიიღოთ ფაილი ნაკადი ცვლადი, ჩაწეროთ იგი ფაილ *, ასე რომ ყველა caps,

711
00:59:19,670 --> 00:59:25,720
ი, *, და სახელი ამ ცვლადი იქნება ფაილი.

712
00:59:25,720 --> 00:59:32,250
ჩვენ შეგვეძლო ეძახით რასაც მოგვწონს. ჩვენ შეგვეძლო ეძახით first_file, ან file_i, რაც ჩვენ გვინდა.

713
00:59:32,250 --> 00:59:37,590
და მერე სახელით ფაილი არ იყო მიღებული ბრძანების სტრიქონში ამ პროგრამის.

714
00:59:37,590 --> 00:59:44,450
ამიტომ შენახული argv [i] და შემდეგ ჩვენ ვაპირებთ გახსნა ამ ფაილის წაკითხვის რეჟიმში.

715
00:59:44,450 --> 00:59:48,100
ახლა, როდესაც ჩვენ გახსნა ფაილი, რა საქმეა, რომ ჩვენ ყოველთვის უნდა გვახსოვდეს, რომ გააკეთოთ

716
00:59:48,100 --> 00:59:52,230
როდესაც ჩვენ გახსნა ფაილი? ვხურავთ მას.

717
00:59:52,230 --> 00:59:57,220
ამიტომ მისის, როგორ უნდა დახუროს ფაილი?

718
00:59:57,220 --> 01:00:01,020
[Missy] fclose (ფაილი) >> fclose (ფაილი). სწორედ.

719
01:00:01,020 --> 01:00:05,340
დიდი. Okay. თუ დავაკვირდებით ამ გავაკეთოთ კომენტარი უფლება აქ,

720
01:00:05,340 --> 01:00:11,940
იგი ამბობს: "ღია argv [i] და ბეჭდვა მისი შინაარსი უნდა stdout."

721
01:00:11,940 --> 01:00:15,460
>> სტანდარტული გარეთ არის უცნაური სახელი. Stdout მხოლოდ ჩვენი გზა ამბობდა

722
01:00:15,460 --> 01:00:22,880
ჩვენ გვინდა ბეჭდვა მას ტერმინალში, ჩვენ გვინდა ბეჭდვა მას სტანდარტულ output stream.

723
01:00:22,880 --> 01:00:26,450
ჩვენ შეგვიძლია რეალურად დავაღწიოთ ამ კომენტარის უფლება აქ.

724
01:00:26,450 --> 01:00:36,480
მე ვაპირებ კოპირება და ჩასვით წლიდან არის ის, რაც ჩვენ გავაკეთეთ.

725
01:00:36,480 --> 01:00:41,290
ამ ეტაპზე, ახლა უნდა წაიკითხოთ ფაილი ნელ bit.

726
01:00:41,290 --> 01:00:46,300
ჩვენ განვიხილეთ რამდენიმე გზები კითხულობს ფაილი.

727
01:00:46,300 --> 01:00:51,830
რაც პირობა არის თქვენი ფავორიტების აქამდე?

728
01:00:51,830 --> 01:00:57,960
რაც გზები გინახავთ ან არ გახსოვთ, წაკითხვის ფაილი?

729
01:00:57,960 --> 01:01:04,870
[დანიელ] fread? >> Fread? ამიტომ fread არის ერთი. ჯიმი, იცით რაიმე სხვები?

730
01:01:04,870 --> 01:01:12,150
[Jimmy] მდებარ >> Okay. Nope. Charlotte? ალექსანდრე? ნებისმიერი სხვები? Okay.

731
01:01:12,150 --> 01:01:20,740
ასე რომ სხვა პირობა არის fgetc, არის, რომ ჩვენ გამოვიყენოთ ლოტი.

732
01:01:20,740 --> 01:01:26,410
არსებობს ასევე fscanf, თქვენ ბიჭებს ვხედავ ნიმუში აქ?

733
01:01:26,410 --> 01:01:29,170
ისინი ყველა იწყება ვ. არაფერი არ უკავშირდება ფაილი.

734
01:01:29,170 --> 01:01:35,260
არსებობს fread, fgetc, fscanf. ეს არის ყველა კითხულობს ფუნქციები.

735
01:01:35,260 --> 01:01:49,120
წერა გვაქვს fwrite, ჩვენ გვაქვს fputc ნაცვლად fgetc.

736
01:01:49,120 --> 01:01:58,250
ჩვენ ასევე არ fprintf როგორც ჩვენ ვნახეთ on ვიქტორინა.

737
01:01:58,250 --> 01:02:01,680
რადგან ეს არის პრობლემა, რომელიც მოიცავს კითხულობს ფაილიდან,

738
01:02:01,680 --> 01:02:04,940
ჩვენ ვაპირებთ გამოვიყენოთ ერთი ამ სამი ფუნქციები.

739
01:02:04,940 --> 01:02:10,890
ჩვენ არ ვაპირებთ, გამოვიყენოთ ამ ფუნქციების ქვემოთ აქ.

740
01:02:10,890 --> 01:02:14,880
ეს ფუნქციები ყველა ნაპოვნი სტანდარტული I / O ბიბლიოთეკაში.

741
01:02:14,880 --> 01:02:17,510
ასე რომ, თუ თქვენ შეხედეთ ზევით ამ პროგრამის

742
01:02:17,510 --> 01:02:24,110
თქვენ ხედავთ, რომ ჩვენ უკვე შედის header ფაილი სტანდარტული I / O ბიბლიოთეკაში.

743
01:02:24,110 --> 01:02:27,120
თუ გვინდა, რომ გაერკვნენ, რომელიც ერთი ჩვენ გვინდა გამოვიყენოთ,

744
01:02:27,120 --> 01:02:29,690
ჩვენ შეგვიძლია ყოველთვის ქმნის კაცი გვერდებზე.

745
01:02:29,690 --> 01:02:34,350
ასე რომ ჩვენ შეგვიძლია აკრიფოთ კაცი stdio

746
01:02:34,350 --> 01:02:43,180
და წაიკითხეთ ყველაფერი stdio და ჩასათვლელი ფუნქციების C.

747
01:02:43,180 --> 01:02:49,870
და ჩვენ შეგვიძლია უკვე ვხედავთ OH, გამოიყურებოდეს. ეს მოხსენიების fgetc, ის ხსენებას fputc.

748
01:02:49,870 --> 01:02:57,220
ასე რომ თქვენ შეგიძლიათ საბურღი ქვემოთ ცოტა და შევხედოთ, ვთქვათ, fgetc

749
01:02:57,220 --> 01:03:00,060
და შეხედეთ მის კაცის გვერდზე.

750
01:03:00,060 --> 01:03:03,430
თქვენ ხედავთ, რომ მიდის ერთად მთელი bunch სხვა ფუნქციები:

751
01:03:03,430 --> 01:03:12,640
fgetc, fgets, getc, getchar, იღებს, ungetc და მისი შეყვანის პერსონაჟების და სიმებიანი.

752
01:03:12,640 --> 01:03:19,180
ასე რომ, ეს როგორ ვკითხულობთ გმირები და სიმებიანი ფაილიდან სტანდარტული input,

753
01:03:19,180 --> 01:03:21,990
რაც ძირითადად მომხმარებლის.

754
01:03:21,990 --> 01:03:24,780
სწორედ ასე ჩვენ გავაკეთებთ რეალურ C.

755
01:03:24,780 --> 01:03:30,850
ასე რომ, ეს არ იყენებს GetString და GetChar ფუნქციები

756
01:03:30,850 --> 01:03:36,840
რომ ჩვენ გამოიყენება CS50 ბიბლიოთეკაში.

757
01:03:36,840 --> 01:03:39,710
ჩვენ ვაპირებთ, რომ ეს პრობლემა რამდენიმე გზები

758
01:03:39,710 --> 01:03:43,430
ასე რომ თქვენ შეგიძლიათ ნახოთ ორი სხვადასხვა გზა ამის გაკეთება.

759
01:03:43,430 --> 01:03:48,490
ორივე fread ფუნქცია რომ დანიელ აღნიშნული და fgetc კარგი გზა გავაკეთეთ.

760
01:03:48,490 --> 01:03:53,790
ვფიქრობ fgetc არის პატარა ადვილია, რადგან იგი მხოლოდ აქვს, როგორც ხედავთ,

761
01:03:53,790 --> 01:03:59,660
ერთი არგუმენტი, ი * რომ ჩვენ წაკითხვის მცდელობისას ხასიათი,

762
01:03:59,660 --> 01:04:02,740
და მისი დაბრუნების ღირებულება int.

763
01:04:02,740 --> 01:04:05,610
და ეს არის პატარა დამაბნეველი, არა?

764
01:04:05,610 --> 01:04:11,450
>> იმის გამო, რომ ჩვენ ვიღებთ ხასიათი, რატომ არ ამ დაბრუნების char?

765
01:04:11,450 --> 01:04:18,700
თქვენ ბიჭები რაიმე იდეები რატომ ეს არ შეიძლება დაბრუნდეს char?

766
01:04:18,700 --> 01:04:25,510
[Missy პასუხები, გაუგებარია] >> Yeah. ამიტომ მისის სრულიად უფლება.

767
01:04:25,510 --> 01:04:31,570
თუ ეს ASCII, მაშინ ეს რიცხვი შეიძლება mapped to ფაქტობრივი char.

768
01:04:31,570 --> 01:04:33,520
შეიძლება ASCII ხასიათი, და ეს უფლება.

769
01:04:33,520 --> 01:04:36,220
სწორედ, რა ხდება.

770
01:04:36,220 --> 01:04:39,190
ჩვენ გამოყენებით int უბრალოდ რადგან მას უფრო მეტი ბიტი.

771
01:04:39,190 --> 01:04:44,750
ეს უფრო დიდია, ვიდრე char; ჩვენი char მხოლოდ 8 ბიტი, რომ 1 byte ჩვენს 32-bit მანქანები.

772
01:04:44,750 --> 01:04:48,520
და int აქვს ყველა 4 ბაიტი ღირებულების სივრცეში.

773
01:04:48,520 --> 01:04:50,940
და აღმოჩნდება, რომ გზა fgetc მუშაობს,

774
01:04:50,940 --> 01:04:53,940
თუ ჩვენ გადახვევა ქვემოთ ჩვენს მოკლე შინაარსი ამ კაცს გვერდზე ცოტა,

775
01:04:53,940 --> 01:05:05,000
გადახვევა ყველა გზა down. თურმე ისინი იყენებენ ამ მასივები მოუწოდა EOF.

776
01:05:05,000 --> 01:05:09,640
ეს სპეციალური მუდმივი როგორც დაბრუნების ღირებულება fgetc ფუნქცია

777
01:05:09,640 --> 01:05:14,570
როდესაც თქვენ მოხვდა ფაილის ბოლოში, ან თუ თქვენ გაქვთ შეცდომა.

778
01:05:14,570 --> 01:05:18,170
და აღმოჩნდება, რომ ამის გაკეთება ამ შედარებები ერთად EOF სწორად,

779
01:05:18,170 --> 01:05:24,060
გსურთ აქვს, რომ ზედმეტი რაოდენობით ინფორმაციას, რომ გაქვთ int

780
01:05:24,060 --> 01:05:28,420
როგორც ეწინააღმდეგებოდა გამოყენებით char ცვლადი.

781
01:05:28,420 --> 01:05:32,130
მიუხედავად იმისა, რომ fgetc ეფექტურად მიღების ხასიათი ფაილი,

782
01:05:32,130 --> 01:05:38,450
გსურთ გახსოვდეთ, რომ იგი ბრუნდება რაღაც რომ ტიპის int თქვენ.

783
01:05:38,450 --> 01:05:41,360
რომ განაცხადა, ეს საკმაოდ მარტივი.

784
01:05:41,360 --> 01:05:44,960
იგი აპირებს მოგვცეს ხასიათი, ამიტომ ყველა უნდა გავაკეთოთ არის შეინახოს ეკითხება ფაილი,

785
01:05:44,960 --> 01:05:48,440
"მომეცი შემდეგი ხასიათი, მომეცი შემდეგი ხასიათი, მომეცი შემდეგი ხასიათი,"

786
01:05:48,440 --> 01:05:51,400
სანამ არ მივიღებთ ბოლომდე ფაილი.

787
01:05:51,400 --> 01:05:54,730
და რომელიც გამოიყვანს ერთ ხასიათი დროს ჩვენი ფაილი,

788
01:05:54,730 --> 01:05:56,250
და შემდეგ შეგვიძლია გავაკეთოთ რასაც მოგვწონს იგი.

789
01:05:56,250 --> 01:06:00,160
ჩვენ შეგვიძლია ჩაწეროთ იგი, შეგვიძლია დაამატოთ ეს ტექსტი, ჩვენ შეგვიძლია ბეჭდვა იგი out.

790
01:06:00,160 --> 01:06:04,630
რაიმე რომ.

791
01:06:04,630 --> 01:06:09,600
>> Zooming უკან გარეთ და ბრუნდება ჩვენი cat.c პროგრამა,

792
01:06:09,600 --> 01:06:16,170
თუ ჩვენ ვაპირებთ გამოვიყენოთ fgetc,

793
01:06:16,170 --> 01:06:21,710
როგორ შეიძლება ჩვენ მივუდგეთ ამ შემდეგი ხაზი კოდი?

794
01:06:21,710 --> 01:06:26,020
ჩვენ ვაპირებთ გამოვიყენოთ - fread გააკეთებს რაღაც ოდნავ განსხვავებული.

795
01:06:26,020 --> 01:06:32,600
და ამ დროს, ჩვენ უბრალოდ აპირებს გამოიყენოს fgetc მისაღებად ერთი ხასიათი დროს.

796
01:06:32,600 --> 01:06:40,910
პროცესში მთელი ფაილი, თუ რა შეიძლება ჩვენ უნდა გავაკეთოთ?

797
01:06:40,910 --> 01:06:44,030
რამდენი სიმბოლოები იქ ფაილი?

798
01:06:44,030 --> 01:06:47,390
ბევრია. ასე, რომ თქვენ ალბათ გვინდა ერთი

799
01:06:47,390 --> 01:06:49,860
და მერე კიდევ სხვა და მიიღეთ საჩუქრად და მიიღეთ საჩუქრად.

800
01:06:49,860 --> 01:06:53,330
როგორი ალგორითმი ფიქრობთ, შეიძლება უნდა გამოვიყენოთ აქ?

801
01:06:53,330 --> 01:06:55,470
რა ტიპის -? [ალექსანდრე] ამისთვის loop? >> ზუსტად.

802
01:06:55,470 --> 01:06:57,500
ზოგიერთი ტიპის loop.

803
01:06:57,500 --> 01:07:03,380
ამისთვის loop ფაქტიურად დიდი, ამ შემთხვევაში.

804
01:07:03,380 --> 01:07:08,620
და თქვენნაირი ამბობდნენ, ეს ჟღერს გსურთ loop მთელ ფაილი,

805
01:07:08,620 --> 01:07:11,820
მიღების ხასიათი დროს.

806
01:07:11,820 --> 01:07:13,850
რაიმე შემოთავაზება, თუ რა შეიძლება, რომ ჰგავს?

807
01:07:13,850 --> 01:07:22,090
[ალექსანდრე, გაუგებარია]

808
01:07:22,090 --> 01:07:30,050
>> Okay, უბრალოდ მითხრათ ინგლისურ თუ რას ცდილობთ? [ალექსანდრე, გაუგებარია]

809
01:07:30,050 --> 01:07:36,270
ასე რომ, ამ შემთხვევაში, ეს ჟღერს ჩვენ უბრალოდ ვცდილობთ, მარყუჟის მთელ ფაილი.

810
01:07:36,270 --> 01:07:45,330
[ალექსანდრე] So I <ზომის int? >> ზომა -?

811
01:07:45,330 --> 01:07:49,290
ვფიქრობ ზომის ფაილი, არა? ზომა - we'll უბრალოდ დაწერა მოსწონს ეს.

812
01:07:49,290 --> 01:07:57,470
ზომა ფაილი ამ დროისათვის, მე + +.

813
01:07:57,470 --> 01:08:04,610
გამოდის, რომ გზა თქვენ ჩვენგან ამ გამოყენებით fgetc, და ეს არის ახალი,

814
01:08:04,610 --> 01:08:10,460
ის არის, რომ არ არსებობს მარტივი გზა უბრალოდ ზომის ფაილების

815
01:08:10,460 --> 01:08:16,979
ამ "sizeof" ტიპის მშენებლობას რომ თქვენ მინახავს ადრე.

816
01:08:16,979 --> 01:08:20,910
როდესაც ვიყენებთ ამ fgetc ფუნქცია, ჩვენ შემოღების გარკვეული სახის

817
01:08:20,910 --> 01:08:29,069
ახალი, ხმაურიანი სინტაქსი ამ for loop, სადაც ნაცვლად გამოყენებით მხოლოდ ძირითადი counter

818
01:08:29,069 --> 01:08:33,920
წასვლა ხასიათი ხასიათი, ჩვენ ვაპირებთ გაიყვანოს ერთი ხასიათი დროს,

819
01:08:33,920 --> 01:08:37,120
ერთი ხასიათი დროს, და გზა ვიცით ჩვენ დასასრულს

820
01:08:37,120 --> 01:08:41,290
არ არის, როდესაც ჩვენ დათვლილი გარკვეული რაოდენობის სიმბოლოებს,

821
01:08:41,290 --> 01:08:49,939
მაგრამ როდესაც ხასიათი ჩვენ გაიყვანოს ის არის, რომ სპეციალური ფაილის დასასრულს ხასიათი.

822
01:08:49,939 --> 01:08:58,689
ასე რომ ჩვენ შეგვიძლია გავაკეთოთ ეს მიერ - მოვუწოდებ ამ ch, და ჩვენ ვაპირებთ ინიციალიზაცია ეს

823
01:08:58,689 --> 01:09:08,050
ჩვენს პირველ ზარის მისაღებად პირველი ხასიათი გარეთ ფაილი.

824
01:09:08,050 --> 01:09:14,979
ასე რომ ამ ნაწილში სწორედ აქ, ამ აპირებს მიიღოს ხასიათი გარეთ ფაილი

825
01:09:14,979 --> 01:09:20,840
და ჩაწეროთ იგი შევიდა ცვლადი ch.

826
01:09:20,840 --> 01:09:25,420
ჩვენ ვაპირებთ აკეთეთ ამ სანამ არ მივიღებთ ბოლომდე ფაილი,

827
01:09:25,420 --> 01:09:41,170
რაც ჩვენ გავაკეთეთ მიერ ტესტირება ხასიათი არ ყოფნის ტოლფასია, რომ სპეციალური EOF ხასიათი.

828
01:09:41,170 --> 01:09:48,750
და შემდეგ ნაცვლად აკეთებს ch + +, რომელიც მხოლოდ წუთობრივი ღირებულება,

829
01:09:48,750 --> 01:09:52,710
ასე რომ, თუ ვკითხულობთ გარეთ ფაილი, კაპიტალის, ვთქვათ,

830
01:09:52,710 --> 01:09:56,810
CH + + რომ მოგვცეს B, და შემდეგ ჩვენ გვინდა კიდევ C და შემდეგ დ.

831
01:09:56,810 --> 01:09:59,310
სწორედ ნათლად არ არის რაც ჩვენ გვინდა. რა გვინდა აქ

832
01:09:59,310 --> 01:10:05,830
ამ ბოლო bit არის ჩვენ გვინდა შემდეგი ხასიათი ფაილი.

833
01:10:05,830 --> 01:10:09,500
>> ასე როგორ შეიძლება მივიღებთ შემდეგი ხასიათი ფაილი?

834
01:10:09,500 --> 01:10:13,470
როგორ მივიღებთ პირველ ხასიათი ფაილი?

835
01:10:13,470 --> 01:10:17,200
[სტუდენტური] fgetfile? >> Fgetc, ან, ბოდიში, თქვენ სრულიად უფლება.

836
01:10:17,200 --> 01:10:20,470
მე misspelled ეს უფლება არსებობს. ამიტომ yeah.

837
01:10:20,470 --> 01:10:26,240
აქ ნაცვლად აკეთებს ch + +,

838
01:10:26,240 --> 01:10:29,560
ჩვენ უბრალოდ ვაპირებ მოვუწოდო fgetc (ფაილი) ერთხელ

839
01:10:29,560 --> 01:10:39,180
და შესანახად შედეგი ჩვენს იმავე ch ცვლადი.

840
01:10:39,180 --> 01:10:43,730
[სტუდენტური კითხვაზე, გაუგებარია]

841
01:10:43,730 --> 01:10:52,390
>> ეს არის, სადაც ეს ფაილ * ბიჭები არიან სპეციალური.

842
01:10:52,390 --> 01:10:59,070
გზა ისინი მუშაობენ, რომ ისინი - როდესაც თქვენ პირველად გახსნა - როდესაც თქვენ პირველად მიიღოს, რომ fopen ზარი,

843
01:10:59,070 --> 01:11:04,260
ი * ეფექტურად ემსახურება როგორც მომცეთ დასაწყისში ფაილი.

844
01:11:04,260 --> 01:11:12,830
და შემდეგ ყოველ ჯერზე რეკავთ fgetc, ის მოძრაობს ერთი ხასიათი მეშვეობით ფაილი.

845
01:11:12,830 --> 01:11:23,280
ასე რომ როდესაც თქვენ დაარქვით, თქვენ დამატება ფაილის მაჩვენებელი ერთი ხასიათი.

846
01:11:23,280 --> 01:11:26,210
და როცა fgetc ერთხელ, თქვენ მოძრავი მას სხვა ხასიათის

847
01:11:26,210 --> 01:11:28,910
და კიდევ ერთი ხასიათი და სხვა ხასიათი და სხვა ხასიათი.

848
01:11:28,910 --> 01:11:32,030
[სტუდენტური კითხვაზე, გაუგებარია] >> And that's - Yeah.

849
01:11:32,030 --> 01:11:34,810
ეს ერთგვარი ამ ჯადოსნური ქვეშ hood.

850
01:11:34,810 --> 01:11:37,930
თქვენ უბრალოდ გააგრძელეთ დამატება საშუალებით.

851
01:11:37,930 --> 01:11:46,510
ამ ეტაპზე, თქვენ შეუძლია რეალურად მუშაობა ხასიათი.

852
01:11:46,510 --> 01:11:52,150
ასე როგორ შეიძლება ჩვენ ბეჭდვა ამ გარეთ ეკრანზე, ახლა?

853
01:11:52,150 --> 01:11:58,340
ჩვენ შეგვიძლია გამოვიყენოთ იგივე printf რამ, რომ ჩვენ გამოყენებული ადრე.

854
01:11:58,340 --> 01:12:00,330
რომ ჩვენ იყენებს ყველა სემესტრში.

855
01:12:00,330 --> 01:12:05,450
ჩვენ შეგვიძლია მოვუწოდებთ printf,

856
01:12:05,450 --> 01:12:21,300
და ჩვენ შეგვიძლია გაივლის წლის ხასიათი ისევე რომ.

857
01:12:21,300 --> 01:12:27,430
კიდევ ერთი გზა ამის გაკეთება არის ვიდრე გამოყენებით printf და მქონე ამის სტრიქონში,

858
01:12:27,430 --> 01:12:29,490
ჩვენ ასევე შეგიძლიათ ერთ სხვა ფუნქციებს.

859
01:12:29,490 --> 01:12:40,090
ჩვენ შეგვიძლია გამოვიყენოთ fputc, რომელიც ბეჭდავს ხასიათის ეკრანზე,

860
01:12:40,090 --> 01:12:52,580
გარდა თუ დავაკვირდებით fputc - ნება მომეცით დააშორებს ცოტა.

861
01:12:52,580 --> 01:12:56,430
ჩვენ ვხედავთ, რა ლამაზი არის სჭირდება in ხასიათი რომ ჩვენ წაიკითხა გამოყენებით fgetc,

862
01:12:56,430 --> 01:13:05,100
მაგრამ, ჩვენ უნდა მისცეს მას ნაკადი to ბეჭდვა.

863
01:13:05,100 --> 01:13:11,850
ჩვენ ასევე შეგიძლიათ putchar ფუნქცია, რომელიც დააყენა პირდაპირ სტანდარტულ out.

864
01:13:11,850 --> 01:13:16,070
ასე რომ მთელი bunch სხვადასხვა პარამეტრები, რომ ჩვენ შეგვიძლია გამოვიყენოთ ბეჭდვა.

865
01:13:16,070 --> 01:13:19,580
ისინი ყველა სტანდარტულ I / O ბიბლიოთეკაში.

866
01:13:19,580 --> 01:13:25,150
როდესაც გსურთ ბეჭდვა - ასე printf, ჩვეულებრივ, ხელს ბეჭდვა სპეციალური სტანდარტი გარეთ ნაკადი,

867
01:13:25,150 --> 01:13:27,910
რაც არის, რომ stdout.

868
01:13:27,910 --> 01:13:41,300
ასე რომ ჩვენ შეგვიძლია მხოლოდ ეხება, როგორც სახის ამ ჯადოსნური ღირებულება, stdout აქ.

869
01:13:41,300 --> 01:13:48,410
Oops. განათავსეთ მძიმით გარეთ.

870
01:13:48,410 --> 01:13:52,790
>> ეს არის ბევრი ახალი, ხმაურიანი ინფორმაციის აქ.

871
01:13:52,790 --> 01:13:58,600
ბევრი ეს ძალიან idiomatic, იმ გაგებით, რომ ეს კოდი

872
01:13:58,600 --> 01:14:05,700
რომ წერია ეს გზა მხოლოდ იმიტომ, რომ ეს სუფთა წასაკითხი, ადვილად წასაკითხი.

873
01:14:05,700 --> 01:14:11,520
არსებობს ბევრი სხვადასხვა გზა ამის გაკეთება, სხვადასხვა ფუნქციები შეგიძლიათ გამოიყენოთ,

874
01:14:11,520 --> 01:14:14,680
მაგრამ ჩვენ ტენდენცია უბრალოდ მიჰყევით ამ საერთო თარგების მეტი და მეტი.

875
01:14:14,680 --> 01:14:20,180
ასე რომ არ გაგიკვირდეთ, თუ ხედავთ კოდი მოსწონს ეს ახლოვდება ისევ და ისევ.

876
01:14:20,180 --> 01:14:25,690
ყველა უფლება. ამ ეტაპზე, ჩვენ გვჭირდება შესვენება დღეში.

877
01:14:25,690 --> 01:14:31,300
მადლობა მობრძანებისათვის. მადლობა თვალს თუ თქვენ შემოსული. ჩვენ დავინახავთ, თქვენ მომავალ კვირას.

878
01:14:31,300 --> 01:14:33,890
[CS50.TV]