1
00:00:00,000 --> 00:00:02,310
[Powered by Google Translate] [კვირა 4 გაგრძელდა]

2
00:00:02,310 --> 00:00:04,240
[დევიდ ჯ Malan - ჰარვარდის უნივერსიტეტი]

3
00:00:04,240 --> 00:00:07,290
[ეს არის CS50. - CS50.TV]

4
00:00:07,290 --> 00:00:11,290
>> ეს არის CS50, და ეს არის ბოლომდე კვირაში 4.

5
00:00:11,290 --> 00:00:14,030
ასე რომ ზოგიერთი კარგი ამბავია და ზოგიერთი ცუდი ამბავი.

6
00:00:14,030 --> 00:00:26,240
არარის ლექცია ორშაბათს, პრობლემა არ მითითებული მომავალ კვირას. [სტუდენტი cheering]

7
00:00:26,240 --> 00:00:28,680
თქვენ არ აპირებენ მინდა სადაც ეს ხდება.

8
00:00:28,680 --> 00:00:31,590
მაგრამ ჩვენ გვყავს ამ ნაცვლად შემდეგი ოთხშაბათი,

9
00:00:31,590 --> 00:00:37,740
და არსებობს ასევე თითო სილაბუსი 1 პარასკევი ლექცია შემდეგი პარასკევი, ისე, რომ ჩვენ შეგვიძლია დარჩენა გზაზე.

10
00:00:37,740 --> 00:00:40,580
მაგრამ ყველაფერი იქნება გადაღებული, როგორც ყოველთვის, ასე რომ არ ინერვიულოთ.

11
00:00:40,580 --> 00:00:44,100
>> და მიმართებაში Quiz 0 რასაც ჩვენ გავაკეთებთ მიმართ კვირის ბოლომდე

12
00:00:44,100 --> 00:00:47,140
არის საგუშაგო კურსი ვებგვერდი cs50.net განმარტება

13
00:00:47,140 --> 00:00:50,160
თუ რა სახის მოლოდინი უნდა ჰქონდეს, როდესაც საქმე პირველი ვიქტორინა.

14
00:00:50,160 --> 00:00:55,100
ზოგადად, ეს იქნება მრავალჯერადი არჩევანი, True-ცრუ, მოკლე პასუხი, მოკლე კოდირების პრობლემები.

15
00:00:55,100 --> 00:00:57,360
თქვენ არ აპირებენ უნდა განახორციელოს ექვივალენტი

16
00:00:57,360 --> 00:01:00,030
საქართველოს პრობლემა, რომ თქვენ ნახე pset, რისთვისაც თქვენ გაქვთ კომპიუტერი

17
00:01:00,030 --> 00:01:03,240
და debugger და მოსწონს, მაგრამ იქნება პატარა კოდირების პრობლემები.

18
00:01:03,240 --> 00:01:06,900
>> მართლაც, საუკეთესო სახელმძღვანელო მისაღებად გრძნობა რა CS50 ტესტები მოსწონს

19
00:01:06,900 --> 00:01:09,180
არის წასვლა cs50.net, წასვლა ტესტები ლინკები,

20
00:01:09,180 --> 00:01:11,920
და ხედავთ ბოლო რამდენიმე წლის განმავლობაში ღირებულების ვიქტორინებში.

21
00:01:11,920 --> 00:01:16,600
უბრალოდ გააცნობიეროს, რომ სასწავლო გეგმა არ ყოველთვის იგივე წლების განმავლობაში.

22
00:01:16,600 --> 00:01:18,510
ზოგჯერ ჩვენ დაამატოთ, ზოგჯერ სხვაობა,

23
00:01:18,510 --> 00:01:20,670
ასე რომ, თუ ხედავთ ზოგიერთ თემას ერთ იმ ძველ ტესტებში

24
00:01:20,670 --> 00:01:25,380
რომ თქვენ არ ვიცი რა ეს ლაპარაკი, ეს არც იყო ის, რომ დაფაროს იგი

25
00:01:25,380 --> 00:01:27,210
ან რომ ჩვენ არ დაფარავს მას.

26
00:01:27,210 --> 00:01:31,110
მაგრამ სახით მიმოხილვები, ამ კვირას, ორშაბათს, სამშაბათს და

27
00:01:31,110 --> 00:01:34,770
ასევე, რა თქმა უნდა, ფართო განხილვის სხდომაზე კვირა ღამე -

28
00:01:34,770 --> 00:01:37,500
დრო და ადგილი, რათა გამოცხადდება კურსი ვებგვერდი -

29
00:01:37,500 --> 00:01:40,120
თქვენ ყველას გვაქვს საშუალება განიხილოს ერთად საგნის სწავლების პრაქტიკის

30
00:01:40,120 --> 00:01:44,830
მასალა წელს, ორივე ნაწილში და როგორც სრული კლასის,

31
00:01:44,830 --> 00:01:48,400
და იმ იქნება გადაღებული, როგორც ყოველთვის ისევე.

32
00:01:48,400 --> 00:01:53,380
>> ყველა უფლება. ასე გარეშე ado, ერთი კომენტარი უღელტეხილზე / მარცხდება და დაამატოთ / Drop.

33
00:01:53,380 --> 00:01:57,980
თქვენ შეიძლება არ უნახავს ჩემი აღნიშნავს წუხელ, და ამ მართლაც რამოდენიმე დამატებითი reassurance

34
00:01:57,980 --> 00:02:01,250
რომ თუ თქვენ შორის არიან, განსაკუთრებით ნაკლებად კომფორტული ან სადღაც შორის

35
00:02:01,250 --> 00:02:04,870
და თქვენ შეგრძნება მხოლოდ ცოტა ზე მეტ თქვენი უფროსი,

36
00:02:04,870 --> 00:02:08,430
გააცნობიეროს, რომ მართლაც საკმაოდ ნორმალური, და იქ საკმარისი მხარდაჭერა სტრუქტურა ადგილი,

37
00:02:08,430 --> 00:02:13,530
რომელთაგან ერთი სამუშაო საათებში იყო განზრახვების გაუმჯობესების ყველა მეტი პოსტი ჩემი ელ წუხელ,

38
00:02:13,530 --> 00:02:16,520
და გააცნობიეროს, რომ ძალიან მოსწონს ვარიანტი უღელტეხილზე / ვერ ამისთვის კლასის მოსწონს

39
00:02:16,520 --> 00:02:21,540
ნამდვილად იგულისხმება როგორც მექანიზმი მიიღოს პირას გამორთვა კურსი მოსწონს,

40
00:02:21,540 --> 00:02:24,200
ისე, რომ ერთხელ თუ თქვენ ხარჯავს იმ 10, 15, 20 საათი

41
00:02:24,200 --> 00:02:28,160
უბრალოდ ცდილობს ზოგიერთი pset მუშაობა და თქვენ იცით, თქვენ 90-95% of გზა არსებობს

42
00:02:28,160 --> 00:02:32,100
მაგრამ ვერ პოულობთ ზოგიერთი Damn bug, in pass / fail მოდელი რომ სახის okay.

43
00:02:32,100 --> 00:02:36,230
>> იდეა არის, რომ ამ მექანიზმის შეგიძლიათ მერე ფოკუსირება თქვენი სხვა psets

44
00:02:36,230 --> 00:02:39,530
ან ძილის ან რასაც ის არის, რომ გსურთ ფოკუსირება.

45
00:02:39,530 --> 00:02:43,390
ასე რომ მიხვდებიან, რომ თქვენ გაქვთ სანამ ამ მოდის სამშაბათი - ტექნიკურად მე -5 კვირა,

46
00:02:43,390 --> 00:02:50,840
მაგრამ დღესასწაული, ასე რომ ამ მოდის სამშაბათი - გადართვა საწყისი უღელტეხილზე / ვერ ფასდება ან პირიქით.

47
00:02:50,840 --> 00:02:54,450
და თუ თქვენ ნამდვილად on precipice და ფიქრობენ ჩაშვების საერთოდ,

48
00:02:54,450 --> 00:02:56,440
გთხოვთ catch me შემდეგ ლექცია ან ვარდნა ჩემთვის შენიშვნა.

49
00:02:56,440 --> 00:02:59,990
მე მინდა მიყვარს მინიმუმ სტატისტიკა სანამ თქვან adieu.

50
00:02:59,990 --> 00:03:03,470
ყველა უფლება. ამიტომ, ჩვენ დავიწყე სასწავლო თვლები off ბოლო დროს.

51
00:03:03,470 --> 00:03:06,030
კერძოდ, ჩვენ ფოკუსირებული სიმებიანი.

52
00:03:06,030 --> 00:03:09,740
სიმებიანი არის ის, რასაც ის დეკლარირებული CS50 ბიბლიოთეკა,

53
00:03:09,740 --> 00:03:14,340
კერძოდ, რომ ფაილი სახელად cs50.h რომელიც დავიწყებთ შევხედოთ ამ კვირაში და მომავალი.

54
00:03:14,340 --> 00:03:17,250
მაგრამ string მართლაც მხოლოდ გამარტივებას რაღაც

55
00:03:17,250 --> 00:03:20,980
რომ ცოტა მეტი arcanely უწოდა char *.

56
00:03:20,980 --> 00:03:24,090
Char ჩვენ იცნობს. ეს მხოლოდ ერთი ხასიათი.

57
00:03:24,090 --> 00:03:28,010
მაგრამ * როგორც ორშაბათს აღნიშნა რა? >> [სტუდენტი] მაჩვენებელი.

58
00:03:28,010 --> 00:03:31,290
კურსორი. და რაც მაჩვენებელი? >> [სტუდენტი] მისამართზე.

59
00:03:31,290 --> 00:03:33,420
>> ეს მოსწონს მისამართი, საიდან მეხსიერებაში.

60
00:03:33,420 --> 00:03:35,910
რა მისამართი ან საიდან ან მეხსიერების?

61
00:03:35,910 --> 00:03:40,290
ერთხელ, ყველას უნდა გვქონდეს ლაპტოპები ერთად GIG ან 2 გბ ოპერატიული მეხსიერება, სავარაუდოდ, ამ დღეებში,

62
00:03:40,290 --> 00:03:44,160
და ეს ნიშნავს, რომ თქვენ გაქვთ მილიარდი ან 2 მილიარდი bytes ღირებულების მეხსიერება.

63
00:03:44,160 --> 00:03:46,240
და ეს ნამდვილად არ აქვს მნიშვნელობა, თუ რას ფიზიკურად ჰგავს,

64
00:03:46,240 --> 00:03:51,220
მაგრამ იღებს რწმენა, რომ თქვენ შეგიძლიათ ხმების ყველა ინდივიდუალური ბაიტი, რომ თქვენი საკუთარი ლეპტოპი აქვს -

65
00:03:51,220 --> 00:03:54,580
ეს არის byte 0, ეს არის byte 1, ეს არის byte 2 მლრდ -

66
00:03:54,580 --> 00:03:56,100
და ეს ზუსტად ის, რაც კომპიუტერში აკეთებს.

67
00:03:56,100 --> 00:04:00,030
როცა გამოყოფს ფართი ერთჯერადი ხასიათი, მაგალითად,

68
00:04:00,030 --> 00:04:02,480
ეს აშკარად აქვს ცხოვრება სადღაც თქვენი კომპიუტერის მეხსიერების,

69
00:04:02,480 --> 00:04:05,860
და შეიძლება უფრო დროს byte ნომერი 12345,

70
00:04:05,860 --> 00:04:08,470
და ეს სადღაც აქ თქვენს კომპიუტერის მეხსიერებაში.

71
00:04:08,470 --> 00:04:12,630
და მისამართი რა, რომ სიმბოლო არის 12345.

72
00:04:12,630 --> 00:04:16,140
>> ახლა კი, კვირაში 0 მეშვეობით არის ჯერჯერობით, ჩვენ ნამდვილად არ ზრუნავდა

73
00:04:16,140 --> 00:04:19,170
სადაც მეხსიერების რამ ინახება, რადგან ჩვენ, როგორც წესი, გამოიყენოთ სიმბოლოების,

74
00:04:19,170 --> 00:04:22,540
ცვლადები, და კოლექტორები რეალურად მიიღოთ ჩვენს მონაცემები.

75
00:04:22,540 --> 00:04:24,950
მაგრამ როგორც ორშაბათს და მით უფრო დღეს, თქვენ ახლა აპირებს

76
00:04:24,950 --> 00:04:27,710
ყველა უფრო ექსპრესიული შესაძლებლობების მქონე წერილობით პროგრამები

77
00:04:27,710 --> 00:04:31,330
ნამდვილად მანიპულირება კომპიუტერის მეხსიერების თუმცა ხედავთ ჯდება,

78
00:04:31,330 --> 00:04:33,720
ორივე კარგი მიზნებისთვის და ცუდი,

79
00:04:33,720 --> 00:04:39,620
bugs მყოფი ძალიან საერთო შედეგი ამ ეტაპზე სწავლის ამ პერსონალის.

80
00:04:39,620 --> 00:04:42,460
მაგრამ რას ნიშნავს იყოს char *?

81
00:04:42,460 --> 00:04:46,140
მოდით წავიდეთ წინ დაბრუნდა - და ჩვენ დაბრუნდება Binky დაპირებისამებრ დღეს.

82
00:04:46,140 --> 00:04:48,670
მოდით წასვლა უბრალო მაგალითი აქ.

83
00:04:48,670 --> 00:04:53,060
ნება მომეცით გადარჩენა ამ ფაილის როგორც compare.c, და ნება მომეცით უბრალოდ ზოგიერთი თარგი კოდი აქ

84
00:04:53,060 --> 00:05:00,490
ასე შეიცავს stdio.h, ნება მიბოძეთ, მისცეს თავს მოიცავს cs50.h. მე მიუახლოვდით up there.

85
00:05:00,490 --> 00:05:05,850
დავიწყებ წერილობით მთავარ int, მთავარი (void) და ახლა მინდა რაღაც ასე:

86
00:05:05,850 --> 00:05:13,520
printf ("მომეცი string:") და მერე გამოიყენებს string s იღებს GetString

87
00:05:13,520 --> 00:05:16,750
მიიღოს სიმებიანი საწყისი მომხმარებელი, მაშინ მე ვაპირებ ვკითხო მომხმარებლის კიდევ ერთი.

88
00:05:16,750 --> 00:05:21,870
("მომეცი სხვა სიმებიანი:") და მე ვაპირებ ვთხოვთ მეშვეობით GetString მისაღებად რომ.

89
00:05:21,870 --> 00:05:27,020
მე ეძახით t რადგან t უძღოდა წინ და წინ არის ლამაზი სახელი სიმებიანი თუ იგი საკმაოდ generic.

90
00:05:27,020 --> 00:05:30,030
ამიტომ GetString, და ახლა მინდა გააკეთოს საღი აზრის გამშვები და მე ვაპირებ ვთქვა

91
00:05:30,030 --> 00:05:39,770
თუ (ებ == t), მაშინ მე უბრალოდ აპირებს ვუთხრა მომხმარებლის printf ("თქვენ აკრეფილი იგივე \ n");

92
00:05:39,770 --> 00:05:45,520
სხვას მე ვაპირებ ამობეჭდოთ რაღაც ("თქვენ აკრეფილი რაღაც განსხვავებული, \ n")

93
00:05:45,520 --> 00:05:48,460
ან რასაც სასჯელი იქნება. ასე რომ რამე მაგდაგვარს.

94
00:05:48,460 --> 00:05:52,200
მაშინ, როგორც ყოველთვის, მე დაბრუნებას 0 რომელიც მხოლოდ გამორჩეულია, რომ არაფერი ცუდი მოხდა,

95
00:05:52,200 --> 00:05:54,400
და მე ვაპირებ წავიდეთ წინ და შეადგინონ და აწარმოებს ამ პროგრამის.

96
00:05:54,400 --> 00:05:56,540
>> მაგრამ ორშაბათს ჩვენ გაიქცა ამ პროგრამის

97
00:05:56,540 --> 00:06:00,420
და ფაქტობრივად უთხრეს, რომ HELLO არ არის HELLO და Goodbye არ არის Goodbye.

98
00:06:00,420 --> 00:06:03,140
ქცევის დავინახეთ იყო ცოტა უფრო მოსწონს ეს.

99
00:06:03,140 --> 00:06:11,450
ნება მომეცით წასვლას ჩემი წყაროს დირექტორია, მიუახლოვდით აქ და მოდით გავხადოთ შევადარებთ.

100
00:06:11,450 --> 00:06:14,570
შედგენილი okay. ნება მომეცით აწარმოებს შედარების. მომეცი string: Hello.

101
00:06:14,570 --> 00:06:16,300
მომეცი სხვა სიმებიანი: Hello.

102
00:06:16,300 --> 00:06:18,000
თქვენ აკრეფილი რაიმე განსხვავებული?

103
00:06:18,000 --> 00:06:22,650
ისე, ნება მომეცით ძიებასა მარტივი მოსწონს 50, 50. თქვენ აკრეფილი რაიმე განსხვავებული?

104
00:06:22,650 --> 00:06:25,740
hi, hi. ასე ნათლად, რაღაც ხდება აქ.

105
00:06:25,740 --> 00:06:28,440
მაგრამ რა იყო ახსნა, თუ რატომ?

106
00:06:28,440 --> 00:06:33,850
როგორც ჩანს, ხაზი 12 სრულიად დისფუნქციური.

107
00:06:34,300 --> 00:06:39,430
რა არის ფუნდამენტური პრობლემა აქ? Yeah. >> [სტუდენტი] ეს შედარება მისამართები.

108
00:06:39,430 --> 00:06:41,850
ჰო, ზუსტად. სინამდვილეში შედარებით მისამართები

109
00:06:41,850 --> 00:06:44,580
რომელშიც HELLO და HELLO ინახება.

110
00:06:44,580 --> 00:06:48,290
ეს არ შედარება წერილებს HELLO ისევ და ისევ,

111
00:06:48,290 --> 00:06:52,370
რადგან რა მოხდა სინამდვილეში, ყველა ამ დროს ჩვენ უკვე გამოყენებით GetString -

112
00:06:52,370 --> 00:06:56,130
ეს დაფა კვლავ ჩვენი კომპიუტერის მეხსიერებაში,

113
00:06:56,130 --> 00:07:00,100
და ვთქვათ მე მოვუწოდებ GetString გამოცხადების შემდეგ ცვლადი s.

114
00:07:00,100 --> 00:07:01,930
რას ჩემი მეხსიერების გამოიყურებოდეს?

115
00:07:01,930 --> 00:07:07,070
მოდით თვითნებურად ამბობენ, რომ ასე გამოიყურება. ეს მოედანი.

116
00:07:07,070 --> 00:07:09,040
და საკმაოდ ბევრი ნებისმიერ დროს მე შედგენილი ნაჭერი მეხსიერების ეკრანზე

117
00:07:09,040 --> 00:07:12,860
თუ 32 ბიტი მე ხატვის მოედნებზე მოსწონს რადგან ნამდვილად ელექტრო მოწყობილობების,

118
00:07:12,860 --> 00:07:17,380
მაჩვენებელი, მისამართი, არის 32 ბიტი. ეს იგივეა, რაც int.

119
00:07:17,380 --> 00:07:19,420
რომელიც შეიძლება განსხვავდებოდეს ეფუძნება კომპიუტერული სისტემა.

120
00:07:19,420 --> 00:07:24,630
იმ თქვენ, რომლებიც ბუნდოვნად იცნობს იმისა, რომ თქვენი Mac ან PC არის 64 ბიტი,

121
00:07:24,630 --> 00:07:28,120
რომ რეალურად ნიშნავს, რომ თქვენი კომპიუტერი იყენებს 64-bit პოინტერები,

122
00:07:28,120 --> 00:07:33,730
64-bit მისამართები, და შორის upsides რომ თქვენი კომპიუტერები

123
00:07:33,730 --> 00:07:35,560
შეიძლება გაცილებით მეტი RAM, ვიდრე yesteryear.

124
00:07:35,560 --> 00:07:39,240
დიდხანს ამბავი მოკლედ, უკან დღეს, როდესაც კომპიუტერები გამოიყენება მხოლოდ 32 ბიტი

125
00:07:39,240 --> 00:07:42,740
წარმოადგინოს მისამართები, ყველაზე დიდი რაოდენობის ბაიტი თქვენ შეიძლება წარმოადგენდეს

126
00:07:42,740 --> 00:07:46,280
ამ შემთხვევაში იყო რა, თუ თქვენ გაქვთ 32 ბიტიანი?

127
00:07:46,280 --> 00:07:49,590
ასე რომ 4 მილიარდი, უფლება, რადგან 2 დან 32 არის 4 მილიარდი.

128
00:07:49,590 --> 00:07:51,370
ეს რიცხვი უკვე განმეორებადი მსვლელობისას.

129
00:07:51,370 --> 00:07:55,240
>> ასე რომ, თუ თქვენ მხოლოდ 32 ბიტი, ყველაზე მეტი შეგიძლიათ ითვლიან რომ დაახლოებით 4 მილიარდი.

130
00:07:55,240 --> 00:07:58,750
მაგრამ ეს იყო ფუნდამენტური შეზღუდვის კომპიუტერები სანამ რამდენიმე წლის წინ

131
00:07:58,750 --> 00:08:01,180
რადგან თუ თქვენ მხოლოდ ითვლიან როგორც მაღალი, როგორც 4 მილიარდი,

132
00:08:01,180 --> 00:08:05,270
არა აქვს მნიშვნელობა თუ ყიდვა 8 გბ ოპერატიული ან თუნდაც 5 გბ ოპერატიული მეხსიერება;

133
00:08:05,270 --> 00:08:07,780
ვერ ითვლიან, რომ მაღალი, ასე რომ აზრი არ აქვს.

134
00:08:07,780 --> 00:08:11,430
თქვენ შეიძლება მხოლოდ წვდომას პირველი 3 ან 4 გბ თქვენი კომპიუტერის მეხსიერებაში.

135
00:08:11,430 --> 00:08:14,410
სწორედ ნაკლები საკითხი ახლა, და თქვენ შეგიძლიათ შეიძინოთ MacBook დადებითი და Dells

136
00:08:14,410 --> 00:08:17,680
, 8 გბ ოპერატიული მეხსიერება ან კიდევ უფრო ამ დღეებში.

137
00:08:17,680 --> 00:08:24,100
მაგრამ თუ მე გამოყოფს საკმაოდ უბრალოდ ამ პროგრამის მაჩვენებელი, კურსორი მოუწოდა s,

138
00:08:24,100 --> 00:08:28,370
ეს შესაძლოა ასე გამოიყურება ეკრანზე, რადგან მართლაც გვჭირდება კანი უკან ამ ფენას.

139
00:08:28,370 --> 00:08:33,520
მე შენარჩუნება ამბობდა სიმებიანი, მაგრამ როგორც ორშაბათს, string მართლაც char *,

140
00:08:33,520 --> 00:08:35,590
მისამართი ზოგიერთი ხასიათი.

141
00:08:35,590 --> 00:08:39,280
ასე რომ ავიღოთ, რომ სასწავლო საჭე off მიუხედავად იმისა, გავაგრძელებთ გამოყენებით GetString ახლა.

142
00:08:39,280 --> 00:08:42,600
ამიტომ მე განაცხადა s, და ეს არის ბლოკი მეხსიერება, 32 ბიტი.

143
00:08:42,600 --> 00:08:47,370
რა არის აქ მეხსიერებაში იყოს? >> [Inaudible სტუდენტი საპასუხოდ]

144
00:08:47,370 --> 00:08:50,040
რა არის ეს? >> [სტუდენტი] Garbage. >> Garbage. სწორედ.

145
00:08:50,040 --> 00:08:54,610
თუ პროგრამისტი არ დააყენა ღირებულების ცვლადი, ვინც იცის რა არის?

146
00:08:54,610 --> 00:08:57,990
ზოგჯერ თქვენ მიიღებთ გაუმართლა და ეს 0, რომელიც სახის ლამაზი, სუფთა, ნაგულისხმებია,

147
00:08:57,990 --> 00:09:00,310
მაგრამ როგორც დავინახეთ, ორშაბათს, ზოგჯერ ეს არაგონივრულია,

148
00:09:00,310 --> 00:09:04,130
ზოგიერთი მართლაც დიდი დადებითი ან უარყოფითი ხმების რომ მოვიდა აქ?

149
00:09:05,350 --> 00:09:07,010
Yeah. >> [სტუდენტი] ფუნქცია ადრე. >> Yeah.

150
00:09:07,010 --> 00:09:10,170
>> ხშირად ფუნქცია გაბმულ წინაშე წარსდგება, რადგან გახსოვთ,

151
00:09:10,170 --> 00:09:13,920
როგორც რეკავთ ფუნქციების მეხსიერება, მათ დასჭირდეს უფრო და უფრო სივრცეში bottom up,

152
00:09:13,920 --> 00:09:17,040
და როგორც კი ფუნქცია დააბრუნებს, რომ მეხსიერების იღებს reused

153
00:09:17,040 --> 00:09:20,890
მომდევნო ბიჭი რომ იღებს მოუწოდა, ვინც იყენებს თქვენს იგივე ნაჭერი მეხსიერება.

154
00:09:20,890 --> 00:09:23,450
და თუ თქვენ მარცხენა ნაგვის იქ, წინა ღირებულებები,

155
00:09:23,450 --> 00:09:28,190
ჩვენ შესაძლოა შეცდომა s როგორც გარკვეული ღირებულება, როდესაც ნამდვილად არ გვაქვს დააყენა არაფერი არსებობს.

156
00:09:28,190 --> 00:09:30,960
ასე რომ ჩვენი RAM ამ ეტაპზე ასე გამოიყურება.

157
00:09:30,960 --> 00:09:36,030
ახლა მარჯვენა მხარეს ხაზი 7 ჩვენ მოუწოდებდა GetString,

158
00:09:36,030 --> 00:09:40,150
რაც ჩვენ ვაკეთებთ არის კვირების განმავლობაში, მაგრამ რაც GetString მართლაც აკეთებს?

159
00:09:40,150 --> 00:09:43,350
GetString მიერ დაწერილი CS50 პერსონალი პატარა ინტელექტუალური

160
00:09:43,350 --> 00:09:46,500
in, რომ როგორც კი იწყება მომხმარებლის აკრეფით გასაღებები და hits Enter,

161
00:09:46,500 --> 00:09:50,010
GetString მოღვაწეები გარეთ რამდენი keystrokes გააკეთეს მომხმარებლის ჰიტი

162
00:09:50,010 --> 00:09:53,360
რამდენი გმირები მჭირდება გამოყოფს RAM for.

163
00:09:53,360 --> 00:09:55,660
და სად, რომ RAM მოდის, ვინ იცის?

164
00:09:55,660 --> 00:09:58,930
ეს სადღაც თქვენი კომპიუტერის 2 გბ ან whatnot მეხსიერება.

165
00:09:58,930 --> 00:10:05,200
მაგრამ დავუშვათ, რომ კომპიუტერი ნაპოვნია ფართი სიტყვა HELLO უფლება აქ.

166
00:10:05,200 --> 00:10:08,710
სიტყვა მე აკრეფილი იყო H-E-L-L-O.

167
00:10:08,710 --> 00:10:13,510
და თუ ჩვენ გავამახვილო ეს თანმიმდევრობა გმირები, ჩვენ შეიძლება შევაჩერო ეს მოსწონს ეს.

168
00:10:13,510 --> 00:10:17,860
მაგრამ მე უნდა გავაკეთოთ 1 ზედმეტი რამ. რა ეკუთვნის დასასრულს ნებისმიერი string დო?

169
00:10:17,860 --> 00:10:20,710
Null ხასიათი, რომელიც ჩვენ წერენ როგორც \ 0.

170
00:10:20,710 --> 00:10:23,980
ეს ტექნიკურად ნომერი 0, მაგრამ backslash იღებს ყველა ნათელი

171
00:10:23,980 --> 00:10:28,150
რომ ეს არის სიტყვასიტყვით ნომერი 0, მთელი 0;

172
00:10:28,150 --> 00:10:32,440
ეს არ მაგალითად, ციტირებით-unquote 0 რომ თქვენ შეიძლება აკრიფეთ კლავიატურაზე.

173
00:10:32,440 --> 00:10:33,940
ასე რომ, ეს არის Hello.

174
00:10:33,940 --> 00:10:36,350
>> და რა მივიღეთ ამბობენ ორშაბათს, რომ ფუნქცია, როგორიცაა GetString

175
00:10:36,350 --> 00:10:39,580
რეალურად დაბრუნების ყველა ამ კვირის?

176
00:10:39,580 --> 00:10:43,960
ეს არ დაბრუნების სიმებიანი თავისთავად იმიტომ, რომ ნამდვილად არ არ რაც იმას ნიშნავს,

177
00:10:43,960 --> 00:10:47,710
რადგან სტრიქონები არ არსებობს. ისინი სახის ფაბრიკაცია წელს CS50 ბიბლიოთეკაში.

178
00:10:47,710 --> 00:10:51,300
რა არის მართლაც სიმებიანი, უფრო ტექნიკურად? >> [სტუდენტი] ის პირველი ხასიათი.

179
00:10:51,300 --> 00:10:55,950
სწორედ. ეს საკმაოდ უბრალოდ მისამართი პირველ სიმბოლოს, რომ მომხმარებლის აკრეფილი შემოსული

180
00:10:55,950 --> 00:11:02,810
ასე რომ, თუ ჩემი სიტყვა HELLO დამთავრდა ეს up at byte ნომერი 123, ხოლო შემდეგ byte ნომერი 124,

181
00:11:02,810 --> 00:11:08,320
125, 126 და ა.შ. თუ უბრალოდ ხმების ჩემი bytes საწყისი 0 on up,

182
00:11:08,320 --> 00:11:12,650
რა GetString ბრუნდება არის სიტყვასიტყვით ნომერი 123.

183
00:11:12,650 --> 00:11:19,270
მერე რა ხდება დასვა s არის ნომერი 123, არ Letter H, არ სიტყვას Hello,

184
00:11:19,270 --> 00:11:23,130
უბრალოდ მისამართი სადაც შემიძლია მის შესახებ პირველი წერილი Hello.

185
00:11:23,130 --> 00:11:26,500
მაგრამ ეს არ ჩანს, როგორიც არის საკმარისი. ვკითხე თქვენ ტექსტი, არ ხასიათი.

186
00:11:26,500 --> 00:11:32,970
ასე როგორ უნდა ან კომპიუტერი იციან, რომ ELLO სახის მოდის ერთად H?

187
00:11:35,760 --> 00:11:37,460
რა სახის ხელშეკრულება გვაქვს? Yeah.

188
00:11:37,460 --> 00:11:40,100
[სტუდენტი] ეს ინახავს ვეუბნებოდი თავს გამოძებნოს მეტი სიმბოლო. >> ზუსტად.

189
00:11:40,100 --> 00:11:44,570
>> არსებობს ამ ადამიანის კომპიუტერი კონვენცია, რომლის დროსაც, როცა საქმე გვაქვს სიმები,

190
00:11:44,570 --> 00:11:49,410
სხვაგვარად ცნობილია როგორც char ვარსკვლავი, თქვენ უბრალოდ უნდა გაერკვნენ

191
00:11:49,410 --> 00:11:54,350
სადაც ყოველი სტრიქონი ცხოვრების მიერ ნამდვილად უბრალოდ iterating მეტი იგი ამისთვის მარყუჟის,

192
00:11:54,350 --> 00:11:57,820
ხოლო მარყუჟის, რაც, ასე რომ, როდესაც თქვენ იპოვით ბოლოს სიმებიანი

193
00:11:57,820 --> 00:12:02,160
ახლა თქვენ შეგიძლიათ infer ამისა, OH, მთლიანი სიტყვის იყო Hello.

194
00:12:02,160 --> 00:12:04,820
იმ თქვენ წინასწარი პროგრამირების გამოცდილება შეიძლება ვიცი ჯავაში

195
00:12:04,820 --> 00:12:09,880
შეგიძლიათ უბრალოდ ვუწოდებთ. სიგრძე და სხვა ენებზე შეგიძლიათ დარეკოთ სიგრძე ან მსგავსი.

196
00:12:09,880 --> 00:12:14,060
ეს იმიტომ, რომ წელს ბევრი ენების, განსაკუთრებით რამ მოუწოდა ობიექტის ორიენტირებული ენებზე,

197
00:12:14,060 --> 00:12:18,580
სიგრძეზე რაღაც სახის encapsulated შიგნით ნაჭერი მონაცემები თავისთავად,

198
00:12:18,580 --> 00:12:24,000
ჰგავს ჩვენ encapsulated პირადობის მოწმობა და სახელები და სახლები შიგნით სტუდენტი ორშაბათს.

199
00:12:24,000 --> 00:12:28,700
მაგრამ C გაცილებით დაბალია დონეზე. არ არსებობს ობიექტების ან კლასი, თუ მოვისმინე იმ თვალსაზრისით ადრე.

200
00:12:28,700 --> 00:12:31,490
ყველაფერი რაც თქვენ ნამდვილად არის მეხსიერების მისამართები.

201
00:12:31,490 --> 00:12:35,540
ასე რომ, ეს არის ერთგვარი მოძველებული გზა წარმოადგენს საინტერესო მონაცემები სტრუქტურებში.

202
00:12:35,540 --> 00:12:38,760
თქვენ გაქვთ დაწყება ღირებულება, როგორიცაა მისამართი პირველ სიმბოლოს

203
00:12:38,760 --> 00:12:42,340
და შემდეგ რამოდენიმე თვითნებური კონვენციის რომ ყველას თანახმაა დაიცვას.

204
00:12:42,340 --> 00:12:46,420
მაშ როგორ არის სიმებიანი სიგრძე განხორციელდა, საერთოდ გთავაზობთ?

205
00:12:46,420 --> 00:12:51,360
Strlen, strlen, რომელიც ზოგიერთ თქვენგანს არის გამოყენებული რამდენჯერმე. ეს საკმაოდ მარტივია, არა?

206
00:12:51,360 --> 00:12:53,060
ეს მოსწონს 2 ხაზი კოდი.

207
00:12:53,060 --> 00:12:56,140
ეს საკმაოდ ბევრი ამისთვის loop რაიმე სახის, იქნებ ერთად დამატებით ადგილობრივი ცვლადი.

208
00:12:56,140 --> 00:13:00,540
მაგრამ strlen უბრალოდ უნდა მიიღოს მაჩვენებელი და შემდეგ დაიწყოს ეძებს \ 0.

209
00:13:00,540 --> 00:13:05,190
>> და როგორც კი ეს უჭირს, მას შეუძლია დაბრუნდეს საერთო რაოდენობის ნაბიჯები, რომ ის მიღებული, რომ სიმებიანი.

210
00:13:05,190 --> 00:13:07,150
ასე რომ ჩვენ შეგვიძლია infer ამ რა მიდის შემდეგი.

211
00:13:07,150 --> 00:13:11,850
დავუშვათ, მაშინ ვაცხადებ t როგორც მე ვაკეთებ სტრიქონში 10.

212
00:13:11,850 --> 00:13:14,280
ეს არის ზოგიერთი ნაგვის ღირებულება. ვინ იცის პირველ რიგში?

213
00:13:14,280 --> 00:13:18,490
მაგრამ მარჯვენა მხარეს ხაზი 10 მე მოუწოდებდა GetString ერთხელ.

214
00:13:18,490 --> 00:13:20,050
ვინ იცის, სადაც ეს მთავრდება?

215
00:13:20,050 --> 00:13:23,830
მოდით თვითნებურად ამბობენ, რომ ოპერაციული სისტემის ნაპოვნი ოთახი მას გზა მეტი აქ.

216
00:13:23,830 --> 00:13:28,610
მე მოხდეს ერთსა აკრიფოთ H-E-L-L-O ერთხელ,

217
00:13:28,610 --> 00:13:31,260
და ასე შეგვიძლია დავხატოთ იგივე სურათს.

218
00:13:31,260 --> 00:13:34,290
მაგრამ ის ფაქტი, რომ მე redrawn ამ სურათის მიზანმიმართული

219
00:13:34,290 --> 00:13:37,720
რადგან ეს სხვადასხვა HELLO, ვიდრე ეს ერთი.

220
00:13:37,720 --> 00:13:43,920
ასე რომ აქ ეს შეიძლება იყოს საიდან 456, ეს 457 და სხვ.

221
00:13:43,920 --> 00:13:47,170
მერე რა ხდება დააყენოს სადაც კითხვის ნიშნის ერთხელ იყო?

222
00:13:47,170 --> 00:13:50,190
ამ შემთხვევაში 456.

223
00:13:50,190 --> 00:13:53,540
ჩვენ კრეფა ამ ნომრებზე თვითნებურად, რადგან მართლაც შემდეგ დღეს

224
00:13:53,540 --> 00:13:57,110
ჩვენ არ ვაპირებთ ზრუნვა იმდენად იმაზე, თუ რა მისამართი არაფერი არის.

225
00:13:57,110 --> 00:14:02,690
ყველა ჩვენ აღელვებს ის არის, რომ ჩვენ შეგვიძლია გაერკვნენ მისამართი ზოგიერთი ნიმუში მონაცემები, როგორიცაა Hello.

226
00:14:02,690 --> 00:14:07,100
>> ასე ნამდვილად რა საუკეთესო ხალხი კომპიუტერულ მეცნიერებაში, როდესაც საუბარია მეხსიერების მისამართები

227
00:14:07,100 --> 00:14:10,210
და ვსაუბრობთ პოინტერები კონკრეტულად,

228
00:14:10,210 --> 00:14:14,220
ვიდრე გადაიტვირთოთ მჭიდროდაა გარეთ 123 - ვის რაში სადაც ეს პერსონალის ფაქტობრივად,

229
00:14:14,220 --> 00:14:17,440
ჩვენ უბრალოდ ვიცით, რომ ეს არის რაღაც რიცხვითი მისამართი -

230
00:14:17,440 --> 00:14:22,180
ჩვენ გამარტივება მსოფლიოში და უბრალოდ, ვამბობთ, რომ არის მიუთითებს, რომ ხასიათი

231
00:14:22,180 --> 00:14:25,080
და t არის მიუთითებს, რომ ხასიათი.

232
00:14:25,080 --> 00:14:27,430
და ის ფაქტი, რომ arrow საკმაოდ განზრახ

233
00:14:27,430 --> 00:14:31,610
რადგან სიტყვასიტყვით არის s არის მიუთითებს H და t არის მიუთითებს სხვა H

234
00:14:31,610 --> 00:14:34,720
იმიტომ, დღის ბოლოს, არა აქვს მნიშვნელობა, თუ რა მისამართი,

235
00:14:34,720 --> 00:14:40,240
მაგრამ ჯერ ამ საკითხზე, რომ გვაქვს შესაძლებლობა გამოთქვას, რომ მისამართი ზოგიერთი ნაჭერი კოდი.

236
00:14:40,240 --> 00:14:42,730
ჩვენ ნამდვილად არ მანიპულირება ამ მისამართებისათვის მხოლოდ ჯერჯერობით

237
00:14:42,730 --> 00:14:47,770
ამიტომ ჩვენ დავინახავთ, სადაც შეგვიძლია interject და სახის გავაკეთოთ რამ ერთად პოინტერები,

238
00:14:47,770 --> 00:14:52,030
მაგრამ ახლა სტრიქონში 12 სიტყვასიტყვით რა ღირებულებები ჩვენ შედარება

239
00:14:52,030 --> 00:14:55,500
შესაბამისად ეს ამბავი ხაზი 12?

240
00:14:56,570 --> 00:15:01,290
ჩვენ ვამბობთ, არის 123 თანაბარი ტოლია 456? და ეს ნამდვილად არ არის.

241
00:15:01,290 --> 00:15:05,320
და მაშინაც კი, კონცეპტუალურად, ეს მაჩვენებელი ნამდვილად არ არის იგივე როგორც ამ

242
00:15:05,320 --> 00:15:09,500
იმიტომ, რომ თქვენ მოუწოდა GetString ორჯერ, და GetString არ ცდილობს იყოს სუპერ ჭკვიანი,

243
00:15:09,500 --> 00:15:12,470
იგი არ ცდილობს გააცნობიეროს, OH, თქვენ აკრეფილი HELLO 5 წუთის წინ;

244
00:15:12,470 --> 00:15:15,090
ნება მიბოძეთ მოგცემთ იგივე მაჩვენებელი როგორც მივეცი თქვენ წინაშე,

245
00:15:15,090 --> 00:15:18,450
უბრალოდ გამოყოფს ახალი ბლოკი მეხსიერება ყოველ დროს, თქვენ ეძახით.

246
00:15:18,450 --> 00:15:20,350
>> ასე როგორ უნდა დაფიქსირება ამ პრობლემას?

247
00:15:20,350 --> 00:15:24,270
თუ მაღალ დონეზე მინდა შედარების სიმები HELLO და HELLO -

248
00:15:24,270 --> 00:15:28,680
მე არ აინტერესებს პოინტერები - როგორ წავიდეთ შესახებ შეკითხვაზე,

249
00:15:28,680 --> 00:15:31,980
საერთოდ მომხმარებლის აკრიფოთ იგივე? რა არის საჭირო აქ? Yeah.

250
00:15:31,980 --> 00:15:35,200
[სტუდენტი] გამოიყენეთ ფუნქცია. >> შემიძლია ფუნქციის გარეთ ყუთში.

251
00:15:35,200 --> 00:15:38,170
შემიძლია ფუნქცია მოუწოდა strcmp, s-t-R-C-M-P,

252
00:15:38,170 --> 00:15:41,190
უბრალოდ შემოკლებულ ვერსია ამბობდა სიმებიანი შევადარებთ.

253
00:15:41,190 --> 00:15:45,070
და თუ ჩვენ წასვლას, მაგალითად, შევადაროთ 2, რომელიც არის შორის დღევანდელ ირჩენენ,

254
00:15:45,070 --> 00:15:46,690
ვაკეთებ ზუსტად რომ.

255
00:15:46,690 --> 00:15:51,750
მე ინახება ყველაფერი იგივე დარგობრივ 1 წლის ქვემოთ 26 ან იმდენად,

256
00:15:51,750 --> 00:15:54,360
და ახლა შეამჩნია ამ ნაწილში შეიცვალა მხოლოდ ცოტა.

257
00:15:54,360 --> 00:15:57,690
მოდით იგნორირება ხაზი 28 ერთი წუთით და ფოკუსირება მხოლოდ ამ ერთ.

258
00:15:57,690 --> 00:16:00,410
რა ვამბობთ, რომ ორშაბათს ქ შეადარეთ აკეთებს?

259
00:16:00,410 --> 00:16:05,200
ეს სახელურები პროცესში აღების 2 პოინტერები, S და T ამ შემთხვევაში,

260
00:16:05,200 --> 00:16:08,480
სახის პრაქტიკულად აყენებს მისი თითის იმ 2 ასოს,

261
00:16:08,480 --> 00:16:11,530
და რა უნდა გავაკეთოთ არის რაღაც ხოლო მარყუჟი ან ამისთვის მარყუჟის,

262
00:16:11,530 --> 00:16:16,050
და ეს ამბობს ეს იგივე? თუ ასეა, ეს მოძრაობს თითების ან პოინტერები ნაბიჯია.

263
00:16:16,050 --> 00:16:17,970
ეს იგივე, ეს იგივე, ეს იგივე,

264
00:16:17,970 --> 00:16:22,710
ამ იგივე, ეს იგივე? და Ooh, მე დასასრულს სიმებიანი ორივე და ტ.

265
00:16:22,710 --> 00:16:26,780
მე არ ი რაიმე წინააღმდეგობები. დიახ, ეს სტრიქონები არის იგივე.

266
00:16:26,780 --> 00:16:31,940
და რას ქ შედარების დაბრუნების თუ 2 სიმები არის იგივე, როგორც ჩანს? ნულოვანი.

267
00:16:31,940 --> 00:16:35,900
ასე რომ 0 არის კარგი ამ შემთხვევაში, რადგან თუ ის დააბრუნებს -1 ან +1,

268
00:16:35,900 --> 00:16:40,560
რაც იმას ნიშნავს, რომ რაღაც მოვა ადრე t ალფავიტის ან შემდეგ ტ.

269
00:16:40,560 --> 00:16:43,760
და რატომ უნდა, რომ იყოს სასარგებლო ჰქონდეს ფუნქცია რომ გიჩვენებთ რომელიც სიმებიანი მოდის ადრე

270
00:16:43,760 --> 00:16:46,720
ან შემდეგ წელს ლექსიკონი?

271
00:16:46,720 --> 00:16:48,740
[სტუდენტი] Searching. >> ძიება და დახარისხება.

272
00:16:48,740 --> 00:16:51,730
>> ასე რომ შეგიძლიათ გააკეთოთ რამ, როგორიცაა ბინარული ძებნის ან bubble sort ან შერწყმის დალაგება

273
00:16:51,730 --> 00:16:53,230
სადაც თქვენ უნდა შეადაროთ რამ.

274
00:16:53,230 --> 00:16:56,420
ჯერჯერობით ჩვენ სახის მოჭრილი ზოგიერთი კუთხეების და მხოლოდ ისაუბრა დახარისხება

275
00:16:56,420 --> 00:16:59,430
კონტექსტში ციფრები იმიტომ რომ ლამაზი და ადვილი ლაპარაკი,

276
00:16:59,430 --> 00:17:02,430
მაგრამ შეგიძლიათ შეადაროთ, რა თქმა უნდა სიმები, ვაშლის და ბანანის,

277
00:17:02,430 --> 00:17:05,349
რადგან თუ ვაშლის ცნობილია მოსვლა ადრე ბანანის, ანალოგიურად,

278
00:17:05,349 --> 00:17:09,319
შეგიძლიათ გადაადგილება სიმები გარშემო მეხსიერების ისევე რობ შემოიერთა შერწყმა დალაგების წელს ვიდეო

279
00:17:09,319 --> 00:17:15,880
და ჩვენ აქ სცენაზე სელექციაში დახარისხების, Insertion დალაგების, და ბუშტი ჯიშია.

280
00:17:15,880 --> 00:17:18,710
ისე სად სხვაგან შეგვიძლია ამ? მოდით ცდილობენ ამ.

281
00:17:18,710 --> 00:17:23,980
მოდით სახის დაგვავიწყდეს, რომ გაკვეთილი მომენტში და ცდილობენ ეხლა და დააკოპირეთ 1.c გავაკეთოთ შემდეგი.

282
00:17:23,980 --> 00:17:26,800
შეესაბამება 21 მე ვამბობ, ბეჭდვითი რაღაც,

283
00:17:26,800 --> 00:17:28,520
მაშინ მე მიღების string საწყისი მომხმარებელი,

284
00:17:28,520 --> 00:17:30,690
მაშინ მე შემოწმების ამ.

285
00:17:30,690 --> 00:17:33,620
ჩვენ ნამდვილად არ მიღებული ამ ჩვევა არ არის, მაგრამ მოდით, ახლა ამის გაკეთება.

286
00:17:33,620 --> 00:17:40,990
მოდით რეალურად კანი უკან ამ ფენას. ეს მართლაც char *. ეს ბიჭი მართლაც char *.

287
00:17:40,990 --> 00:17:45,690
ასე რომ რას ნიშნავს უნდა შემოწმების თუ == NULL?

288
00:17:45,690 --> 00:17:48,380
თურმე როცა რეკავთ ფუნქცია, როგორიცაა GetString

289
00:17:48,380 --> 00:17:51,540
ან საერთოდ ჰკითხეთ კომპიუტერი გადმოგცეთ გარკვეული მეხსიერება,

290
00:17:51,540 --> 00:17:53,030
რაღაც ვერ არის წესრიგში.

291
00:17:53,030 --> 00:17:56,630
თქვენ შეიძლება გიჟები და ვთხოვ კომპიუტერში terabyte მეხსიერების

292
00:17:56,630 --> 00:18:01,780
მიერ ითხოვენ trillions ბაიტების მეხსიერების რომ უბრალოდ არ არსებობს კომპიუტერი,

293
00:18:01,780 --> 00:18:05,130
მაგრამ GetString და სხვა ფუნქციების დაგვჭირდება გარკვეული გზა yelling at თქვენ

294
00:18:05,130 --> 00:18:06,820
თუ თქვენ სთხოვა ძალიან ბევრი.

295
00:18:06,820 --> 00:18:10,450
და გზა GetString აკეთებს ეს თუ არ ითხოვა მეტი მეხსიერების

296
00:18:10,450 --> 00:18:14,250
ვიდრე შესაძლებელია კომპიუტერის, თუნდაც რომ სუპერ, სუპერ დაბალი ალბათობა

297
00:18:14,250 --> 00:18:17,730
ვინაიდან არცერთ us ვაპირებთ აკრიფოთ ტრილიონი გმირები და შემდეგ დააჭიროთ,

298
00:18:17,730 --> 00:18:21,980
მაგრამ დაბალი ალბათობით, თუმცა არ უნდა იყოს, მე მაინც გვინდა შევამოწმოთ იგი მხოლოდ იმ შემთხვევაში,

299
00:18:21,980 --> 00:18:26,120
და სპეციალური მნიშვნელობა, რომელიც GetString, პასუხი, და სხვა ფუნქციების ბრუნდება

300
00:18:26,120 --> 00:18:30,630
თუ რამე წავიდა არასწორი არის NULL ყველა Caps.

301
00:18:30,630 --> 00:18:36,520
>> და რა არის NULL? NULL მხოლოდ ასე ხდება წარმოადგინოს მაჩვენებელი. ეს მეხსიერების მისამართი 0.

302
00:18:36,520 --> 00:18:40,800
მსოფლიოს გადაწყდა, რომ თვითნებურად, თუ ეს ჩემი კომპიუტერის მეხსიერებაში - იცით რა? -

303
00:18:40,800 --> 00:18:46,260
ჩვენ ვაპირებთ მოიპაროს მხოლოდ 1 byte ყოველი კომპიუტერის მეხსიერებაში, და ეს საიდან 0.

304
00:18:46,260 --> 00:18:49,560
ჩვენ ვაპირებთ მისცეს მას მეტსახელად NULL, და ჩვენ ვაპირებთ გპირდებით

305
00:18:49,560 --> 00:18:52,660
რომ ჩვენ არასოდეს რეალურად დააყენა რეალური მონაცემები არ არსებობს

306
00:18:52,660 --> 00:18:56,770
იმიტომ, რომ ჩვენ უბრალოდ თვითნებურად სჭირდებათ განსაკუთრებული ღირებულება, 0, aka NULL,

307
00:18:56,770 --> 00:19:00,230
ასე, რომ ჩვენ შეგვიძლია დაწეროთ საათზე მომხმარებლებს თუ რაღაც მიდის არასწორი.

308
00:19:00,230 --> 00:19:03,590
წინააღმდეგ შემთხვევაში თქვენ შეიძლება არ ვიცი ამჯამად 0 ნიშნავს დააყენა რაღაც აქ

309
00:19:03,590 --> 00:19:05,490
ან ნიშნავს რაღაც წავიდა არასწორი?

310
00:19:05,490 --> 00:19:09,190
ჩვენ უნდა ყველა თვლის, რომ NULL არაფერს ნიშნავს იყო დაბრუნებული,

311
00:19:09,190 --> 00:19:11,700
არ ფაქტობრივი მისამართი დააბრუნეს.

312
00:19:11,700 --> 00:19:15,210
ახლა, აქ მე უბრალოდ მიღების ჩემს ადამიანურ კონვენციის მე დაბრუნდნენ 1 მთავარი

313
00:19:15,210 --> 00:19:17,040
თუ რამე მიდის არასწორი.

314
00:19:17,040 --> 00:19:20,650
ეს იმიტომ, რომ ძირითად დაბრუნებას კონვენცია წარმოადგენს დაბრუნებას 0 თუ კარგი,

315
00:19:20,650 --> 00:19:22,990
1 ან სხვა ღირებულება, თუ ცუდია.

316
00:19:22,990 --> 00:19:28,200
მაგრამ GetString და ნებისმიერი ფუნქცია, რომ გარიგებებს მეხსიერების ანაზღაურება NULL თუ რაღაც მიდის ცუდი.

317
00:19:28,200 --> 00:19:33,480
>> Okay. ასე რომ, სამწუხაროდ, ხაზი 27, სუპერ მარტივი თუმცა, მთლიანად ვერ გადაიწერა სიმებიანი.

318
00:19:33,480 --> 00:19:35,740
რატომ? ჩვენ ვხედავთ ამ შემდეგნაირად.

319
00:19:35,740 --> 00:19:40,120
მე აცხადებდნენ შეესაბამება 27 უნდა მიღების ასლი და უწოდა ტ.

320
00:19:40,120 --> 00:19:45,790
ასე რომ მე არ გეკითხებით მომხმარებლის 2 სტრიქონები ამ დროს მე უბრალოდ ვამბობ, ღირებულების s

321
00:19:45,790 --> 00:19:47,870
უნდა დადგეს t ისევე.

322
00:19:47,870 --> 00:19:52,890
ახლა მხოლოდ იმის დემონსტრირება, თუ როგორ გატეხილი ეს არის, რომ ამჟამად 29 Onward რა ვარ მე აკეთებს?

323
00:19:52,890 --> 00:19:56,980
პირველი მე შემოწმების თუ სიგრძეზე t მეტია 0.

324
00:19:56,980 --> 00:19:59,330
არსებობს რამდენიმე სტრიქონი იქ. მომხმარებლის აკრეფილი რაღაც სისტემაში

325
00:19:59,330 --> 00:20:03,410
რა არის ხაზზე 32 აკეთებს, როგორც ჩანს?

326
00:20:03,410 --> 00:20:08,910
[Inaudible სტუდენტი საპასუხოდ] >> მარჯვენა. შეგიძლიათ სახის infer ის, რაც ვთქვი ის აკეთებს.

327
00:20:08,910 --> 00:20:13,200
მაგრამ ტექნიკურად, რა არის ეს აკეთებს? t [0] წარმოადგენს რა?

328
00:20:13,200 --> 00:20:15,140
[სტუდენტი] zeroth ხასიათი. >> [Malan] zeroth ხასიათი.

329
00:20:15,140 --> 00:20:19,620
ან, უფრო ადამიანის მსგავსი, პირველი პერსონაჟი t, რასაც არ არის, H იქნებ ამ შემთხვევაში.

330
00:20:19,620 --> 00:20:24,990
და toupper აკეთებს იმას ნათქვამია მოხსენებაში. ეს capitalizes zeroth ხასიათი t და ეს ცვლის მას.

331
00:20:24,990 --> 00:20:28,430
ასე რომ, ეს იმას ნიშნავს, მიიღოს zeroth ხასიათი t, რათა ის ზედა,

332
00:20:28,430 --> 00:20:30,320
და მისი უკან რომ იმავე ადგილას.

333
00:20:30,320 --> 00:20:35,540
ასე რომ, თუ მე აკრიფოთ მიესალმები ამას, ეს უნდა შეიცვალოს ამას თ რომ დედაქალაქში H.

334
00:20:35,540 --> 00:20:41,400
მაგრამ პრობლემა ის არის, რომ ხაზები 35 და 36 რა ვარ შესახებ გააკეთოთ ამობეჭდოთ ჩვენთვის და ტ.

335
00:20:41,400 --> 00:20:43,120
და რაც თქვენი hunch?

336
00:20:43,120 --> 00:20:47,250
რა ვარ მე რეალურად აპირებს თუ არა მე აკრეფილი მიესალმები ყველა ამას?

337
00:20:47,250 --> 00:20:52,280
რა ხდება მისაღებად დაბეჭდილი? >> [Inaudible სტუდენტი საპასუხოდ] >> რა არის რომ?

338
00:20:52,280 --> 00:20:58,360
[სტუდენტი] დიდი H და დანარჩენი მცირე. >> დიდი H და დანარჩენი მცირე რისთვისაც, s ან t?

339
00:20:58,360 --> 00:21:03,170
[სტუდენტი] ორივე. >> ორივე. სწორედ. ასე რომ ვნახოთ რა ხდება აქ.

340
00:21:03,170 --> 00:21:08,380
>> ნება მომეცით წავიდეთ წინ და შეადგინონ ამ. ეს არის copy1, ასე რომ copy1. ყველა უფლება.

341
00:21:08,380 --> 00:21:14,840
Zoom შემოსული ნება მომეცით წავიდეთ წინ და აწარმოებს copy1, შეიტანეთ, ვთქვათ რაღაც: Hello ამას.

342
00:21:14,840 --> 00:21:19,570
ეს კაპიტალიზირდება ასლი, მაგრამ ეს აშკარად კაპიტალიზირდება ორიგინალური ისევე,

343
00:21:19,570 --> 00:21:22,070
რადგან ის, რაც ახლა ხდება ეს ამბავი?

344
00:21:22,070 --> 00:21:27,030
შეესაბამება 27 მე არ რეალურად ჩანს, კოპირება ტექსტი,

345
00:21:27,030 --> 00:21:30,450
მაგრამ მიუხედავად იმისა, რომ თქვენ შეიძლება არ ინტუიციურად იმედი გამოთქვა, რომ იყოს საქმე,

346
00:21:30,450 --> 00:21:33,680
თუ ფიქრობთ ამის შესახებ ამ სურათს, თუ რა არ მინდა გაკეთდეს?

347
00:21:33,680 --> 00:21:35,410
ნახევარი სურათზე არის იგივე.

348
00:21:35,410 --> 00:21:39,390
მოდით გააფართოვოს უკან დროში, ასე რომ t ჯერ არ არსებობს ამბავი.

349
00:21:39,390 --> 00:21:43,160
S შეიძლება არსებობდეს ამბავი, მაგრამ მოდით ამას მიესალმები ამ დროს.

350
00:21:43,160 --> 00:21:46,710
ნება მომეცით, დაფიქსირება, რაც მე რეალურად აკრეფილი შემოსული

351
00:21:46,710 --> 00:21:51,280
ამ შემთხვევაში აქ გვაქვს H-E-L-მ-o.

352
00:21:51,280 --> 00:21:58,050
ჩვენ მიაპყროს, როგორც თანმიმდევრობა გმირები, რომ ჩემი გამყოფი ხაზები აქ და ჩემი \ 0.

353
00:21:58,050 --> 00:22:05,980
ასე რომ, ეს სადაც ჩვენ ვართ, როგორც კი ხაზი 1 მეშვეობით 24-ish, მისცეს ან მიიღოს, არ შესრულდება.

354
00:22:05,980 --> 00:22:07,800
ეს არის სურათის ჩემი გონებიდან.

355
00:22:07,800 --> 00:22:10,800
როდესაც მე მისაღებად ხაზი 27, რა ხდება?

356
00:22:10,800 --> 00:22:14,730
ისევე ადრე, მომცეთ, რომელიც მე მიაპყროს როგორც ამ მოედანზე.

357
00:22:14,730 --> 00:22:19,740
ეს მოუწოდა ტ. და რაც მისი ღირებულება იყოს? ვინ იცის? ზოგიერთი ნაგვის ღირებულება.

358
00:22:19,740 --> 00:22:22,060
>> ამიტომ მე აბსტრაქტული რომ მოშორებით როგორც კითხვის ნიშნის.

359
00:22:22,060 --> 00:22:27,670
და როგორც კი მარჯვენა მხარეს ხაზი 27 ახორციელებს, რა ვარ მე აყენებს შიგნით t?

360
00:22:27,670 --> 00:22:30,770
იგივე რომ წელს s.

361
00:22:30,770 --> 00:22:34,120
ასე რომ, თუ ჩვენ ერთი წუთით ამოიღონ ამ აბსტრაქცია of arrow და ვამბობთ,

362
00:22:34,120 --> 00:22:40,330
OH, ეს არის მეხსიერების დატვირთვის მისამართი 123, როცა ამბობთ t იღებს s, მძიმით,

363
00:22:40,330 --> 00:22:42,700
თქვენ სიტყვასიტყვით აყენებს 123 აქ.

364
00:22:42,700 --> 00:22:45,200
ახლა თუ ჩვენ სახის გაამარტივებს ჩვენი სამყაროს კვლავ სურათები,

365
00:22:45,200 --> 00:22:48,750
რა თქვენ მართლაც გაკეთდეს მხოლოდ დაემატა კიდევ ერთი arrow თქვენს სამყაროსთან

366
00:22:48,750 --> 00:22:52,910
რომ მიუთითებს საწყისი t იმავე ზუსტი სიმებიანი.

367
00:22:52,910 --> 00:22:59,730
ასე რომ, როდესაც შეესაბამება 31 და 32 მე რეალურად წასვლა შეცვლის შესახებ t [0],

368
00:22:59,730 --> 00:23:05,580
რა არის t [0] აშკარად სინონიმი არის? s [0]

369
00:23:05,580 --> 00:23:07,030
ასე რომ ყველა რომ ხდება.

370
00:23:07,030 --> 00:23:09,900
და მიუხედავად იმისა, ასეთი გრძნობს პატარა დაბალი დონე და arcane

371
00:23:09,900 --> 00:23:12,760
და ამ სახის იგრძნობა ალბათ ინტუიციურად უნდა ახლახანს მუშაობდა -

372
00:23:12,760 --> 00:23:15,410
მე გააკეთა ასლები რამ ადრე და ეს მხოლოდ მუშაობდა -

373
00:23:15,410 --> 00:23:18,590
თუ თქვენ ნამდვილად ვფიქრობ იმაზე, თუ რა სიმებიანი ნამდვილად არის, ეს char *.

374
00:23:18,590 --> 00:23:21,700
ისე, რა არის ეს? ეს მისამართი ზოგიერთი ხასიათი.

375
00:23:21,700 --> 00:23:24,930
მაშინ ალბათ ეს ქმნის მეტი გაგებით, რომ როდესაც თქვენ ცდილობენ რაღაც

376
00:23:24,930 --> 00:23:29,220
სუპერ შეხედვით მარტივი მოსწონს, ყველა თქვენ აკეთებთ არის კოპირება მეხსიერების მისამართზე.

377
00:23:29,220 --> 00:23:32,530
თქვენ არ რეალურად აკეთებს არაფერი სიმებიანი თავად.

378
00:23:32,530 --> 00:23:37,500
ისე კი, თუ თქვენ არ ვიცი, როგორ გადაჭრას ეს პრობლემა კოდი,

379
00:23:37,500 --> 00:23:45,080
მაღალი დონის, კონცეპტუალურად, რას უნდა გავაკეთოთ, რათა ta ჭეშმარიტი ასლი s, სავარაუდოდ?

380
00:23:46,670 --> 00:23:48,820
Yeah. >> [სტუდენტი] Give it new საიდან? >> ზუსტად.

381
00:23:48,820 --> 00:23:50,800
>> ჩვენ უნდა მივცეთ t ბრენდის ახალი ადგილმდებარეობა.

382
00:23:50,800 --> 00:23:55,230
ჩვენ გვჭირდება, რათა როგორმე შექმნას სამყარო სადაც მივიღებთ ახალ ბლოკი მეხსიერება,

383
00:23:55,230 --> 00:24:00,090
რომელიც მხოლოდ სიცხადე გულისთვის მე მიაპყროს უფლება ქვემოთ ამ ერთი, მაგრამ ეს არ უნდა იყოს იქ.

384
00:24:00,090 --> 00:24:04,880
მაგრამ ეს უნდა იყოს იგივე ზომის, ამიტომ მე მიაპყროს ამ ვერტიკალური ხაზები იგივე ადგილზე.

385
00:24:04,880 --> 00:24:09,720
ეს ჯარიმა, თუ ეს ყველაფერი ნაგავი თავდაპირველად. ვინ იცის, რა იყო იქ?

386
00:24:09,720 --> 00:24:13,850
მაგრამ ნაბიჯი 1 აპირებს უნდა მომეცი იმდენი მეხსიერებაში, მე უნდა

387
00:24:13,850 --> 00:24:18,630
რათა შეწყობოდა ასლი hello, მაშინ გაერკვნენ, თუ როგორ კოპირება თ აქ, ვებ აქ,

388
00:24:18,630 --> 00:24:20,390
ლ აქ და სხვ.

389
00:24:20,390 --> 00:24:24,880
მაგრამ ეს უკვე უნდა გრძნობდეს პატარა აშკარა მაშინაც კი, თუ ზოგიერთი დეტალი ჯერ კიდევ რეზიუმე.

390
00:24:24,880 --> 00:24:28,690
გადააკოპირეთ ეს სიმებიანი შევიდა ამ, უბრალოდ ამისთვის მარყუჟი ან ხოლო loop

391
00:24:28,690 --> 00:24:31,580
ან რაღაც, რომელთანაც თქვენ გახდეს უფრო იცნობს.

392
00:24:31,580 --> 00:24:35,970
მოდით ცდილობენ ამ. ნება მომეცით წასვლას copy2.c.

393
00:24:35,970 --> 00:24:43,270
In copy2.c გვაქვს თითქმის იგივე პროგრამის გარდა ხაზი 27.

394
00:24:43,270 --> 00:24:47,260
როგორც ჩანს ცოტა რთული, მაგრამ თუ ჩვენ შესვენება მისი დანგრევა ნაჭერი მიერ ცალი,

395
00:24:47,260 --> 00:24:48,950
მარცხენა მხარეს არის იგივე.

396
00:24:48,950 --> 00:24:52,790
ჩარ * t ქმნის ამ რამ მეხსიერებაში, მაგრამ კითხვის ნიშნის

397
00:24:52,790 --> 00:24:54,680
რადგან არ ვიცით რა იქ იყოს.

398
00:24:54,680 --> 00:24:57,920
წლის მარჯვენა მხარეს ჩვენ ახლა შემოღების ახალი ფუნქცია, malloc,

399
00:24:57,920 --> 00:25:00,640
მეხსიერების გამოყოფას, მომეცი მეხსიერება,

400
00:25:00,640 --> 00:25:06,900
და ეს აშკარად იღებს რამდენი არგუმენტები, რამდენი რამ შიგნით ფრჩხილებში?

401
00:25:09,660 --> 00:25:12,130
გავიგე murmurings 1 და 2 გზა, მაგრამ ეს მხოლოდ 1.

402
00:25:12,130 --> 00:25:15,320
იქ არ არის მძიმე, რაც იმას ნიშნავს, არსებობს მხოლოდ 1 რამ შიგნით ფრჩხილებში.

403
00:25:15,320 --> 00:25:17,720
მიუხედავად იმისა, რომ არსებობს სხვა ფრჩხილებში, ნება მომეცით ხაზი გავუსვა

404
00:25:17,720 --> 00:25:21,460
რა შიგნით outermost ფრჩხილებში და ეს ამ გამოსახულებანი:

405
00:25:21,460 --> 00:25:25,880
(Strlen (ებ) + 1) * sizeof (char).

406
00:25:25,880 --> 00:25:29,190
ასე რომ, თუ ჩვენ რეალურად ვფიქრობ ამ გზით, ამ ამბობს მომეცი სიგრძით s.

407
00:25:29,190 --> 00:25:34,440
რატომ ვარ მე, თუმცა დასძინა, 1 გადატანა სიგრძე? >> [Inaudible სტუდენტი საპასუხოდ]

408
00:25:34,440 --> 00:25:40,200
სწორედ. ჩვენ გვჭირდება ფართი ამ ბიჭს საათზე კუდი, მეექვსე ხასიათი, რომ არ აქვს მნიშვნელობა ინგლისური

409
00:25:40,200 --> 00:25:42,250
მაგრამ აქვს სპეციალური პროგრამული მნიშვნელობა აქვს.

410
00:25:42,250 --> 00:25:46,800
>> ამიტომ ჩვენ გვჭირდება + 1 რომ რადგან strlen ბრუნდება ადამიანის მოლოდინს სიგრძე,

411
00:25:46,800 --> 00:25:50,890
მიესალმები ან 5, იგი არ მოგცემთ დამატებით null ხასიათი.

412
00:25:50,890 --> 00:25:52,980
ასე რომ ხელით დაამატოთ ეს ერთად + 1.

413
00:25:52,980 --> 00:25:56,060
და მაშინ ეს, * ზომა (char), ჩვენ არ გვინახავს ამ ადრე.

414
00:25:56,060 --> 00:25:57,480
ეს არ არის ტექნიკურად ფუნქცია.

415
00:25:57,480 --> 00:26:04,150
აი ეს არის განსაკუთრებული სიტყვით რომ ეუბნება, თუ რა ზომის არის ზოგიერთი მონაცემები ტიპის კომპიუტერი

416
00:26:04,150 --> 00:26:06,980
რადგან რეალურად, ზოგიერთი ჩვენგანი 32-bit კომპიუტერებს.

417
00:26:06,980 --> 00:26:10,900
მაქვს საკმაოდ ძველი კომპიუტერი სახლში, და ეს მხოლოდ იყენებს 32 ბიტს წარმოადგინოს პოინტერები.

418
00:26:10,900 --> 00:26:13,900
და ასე თუ წავიდოდი ზომის მონაცემები ტიპის, ეს შესაძლოა 32 ბიტი.

419
00:26:13,900 --> 00:26:18,300
მაგრამ თუ მე გამოყენებით ჩემი ახალი ლამაზი კომპიუტერი, ალბათ დაიბრუნებს ღირებულება 64 ბიტი

420
00:26:18,300 --> 00:26:20,510
ამისთვის რაღაც მისამართზე.

421
00:26:20,510 --> 00:26:25,400
ასე რომ, ამ შემთხვევაში, უბრალოდ უნდა იყოს სუპერ უსაფრთხო, ჩვენ არ ვაპირებთ მძიმე კოდი რაღაც -

422
00:26:25,400 --> 00:26:28,740
ასევე, რა არის ზომა char მიხედვით, რაც ჩვენ უკვე აღვნიშნე, რომ აქამდე?

423
00:26:28,740 --> 00:26:34,450
ჩვენ საკმაოდ ბევრი ამბობს სიტყვიერად, რომ 1 ნაწილად, და ეს საკმაოდ ბევრი ჭეშმარიტი მთელს ფორუმში.

424
00:26:34,450 --> 00:26:37,000
თუმცა ისევ და ისევ, დაშვებების ტენდენცია იყოს ცუდი.

425
00:26:37,000 --> 00:26:40,850
ისინი გამოიწვიოს buggy პროგრამული თუ ადამიანი სარგებლობს თქვენი პროგრამული უზრუნველყოფის გზები თქვენ არ აპირებდა.

426
00:26:40,850 --> 00:26:44,750
მოდით რეზიუმე ამ მოშორებით და უბრალოდ მეტი generically ამბობენ

427
00:26:44,750 --> 00:26:46,830
მჭირდება ამ ბევრი მოცულობით მეხსიერება

428
00:26:46,830 --> 00:26:50,210
და თითოეული ბლოკი მეხსიერება უნდა იყოს ექვივალენტური ზომა ხასიათი,

429
00:26:50,210 --> 00:26:54,870
რაც ფაქტობრივად ტოლია 1 ამ შემთხვევაში, მაგრამ მეტი გზა generic წერის იგი.

430
00:26:54,870 --> 00:27:00,460
ასე რომ, თუ სიტყვა არის hello, რამდენი ბაიტი ამჯამად malloc სავარაუდოდ გამოყოს ამისთვის მიესალმები?

431
00:27:00,460 --> 00:27:04,980
[სტუდენტი] ექვსი. >> ექვსი. ზუსტად ისე, როგორც ბევრი როგორც ჩვენ გვაქვს კითხვის ნიშნები ეკრანზე.

432
00:27:04,980 --> 00:27:07,800
და მერე მიხვდები ახლა ეფუძნება თქვენი გაგება GetString

433
00:27:07,800 --> 00:27:12,790
რას malloc ალბათ დაბრუნებას? >> [სტუდენტი] მისამართზე.

434
00:27:12,790 --> 00:27:17,020
მისამართი რა? პირველი ბლოკი მეხსიერება.

435
00:27:17,020 --> 00:27:20,670
>> ჩვენ არ გვაქვს იდეა რა იქ, რადგან რამდენიმე სხვა ფუნქცია

436
00:27:20,670 --> 00:27:23,010
შესაძლებელი იყო გამოყენებისას მეხსიერების ადრე.

437
00:27:23,010 --> 00:27:28,380
მაგრამ malloc, როგორიცაა GetString ბრუნდება მისამართი პირველი ბაიტი მეხსიერების

438
00:27:28,380 --> 00:27:30,540
რომ მან გათვალისწინებულია თქვენ.

439
00:27:30,540 --> 00:27:38,380
თუმცა, რა იგი ამას არ გააკეთებს არის შეავსოთ ამ ცარიელი ერთად backslash null ხასიათი

440
00:27:38,380 --> 00:27:43,030
რადგან აღმოჩნდება, შეგიძლიათ გამოიყენოთ malloc გამოყოფას არაფერი: ints, სიმები, მასივები,

441
00:27:43,030 --> 00:27:45,700
მოძრავი, სტუდენტი სტრუქტურებში.

442
00:27:45,700 --> 00:27:47,750
თქვენ შეგიძლიათ გამოიყენოთ malloc მთლიანად generically.

443
00:27:47,750 --> 00:27:51,470
მას ფეხზეც ან უნდა ვიცოდეთ თუ რას გამოყოფის მეხსიერების.

444
00:27:51,470 --> 00:27:55,810
ასე რომ, ეს იქნებოდა presumptuous ამისთვის malloc დააყენოს \ 0

445
00:27:55,810 --> 00:27:58,340
დასასრულს ყველა ბლოკი მეხსიერების ის გაწვდით

446
00:27:58,340 --> 00:28:02,620
რადგან ეს \ 0 რამ არის მხოლოდ კონვენციის სიმებისათვის.

447
00:28:02,620 --> 00:28:06,310
ეს არ გამოიყენება ints, ეს არ გამოიყენება მოძრავი, ეს არ გამოიყენება სტუდენტებს.

448
00:28:06,310 --> 00:28:11,730
და ასე GOTCHA ერთად malloc არის, რომ ტვირთი მთლიანად თქვენ პროგრამისტი

449
00:28:11,730 --> 00:28:16,790
უნდა გვახსოვდეს, თუ რამდენი ბაიტი თქვენ გამოყოფილი და არა ოდესმე გამოიყენოს ამისთვის loop

450
00:28:16,790 --> 00:28:21,570
ან მაშინ, როცა მარყუჟის და წავიდეთ წარსულში საზღვრის ბლოკი მეხსიერება თქვენ უკვე ეძლევა.

451
00:28:21,570 --> 00:28:23,540
განათავსეთ სხვა გზა, როგორც კი თქვენ გამოყოს მეხსიერება,

452
00:28:23,540 --> 00:28:28,510
ვერ ვთხოვთ ოპერაციული სისტემა, OH, სხვათა შორის, თუ როგორ დიდი ბლოკი მეხსიერება იყო ეს?

453
00:28:28,510 --> 00:28:32,080
ეს მთლიანად თქვენზეა უნდა გვახსოვდეს, თუ თქვენ გჭირდებათ რომ ღირებულება.

454
00:28:32,080 --> 00:28:34,330
>> ასე რომ ვნახოთ რა გაგრძელება გამოიყენოს ეს მეხსიერებაში.

455
00:28:34,330 --> 00:28:38,430
შეესაბამება 28 და 29 რატომ აკეთებს ამას?

456
00:28:39,850 --> 00:28:42,260
უბრალოდ სულ საღი აზრის ქვითარი.

457
00:28:42,260 --> 00:28:45,110
Just შემთხვევაში რაღაც არ მოხდა ისე, ვთხოვ რაღაც Crazy ოდენობით მეხსიერება

458
00:28:45,110 --> 00:28:48,690
ან მე ამდენი რამ გაშვებული კომპიუტერი რომ იქ უბრალოდ არ არის საკმარისი მეხსიერება,

459
00:28:48,690 --> 00:28:51,780
მსგავსი რამ, რომ მე მინიმუმ გვინდა შევამოწმოთ null.

460
00:28:51,780 --> 00:28:55,260
სინამდვილეში, ყველაზე მეტად კომპიუტერები მოგცემთ იმის ილუზია, რომ ყველა პროგრამა

461
00:28:55,260 --> 00:28:57,080
შეგიძლიათ გამოიყენოთ მთლიანად თქვენი RAM,

462
00:28:57,080 --> 00:29:00,740
მაგრამ ასე, თუ მომხმარებლის ტიპის ზოგიერთ Crazy ხანგრძლივი string რადგან ისინი ცუდი ბიჭი

463
00:29:00,740 --> 00:29:03,440
და ისინი რეალურად ცდილობს Crash თქვენი პროგრამის ან hack მივანიჭო,

464
00:29:03,440 --> 00:29:07,300
გსურთ მინიმუმ შეამოწმოთ დაბრუნების ღირებულება malloc და თუ არა შეადგენს null.

465
00:29:07,300 --> 00:29:11,630
და თუ ეს ასეა, მოდით ახლახან შევწყვიტე ახლავე რადგან არ ვიცი რა უნდა გააკეთოს ამ შემთხვევაში.

466
00:29:11,630 --> 00:29:13,950
როგორ შემიძლია კოპირება სიმებიანი? არსებობს რამდენიმე გზა ამის გაკეთება.

467
00:29:13,950 --> 00:29:18,850
არსებობს ქ კოპირება ფუნქციების C, მაგრამ სუპერ მარტივი ჩვენთვის ამის გაკეთება მოძველებული გზა.

468
00:29:18,850 --> 00:29:23,110
>> პირველი ნება მომეცით გაერკვნენ, რა სიგრძით s არის.

469
00:29:23,110 --> 00:29:26,930
მე შეეძლო ეს loop არამედ უბრალოდ განათავსოთ out აქ სიცხადე.

470
00:29:26,930 --> 00:29:30,610
ასე n ახლა ინახავს სიგრძეზე ორიგინალური ტექსტი, რომელიც სავარაუდოდ 5.

471
00:29:30,610 --> 00:29:35,290
მაშინ ჩემი ამისთვის loop მე iterating საწყისი 0 on მდე N,

472
00:29:35,290 --> 00:29:40,940
და თითოეულ iteration მე აყენებს s [i] შიგნით t [i].

473
00:29:40,940 --> 00:29:45,060
ასე რომ, რაც მე გულისხმობდა, რომ ჩემს 2 თითების მიუთითებს სიმები ადრე.

474
00:29:45,060 --> 00:29:49,260
როგორც ეს loop iterates მოსწონს, მე ვაპირებ იყოს გადაწერა თ შევიდა აქ,

475
00:29:49,260 --> 00:29:52,890
ვებ შევიდა აქ, ლ შევიდა აქ რადგან ეს s, ეს არის ტ.

476
00:29:52,890 --> 00:29:58,770
და მერე ბოლოს, შეესაბამება 35 რატომ აკეთებს ამას?

477
00:29:58,770 --> 00:30:03,770
მე უნდა დავრწმუნდეთ, რომ მე დამთავრებული სიმებიანი ტ.

478
00:30:03,770 --> 00:30:06,170
და მე ეს გზა იყოს სუპერ სიცოცხლისუნარიანობა.

479
00:30:06,170 --> 00:30:09,510
მაგრამ შესთავაზოს, ვინმეს თუ შეგიძლიათ, განსხვავებულ გზას აკეთებენ.

480
00:30:09,510 --> 00:30:13,930
მე ნამდვილად არ გვჭირდება ხაზის 35. არსებობს სხვა გზა ამის გაკეთება.

481
00:30:13,930 --> 00:30:18,880
Yeah. >> [Inaudible სტუდენტი საპასუხოდ] >> Say ეს louder.

482
00:30:18,880 --> 00:30:20,960
[სტუდენტი] ნაკლებია ან ტოლი. >> ზუსტად.

483
00:30:20,960 --> 00:30:24,450
ჩვენ შეგვეძლო უბრალოდ, ვამბობთ ნაკლები ან ტოლია N, რომელიც ზოგადად უკვე ცუდი

484
00:30:24,450 --> 00:30:28,190
რადგან თითქმის ყოველთვის, როცა ჩვენ ახვიდეთ ტოლია რამ ჩვენ დათვლის

485
00:30:28,190 --> 00:30:30,000
ჩვენ 1 ნაბიჯით შორს.

486
00:30:30,000 --> 00:30:32,170
მაგრამ გახსოვდეთ, თუ რამდენი ბაიტი არც ჩვენ გამოყოს?

487
00:30:32,170 --> 00:30:37,210
ჩვენ გამოყოფილი strlen of s, ასე 5 + 1 სულ 6.

488
00:30:37,210 --> 00:30:39,980
ასე რომ ამ შემთხვევაში ჩვენ შეგვიძლია გავაკეთოთ რაღაც მსგავსი

489
00:30:39,980 --> 00:30:46,450
ასე, რომ ჩვენ კოპირება არა მხოლოდ მიესალმები არამედ \ 0 ბოლომდე.

490
00:30:46,450 --> 00:30:49,860
გარდა ამისა, ჩვენ შეგვიძლია გამოვიყენოთ ფუნქცია მოუწოდა ქ ასლი, strcpy,

491
00:30:49,860 --> 00:30:51,700
მაგრამ, რომ არ იქნება თითქმის იმდენი fun.

492
00:30:51,700 --> 00:30:54,000
მაგრამ ეს ყველაფერი მას არ ქვევმოთ hood.

493
00:30:54,000 --> 00:30:56,050
მაშინ ბოლოს, ჩვენ იგივე რამ, როგორც ეს ადრე იყო.

494
00:30:56,050 --> 00:31:01,620
მე კაპიტალიზაცია t და მერე აცხადებენ, რომ ორიგინალური ასე გამოიყურება და ასლი ჰგავს, რომ.

495
00:31:01,620 --> 00:31:08,570
მოდით ვეცადოთ ეს ახლა. ნება მომეცით წავიდეს აქ. ჩადება copy2. ჩვენ მიუახლოვდით და აწარმოებს copy2.

496
00:31:08,570 --> 00:31:13,840
მე ვაპირებ აკრიფოთ მიესალმები ამას, და მართლაც მივიღებ ამას მიესალმები როგორც ორიგინალური

497
00:31:13,840 --> 00:31:16,930
მაგრამ დედაქალაქში გამარჯობა ამისთვის ასლი.

498
00:31:16,930 --> 00:31:20,300
მაგრამ მე არ კეთდება მხოლოდ ამჟამად. მე უნდა გავაკეთოთ 1 ბოლო რამ აქ.

499
00:31:20,300 --> 00:31:28,000
46 და 47 აშკარად გამონთავისუფლების მეხსიერება, მაგრამ რა, რომ რეალურად ნიშნავს?

500
00:31:28,000 --> 00:31:33,250
რა ვარ მე აკეთებს, როგორ ფიქრობთ, დარეკვით ხაზის 46 და ხაზი 47?

501
00:31:33,250 --> 00:31:38,900
რა ეფექტი ამჯამად რომ აქვს? Yeah.

502
00:31:38,900 --> 00:31:43,140
[Inaudible სტუდენტი საპასუხოდ] >> ზუსტად.

503
00:31:43,140 --> 00:31:46,380
>> თქვენ უბრალოდ ვეუბნებოდი ოპერაციული სისტემა, Hey, მადლობა ამ მეხსიერებაში.

504
00:31:46,380 --> 00:31:48,320
ახლა თქვენთვის ვიყენებთ მას ვინმე.

505
00:31:48,320 --> 00:31:50,790
და აქ მაგალითი ნაგვის ღირებულებებს.

506
00:31:50,790 --> 00:31:55,430
მე ახლახან გამოიყენება ამ მეხსიერების დაწერეთ სიტყვა მიესალმები წელს 2 ადგილებში,

507
00:31:55,430 --> 00:31:57,490
აქ, აქ, აქ, და აქ.

508
00:31:57,490 --> 00:32:00,910
ასე რომ, ეს არის H-E-L-L-O-\ 0.

509
00:32:00,910 --> 00:32:06,960
მაგრამ შემდეგ მოვუწოდებ ხაზის 46 და ხაზი 47, და თქვენ იცით, რა ხდება იქ თვალსაზრისით სურათზე?

510
00:32:06,960 --> 00:32:10,010
სინამდვილეში, დაველოდოთ, ამ სურათის ძველი.

511
00:32:10,010 --> 00:32:12,550
ერთხელ ჩვენ ასლი, ამ ბიჭს ფაქტიურად მიუთითებს აქ,

512
00:32:12,550 --> 00:32:16,110
მოდით ამოიღონ ნომრები და მხოლოდ აბსტრაქტული მოშორებით როგორც ჩვენი ისრები კვლავ.

513
00:32:16,110 --> 00:32:19,370
რა ხდება ამ სურათს როცა მოვუწოდებ თავისუფალი?

514
00:32:19,370 --> 00:32:22,750
[Inaudible სტუდენტი საპასუხოდ] >> კი არ.

515
00:32:22,750 --> 00:32:29,510
თუ მოვუწოდებ უფასოდ და T - სახის ხრიკი კითხვა - ამ სურათს არ ცვლის ყველა

516
00:32:29,510 --> 00:32:33,880
რადგან მოუწოდებდა და მოუწოდებდა t მხოლოდ ეუბნება ოპერაციული სისტემა,

517
00:32:33,880 --> 00:32:39,010
Hey, შეგიძლიათ გამოიყენოთ ეს მეხსიერების ერთხელ, მაგრამ ეს არ ცვლის ეს null

518
00:32:39,010 --> 00:32:41,840
ან რაღაც განსაკუთრებული ხასიათი, იგი არ ცვლის ამ,

519
00:32:41,840 --> 00:32:47,350
ეს არ ცვლის თ ან ე ან ლ ან ლ ან o ორივე ადგილიდან არაფერი.

520
00:32:47,350 --> 00:32:51,610
თვალსაზრისით სურათზე, როგორც კი მოვუწოდებთ თავისუფალი, არაფერი შეიცვლება.

521
00:32:51,610 --> 00:32:56,570
და მასში მდგომარეობს წარმოშობის ნაგვის ღირებულებები რადგან თუ შემდეგ ამ პროგრამაში

522
00:32:56,570 --> 00:33:01,010
ვთხოვთ ოპერაციული სისტემის უფრო მეხსიერების ერთად GetString ან malloc ან რამე მაგდაგვარს

523
00:33:01,010 --> 00:33:04,900
და ოპერაციული სისტემის ამბობს, დარწმუნებული ვარ, მყავს 12 ბაიტი მეხსიერება უბრალოდ გაათავისუფლა up,

524
00:33:04,900 --> 00:33:08,080
გამოიყენოს ეს, რას აპირებს გადაეცემა?

525
00:33:08,080 --> 00:33:10,830
თქვენ ვაპირებთ გადაეცემა ბლოკი მეხსიერება, რომ ჩვენ, როგორც წესი, მიაპყროს

526
00:33:10,830 --> 00:33:13,700
ერთად კითხვის ნიშნები, მაგრამ რა არის ის კითხვის ნიშნები?

527
00:33:13,700 --> 00:33:17,000
ისინი მოხდეს იყოს H-E-L-L-O, H-E-L-მ-o.

528
00:33:17,000 --> 00:33:20,940
ეს არის ჩვენი ახალი ნაგვის ღირებულებებს, როგორც კი თქვენ უფასოა, რომ მეხსიერებაში.

529
00:33:20,940 --> 00:33:22,750
>> არსებობს რეალური სამყაროს გავლენა აქაც.

530
00:33:22,750 --> 00:33:24,720
ეს ხდება არ უკავშირდება RAM, მაგრამ თქვენი კომპიუტერები

531
00:33:24,720 --> 00:33:26,720
ფაქტობრივად იგივე რამ რომელსაც დისკზე.

532
00:33:26,720 --> 00:33:30,620
ჩვენ ვსაუბრობთ ამ კერძოდ მომავალში პრობლემა კომპლექტი, რომ აქცენტს აკეთებს სასამართლო ექსპერტიზის.

533
00:33:30,620 --> 00:33:36,170
მაგრამ რა მოხდება თუ თქვენ გაქვთ გარკვეული მგრძნობიარე ფინანსური ფაილი თქვენს კომპიუტერში

534
00:33:36,170 --> 00:33:39,600
ან sketchy JPEG და თქვენ გადაიტანეთ იგი თქვენს ნაგავი,

535
00:33:39,600 --> 00:33:44,390
რა ხდება, როდესაც თქვენ გადაიტანეთ იგი შევიდა ნაგვის ან recycle bin?

536
00:33:44,390 --> 00:33:47,240
თქვენ იცოდა რა იყო საუბარი. [სიცილის]

537
00:33:47,240 --> 00:33:52,370
რა ხდება, როდესაც თქვენ ისხდნენ, რომ მტკიცებულება თქვენი recycle bin ან ნაგვის შეიძლება?

538
00:33:52,370 --> 00:33:55,920
[Inaudible სტუდენტი საპასუხოდ]

539
00:33:55,920 --> 00:33:58,000
ისე, ასე რომ ფრთხილად. რა ხდება, როდესაც თქვენ ეს?

540
00:33:58,000 --> 00:34:01,030
მოკლე პასუხი არის არაფერი, არა?

541
00:34:01,030 --> 00:34:04,790
Sketchy ან მგრძნობიარე ფაილი დღემდე მხოლოდ სხდომაზე სადღაც თქვენს ხისტ დისკზე.

542
00:34:04,790 --> 00:34:07,940
ყველაზე მეტად ჩვენს არანაკლებ ვისწავლეთ რთულ გზაზე, რაც გჭირდებათ დაცლას თქვენი ურნის

543
00:34:07,940 --> 00:34:10,429
ან თქვენი recycle bin რეალურად წაშალოთ ფაილები.

544
00:34:10,429 --> 00:34:13,440
მართლაც, როდესაც თქვენ დააჭიროთ მაუსის მარჯვენა ღილაკს ან კონტროლის დაჭერით თქვენი ნაგვის can

545
00:34:13,440 --> 00:34:15,580
ან აირჩიეთ ფაილი, ცარიელი სანაგვე ან რასაც

546
00:34:15,580 --> 00:34:21,420
და თქვენ ნამდვილად დაცლას trash შეუძლია recycle bin, რაც სინამდვილეში ხდება მაშინ ამ სურათს?

547
00:34:22,810 --> 00:34:25,969
სხვა არაფერი. ასე რომ არაფერი რეალურად ხდება დისკზე.

548
00:34:25,969 --> 00:34:30,880
>> და თუ ჩვენ მხოლოდ დროებით digress და დაწეროთ - I'll ისარგებლეთ უკან ამ.

549
00:34:30,880 --> 00:34:34,639
ახლა სიუჟეტი იცვლება RAM, სადაც პროგრამების არსებობს

550
00:34:34,639 --> 00:34:39,250
ხოლო თქვენ გაშვებული მათ, დისკზე, სადაც ინახება გრძელვადიანი

551
00:34:39,250 --> 00:34:42,920
მაშინაც კი, როდესაც ხელისუფლებაში გადის, ახლა - და ჩვენ დავბრუნდებით ამ მომავალში -

552
00:34:42,920 --> 00:34:46,380
მოდით უბრალოდ ვიტყვი, რომ ეს წარმოადგენს მყარი დისკის შიგნით თქვენი კომპიუტერის

553
00:34:46,380 --> 00:34:50,110
რადგან უკან დღეში ადრე წრიული დისკები, ჰგავს ფლოპი დისკები.

554
00:34:50,110 --> 00:34:55,130
ასე რომ თუ გარკვეული მგრძნობიარე Excel ფაილი, ის შესაძლოა ამ ბლოკი მეხსიერება

555
00:34:55,130 --> 00:34:59,770
თქვენი კომპიუტერის დისკზე, და მე უბრალოდ ხატვის იგივე თვითნებური 1s და 0S.

556
00:34:59,770 --> 00:35:03,970
როდესაც თქვენ გადაიტანეთ ფაილი მოსწონს, რომ თქვენი ნაგვის შეიძლება ან recycle bin,

557
00:35:03,970 --> 00:35:07,750
სიტყვასიტყვით, აღარაფერი ხდება, რადგან Apple და Microsoft ახლახანს გადაწყვიტეს

558
00:35:07,750 --> 00:35:10,450
ნაგვის შეგვიძლია და recycle bin მართლაც მხოლოდ დროებითი placeholder.

559
00:35:10,450 --> 00:35:14,710
იქნებ საბოლოოდ OS იქნება დაცლას იგი თქვენთვის, მაგრამ, როგორც წესი, ის არაფერს აკეთებს,

560
00:35:14,710 --> 00:35:17,090
მინიმუმ, სანამ თქვენ ნამდვილად დაბალი კოსმიურ.

561
00:35:17,090 --> 00:35:20,870
>> თუმცა, როდესაც მიდიხარ ცარიელი სანაგვე ან ცარიელი recycle bin,

562
00:35:20,870 --> 00:35:23,460
ანალოგიურად, აღარაფერი ხდება ამ სურათს.

563
00:35:23,460 --> 00:35:28,590
ყველა რომ ხდება სხვაგან თქვენს კომპიუტერში, არსებობს გარკვეული სახის მაგიდასთან.

564
00:35:28,590 --> 00:35:35,400
ეს ერთგვარი მოსწონს პატარა cheat ფურცელი, რომელიც ამბობს, რომ, ვთქვათ, resume.doc,

565
00:35:35,400 --> 00:35:40,920
ასე რომ თქვენი რეზიუმე Microsoft Word ფაილის გამოიყენება ცხოვრობენ საიდან 123 თქვენს მყარ დისკზე,

566
00:35:40,920 --> 00:35:43,710
არ მეხსიერებაში და არა RAM მაგრამ თქვენს მყარ დისკზე,

567
00:35:43,710 --> 00:35:49,050
და თქვენი sketchy JPEG ცხოვრობს 456, და თქვენი Excel ფაილი ცხოვრობს 789 ან სადაც არ უნდა.

568
00:35:49,050 --> 00:35:53,640
როდესაც თქვენ წაშალოთ ფაილები პრაქტიკულად ვასუფთავებ სანაგვე ყუთს ან recycle bin,

569
00:35:53,640 --> 00:35:59,530
ამ სურათს არ ცვლის. 0S და 1s თქვენს ხისტ დისკზე არ მიდიან სადმე.

570
00:35:59,530 --> 00:36:03,930
მაგრამ ამ მაგიდასთან, ამ პატარა მონაცემთა ბაზის ჯიშები, აკეთებს ცვლილებას.

571
00:36:03,930 --> 00:36:08,750
როდესაც თქვენ წაშალოთ თქვენი რეზიუმე, ეს თითქოს ფაილი ამოღებულია ზოგიერთი გრძნობა,

572
00:36:08,750 --> 00:36:12,790
მაგრამ ყველა კომპიუტერის ამჯამად არის დაივიწყოს სადაც ეს ნივთი ცხოვრობს თქვენს ხისტ დისკზე.

573
00:36:12,790 --> 00:36:17,870
0S და 1s რომ დაკომპლექტებას თქვენი რეზიუმე ან რომელიმე ამ სხვა ფაილი დღესაც ხელუხლებლად.

574
00:36:17,870 --> 00:36:21,960
>> ასე რომ, თუ თქვენ ეს შემთხვევით, იქ მაინც არასამთავრობო ნულოვანი ალბათობის

575
00:36:21,960 --> 00:36:25,800
რომ თქვენ შეიძლება ფეხზე თქვენი მონაცემები გამოყენებით Norton Utilities ან კომერციული პროგრამული

576
00:36:25,800 --> 00:36:29,810
რომლის მიზანია ცხოვრების მოძიების 0S და 1s რომ არ სახის იქნა ობოლი,

577
00:36:29,810 --> 00:36:33,300
დავიწყებული აქ დაუტოვებიათ აქ, ასე რომ თქვენ შეგიძლიათ მიიღოთ თქვენი მონაცემები უკან.

578
00:36:33,300 --> 00:36:38,410
ან სასამართლო გამომძიებლები ერთად პოლიციის ან FBI რომ პრაქტიკულად ხისტ დისკზე

579
00:36:38,410 --> 00:36:42,550
და რეალურად ვეძებთ ნიმუში 0S და 1s რომ გამოიყურებოდეს JPEGs, გამოიყურებოდეს Excel ფაილი

580
00:36:42,550 --> 00:36:46,400
და ფეხზე რომ გზა მაშინაც კი, თუ კომპიუტერში არ დავიწყებია მათ იქ.

581
00:36:46,400 --> 00:36:49,820
ასე რომ ერთადერთი გზა ნამდვილად წაშლა მონაცემები, როგორც ჩვენ განვიხილავთ მომავალში,

582
00:36:49,820 --> 00:36:54,190
არის scrub ან wipe ფაილი ან ხისტი მიერ -

583
00:36:54,190 --> 00:36:56,540
თქვენ არ შეგიძლიათ ნამდვილად დავაღწიოთ 0S და 1s

584
00:36:56,540 --> 00:36:59,440
რადგან სხვაგვარად ნეტავ იწყება Gigabyte ხისტ დისკზე

585
00:36:59,440 --> 00:37:02,380
და ნეტავ დასრულდება up ერთად megabyte ხისტ დისკზე თუ მუდმივად იყო წაშლის,

586
00:37:02,380 --> 00:37:04,380
სიტყვასიტყვით, 0S და 1s.

587
00:37:04,380 --> 00:37:06,310
ასე რომ რას თუ თქვენ ნამდვილად სურდა საფარის თქვენი ტრეკების

588
00:37:06,310 --> 00:37:10,510
და ფუნდამენტური პრობლემა ის არის, რომ იქ მაინც 0S და 1s on დისკზე?

589
00:37:10,510 --> 00:37:14,930
მე ვხედავ ვინმეს gesticulating, რომ თქვენ ფიზიკურად შესვენება მოწყობილობა. იმუშავებს.

590
00:37:14,930 --> 00:37:19,600
[სიცილის] მაგრამ თუ ეს სახის ძვირადღირებული გადაწყვეტა, რა იქნება უფრო გონივრულად?

591
00:37:19,600 --> 00:37:23,270
Yeah. >> [სტუდენტი] გადავაწერო მათ. >> გადავაწერო მათ რა? >> [სტუდენტი] სხვა მონაცემები.

592
00:37:23,270 --> 00:37:29,070
სხვა მონაცემები. შეგიძლიათ უბრალოდ ჩაანაცვლებს დისკზე ერთად 0S ან 1s ან ყველა 0S, ყველა 1s.

593
00:37:29,070 --> 00:37:31,230
>> და ეს მართლაც რა ზოგიერთი პროგრამა აკეთებს.

594
00:37:31,230 --> 00:37:33,570
თქვენ შეგიძლიათ შეიძინოთ პროგრამული ან თუნდაც უფასოდ პროგრამული უზრუნველყოფა,

595
00:37:33,570 --> 00:37:36,610
და კიდევ აგებული, რომ Mac OS ამ დღეებში ნაკლებად ისე Windows,

596
00:37:36,610 --> 00:37:38,660
არის უნარი უსაფრთხოდ წაშალოს.

597
00:37:38,660 --> 00:37:41,960
რეალურად, თუ თქვენ გინდათ რომ ყველა პერსპექტივაში მთავარი დღეს თუ თქვენ გაქვთ Mac და ამის გაკეთება,

598
00:37:41,960 --> 00:37:45,740
თუ თქვენ მოხვდით რაღაცები თქვენს trash შეუძლია, რომ თქვენ უსაფრთხო Empty Trash,

599
00:37:45,740 --> 00:37:47,610
რომელიც ზუსტად რომ.

600
00:37:47,610 --> 00:37:53,350
იმის ნაცვლად, რომ უბრალოდ წაშლას ფაილი აქ, ეს არ წაშალოს 0S და 1s აქ,

601
00:37:53,350 --> 00:38:01,240
პირიქით, ის მხოლოდ ცვლის მათ ყველა, მაგალითად, რომ 0S და dot, dot, dot.

602
00:38:01,240 --> 00:38:05,330
ასე რომ ერთი თქვენი მომავალი psets რეალურად იყოს შეგნებულად ფეხზე მონაცემები -

603
00:38:05,330 --> 00:38:08,430
ფოტოები, რომ ჩვენ აღებულ ადამიანი, ადგილები, და რამ შესახებ კამპუსში

604
00:38:08,430 --> 00:38:12,810
რისთვისაც ჩვენ გავაკეთებ სასამართლო იმიჯი ციფრული კამერა მისი მეხსიერების ბარათი,

605
00:38:12,810 --> 00:38:17,120
რომელიც ზუსტად იგივე იდეა - და თქვენ უნდა იყოს დაუპირისპირდა რეალურად იპოვოს

606
00:38:17,120 --> 00:38:20,160
თარგების რომ წარმოადგენენ JPEGs თქვენს ხისტ დისკზე,

607
00:38:20,160 --> 00:38:23,610
ჰგავს, რომ ყოფილი სტუდენტი, რომელთა ელ წავიკითხე რამდენიმე კვირის წინ გააკეთა

608
00:38:23,610 --> 00:38:25,860
ფეხზე მისი დის ფოტოები.

609
00:38:25,860 --> 00:38:30,300
რატომ არ ვიღებთ 5 წუთიანი შესვენება აქ, და ჩვენ გადაჯგუფების ერთად უფრო მეხსიერებაში.

610
00:38:33,030 --> 00:38:38,610
ასე რომ აქ, სადაც რამ კიდევ ცოტა გონება-bending, მაგრამ ეს არის ძალიან ძლიერი ნაბიჯი

611
00:38:38,610 --> 00:38:40,480
მიმართ გაგება ამ ყველა სხვა.

612
00:38:40,480 --> 00:38:42,900
აქ არის პროგრამა მოუწოდა pointers.c.

613
00:38:42,900 --> 00:38:45,430
ეს არის შორის დღევანდელ ნიმუში კოდი.

614
00:38:45,430 --> 00:38:51,280
გაითვალისწინეთ, რომ პირველი რამდენიმე ხაზი, 19 გზით 22, ყველა ვაკეთებთ არის რაღაც GetString

615
00:38:51,280 --> 00:38:54,460
და დაბრუნების მისამართი, შენახვა მას s.

616
00:38:54,460 --> 00:38:58,380
ამიერიდან ამისთვის pset კი 3 თუ გინდათ მაგრამ pset 4 და

617
00:38:58,380 --> 00:39:01,030
სადაც შეგიძლიათ დაიწყოს მიიღოს ამ სასწავლო თვლები off თავს,

618
00:39:01,030 --> 00:39:04,030
არ არსებობს მიზეზი, რომ ვიტყვი, რომ სიმები არსებობს უქმნით.

619
00:39:04,030 --> 00:39:07,030
ეს, რა თქმა უნდა okay to დავიწყო ამბობდა char *.

620
00:39:07,030 --> 00:39:12,610
>> როგორც განზე, ონლაინ ცნობებსა და წიგნებში შეგიძლიათ ხშირად ვხედავ ვარსკვლავი შემდეგ ცვლადი.

621
00:39:12,610 --> 00:39:15,600
ალბათ კი ფართების გარშემო ორივე მხარეს იგი.

622
00:39:15,600 --> 00:39:17,680
ყველა იმ are ფუნქციურად სწორი.

623
00:39:17,680 --> 00:39:21,180
ახლა, თუმცა, ჩვენ standardize ამ მიდგომას, რათა სუპერ წმინდა

624
00:39:21,180 --> 00:39:24,000
რომ char * ჰგავს ამბობდა ხასიათი მაჩვენებელი.

625
00:39:24,000 --> 00:39:25,680
სწორედ მონაცემები ტიპის.

626
00:39:25,680 --> 00:39:28,730
და მერე სახელით ცვლადი s ამ შემთხვევაში.

627
00:39:28,730 --> 00:39:31,180
ასე რომ ჩვენ მიღებული სიმებიანი და ჩვენ მას s.

628
00:39:31,180 --> 00:39:35,180
და შემდეგ ქვევით აქ შეამჩნია, რომ მე ვაკეთებ რეალურად ცოტა მოსატყუებლად.

629
00:39:35,180 --> 00:39:39,080
ამას უწოდებენ მაჩვენებელი არითმეტიკა, რომელიც ერთგვარი სუპერ მარტივი.

630
00:39:39,080 --> 00:39:41,790
ეს უბრალოდ ნიშნავს, დაამატოთ და სხვაობა ნომრის მითითებას.

631
00:39:41,790 --> 00:39:43,660
მაგრამ ეს რეალურად მუშაობს.

632
00:39:43,660 --> 00:39:49,170
ეს პროგრამა აშკარად ბეჭდავს string s 1 სიმბოლოს თითო ხაზზე ისეთი, რომ საბოლოო ჯამში -

633
00:39:49,170 --> 00:39:54,920
ასე შეგვიძლია გააფუჭებს სადაც ეს ხდება, გააკეთოს პოინტერები, აწარმოებს პოინტერები, ნება მომეცით zoom სისტემაში

634
00:39:54,920 --> 00:39:58,940
ახლა ნება მომეცით ტიპის რაღაც HELLO და გაცნობის შეიყვანეთ

635
00:39:58,940 --> 00:40:01,080
და ეს ბეჭდავს 1 სიმბოლოს თითო ხაზზე.

636
00:40:01,080 --> 00:40:04,730
მანამდე მეორე წინ, ჩვენ გავაკეთეთ ამ მოედანზე bracket ნოტაცია.

637
00:40:04,730 --> 00:40:09,760
გვსურს აქვს ამისთვის მარყუჟის და ჩვენ გვინდა გავაკეთოთ printf of s [i] და ჩვენ გვინდა გავაკეთოთ, რომ ისევ და ისევ და ისევ

638
00:40:09,760 --> 00:40:11,950
ერთად backslash N დასასრულს თითოეული ხაზი.

639
00:40:11,950 --> 00:40:16,800
მაგრამ ამ პროგრამის სხვადასხვა. ეს პროგრამა იყენებს, სიტყვასიტყვით, არითმეტიკული.

640
00:40:16,800 --> 00:40:18,860
ასე რომ, რა ხდება აქ?

641
00:40:18,860 --> 00:40:24,720
უპირველეს ყოვლისა, სანამ ამ loop კი ახორციელებს, რა, უბრალოდ უნდა იყოს მკაფიო, არის s რეალურად?

642
00:40:24,720 --> 00:40:27,270
S არის? >> [სტუდენტი] მისამართზე. >> მისამართზე.

643
00:40:27,270 --> 00:40:32,980
>> და ეს მისამართი, იმ შემთხვევაში, Hello, პირველი პერსონაჟი, რომ სიტყვა, რომელიც თ.

644
00:40:32,980 --> 00:40:37,370
რათა არის, ამ კონკრეტულ მაგალითს, მისამართი თ.

645
00:40:37,370 --> 00:40:41,850
ასე რომ რას ნიშნავს გავაკეთოთ s + მე?

646
00:40:41,850 --> 00:40:46,280
ისე, მე იწყება 0 ამ for loop. ჩვენ გავაკეთეთ, რომ ბევრჯერ.

647
00:40:46,280 --> 00:40:49,760
მე აპირებს ახვიდეთ სიგრძეზე სიმებიანი, როგორც ჩანს.

648
00:40:49,760 --> 00:40:53,950
ამიტომ პირველ iteration ამ მარყუჟის, მე აშკარად 0.

649
00:40:53,950 --> 00:41:01,740
ასე რომ, ეს გამოხატვის ამბობს s + i - საკმაოდ, S +0--რომ აშკარად უბრალოდ s.

650
00:41:01,740 --> 00:41:04,320
რა არის * s აქ?

651
00:41:04,320 --> 00:41:08,530
ახლა ჩვენ გამოყენებით ვარსკვლავს ოდნავ სხვაგვარად.

652
00:41:08,530 --> 00:41:13,080
ნება მომეცით წავიდეთ წინ და დავაღწიოთ t რადგან ჩვენ გავაკეთეთ ვსაუბრობთ t და ასლები s.

653
00:41:13,080 --> 00:41:15,540
ახლა ჩვენ უბრალოდ მინდა ვუთხრა ამბავი ჩართვის s.

654
00:41:15,540 --> 00:41:20,090
და ა.შ. ამ ეტაპზე, მას შემდეგ, რაც ტიპის ტექსტი, ჩვენი სამყაროს გამოიყურება საკმაოდ მოსწონს ეს მოხდა ადრე

655
00:41:20,090 --> 00:41:26,630
მხოლოდ s შენახვის მისამართი თ და ზოგადად მიუთითებს სიმებიანი hello.

656
00:41:26,630 --> 00:41:33,170
თუ მე ახლა ხაზი მოსწონს * (s + I), მოდით ცდილობენ ამ გარეთ.

657
00:41:33,170 --> 00:41:40,140
ასე * (s + I). ნება მომეცით გაამარტივებს ამ რადგან ეს არის 0, ასე რომ ეს არის * (ებ +0).

658
00:41:40,140 --> 00:41:43,790
ისე, დაველოდოთ წუთში. გაამარტივონ შემდგომი. ეს არის * (s).

659
00:41:43,790 --> 00:41:47,020
კარგად, ახლა ფრჩხილებში არიან სახის სულელური, ახლა მოდით უბრალოდ * s.

660
00:41:47,020 --> 00:41:50,540
ამიტომ პირველ iteration ამ მარყუჟი, რომ ხაზი რომ გაუსვა ხაზი, 26,

661
00:41:50,540 --> 00:41:53,650
არის საკმაოდ ბევრი ექვივალენტი ბეჭდვა ამ.

662
00:41:53,650 --> 00:41:56,040
რა არის მონაცემები გაცნობის * s?

663
00:41:56,040 --> 00:42:00,770
ამ კონტექსტში, რადგან ვარსკვლავი ხდება, რომ იყოს შემდეგი s თავად,

664
00:42:00,770 --> 00:42:04,930
მაგრამ უფრო კონკრეტულად, რადგან ჩვენ აღარ გამოცხადების s,

665
00:42:04,930 --> 00:42:09,730
ჩვენ არ შექმნის ცვლადი უქმნით არ ნახსენები char * სტრიქონში 26,

666
00:42:09,730 --> 00:42:14,280
არ ნახსენები სიტყვით ტექსტი, ჩვენ უბრალოდ გამოყენებით ცვლადში s,

667
00:42:14,280 --> 00:42:19,650
თურმე ახლა ვარსკვლავი ოდნავ განსხვავებული და, admittedly, დამაბნეველი მნიშვნელობა.

668
00:42:19,650 --> 00:42:26,590
* S აქ ნიშნავს წასვლა მისამართი და ბეჭდვითი რაც არსებობს.

669
00:42:26,590 --> 00:42:33,750
რათა აქ არის, * s არის - სახის მოსწონს Chutes და კიბეები, დაიცვას arrow - აქ.

670
00:42:33,750 --> 00:42:35,850
ასე რომ, ეს არის * s.

671
00:42:35,850 --> 00:42:39,060
>> მერე რა ხდება დაბეჭდილი პირველი iteration რომ მარყუჟი შეესაბამება 26?

672
00:42:39,060 --> 00:42:42,170
მე ამობეჭდოთ% C, რომელიც placeholder for ხასიათი,

673
00:42:42,170 --> 00:42:48,520
მაშინ \ n ახალი ხაზი. * (S + I), სადაც მე არის 0 მხოლოდ ამ.

674
00:42:48,520 --> 00:42:53,670
მერე რა char შემიძლია ადგილი ამისთვის% გ? H.

675
00:42:53,670 --> 00:42:56,900
მომდევნო iteration of loop - თქვენ ალბათ შეუძლია დაინახოს, სადაც ეს ხდება -

676
00:42:56,900 --> 00:43:01,350
შემდეგი iteration მე აშკარად 1, ასე რომ, ეს იმას ნიშნავს s +1,

677
00:43:01,350 --> 00:43:05,580
და მაშინ ახლა მე გვჭირდება ფრჩხილებში რადგან ახლა ვარსკვლავი სჭირდება ვთქვა

678
00:43:05,580 --> 00:43:08,620
გადადით მეხსიერების მისამართი s +1.

679
00:43:08,620 --> 00:43:14,170
რა არის s? მოდით გააფართოვოს უკან დრო და ამბობენ, რომ ეს arrow ახლა რეალურად არ აკეთებს us ნებისმიერი მომხრეა.

680
00:43:14,170 --> 00:43:18,450
მოდით უფრო კონკრეტულად ვთქვა, რომ ეს შენახვის ნომერი 123

681
00:43:18,450 --> 00:43:25,110
რადგან დაწყება ამ სიმებიანი Hello, ეს არის მისამართი 123, ეს 124 და სხვ.

682
00:43:25,110 --> 00:43:30,550
ასე რომ მეორე iteration როდესაც მე ვამბობ, s +1 ასეთი ამბობდა 123 +1,

683
00:43:30,550 --> 00:43:35,340
სხვაგვარად ცნობილია როგორც 124, ასე რომ char იღებს დაბეჭდილი მეორე iteration?

684
00:43:35,340 --> 00:43:37,850
E საათზე მეხსიერების მისამართი 124.

685
00:43:37,850 --> 00:43:44,440
მაშინ + ერთხელ, 125, 126, 127, და ამ loop საბედნიეროდ შეწყვეტს, სანამ არ მივიღებთ აქ

686
00:43:44,440 --> 00:43:49,040
რადგან მე გამოყენებით strlen დავრწმუნდეთ, რომ მე არ ითვლიან ძალიან მაღალია.

687
00:43:49,040 --> 00:43:50,810
ასე რომ ძალიან არის იგი.

688
00:43:50,810 --> 00:43:55,000
ისევ და ისევ, ეს მხოლოდ თითქოს ჩვენ გავაკეთეთ კვირის წინ.

689
00:43:55,000 --> 00:43:59,200
ნება მომეცით წერენ ეს ხაზი ქვემოთ მიუხედავად იმისა, რომ ჩვენ არ გვსურს რომ ორივე.

690
00:43:59,200 --> 00:44:02,500
ეს არის იდენტური ახლა ამ.

691
00:44:02,500 --> 00:44:08,310
>> ასე რომ მიუხედავად იმისა, რომ ჯერ არ არის ტექსტი, როგორც ჩვენ უწოდა კვირების განმავლობაში, და მართლაც char *.

692
00:44:08,310 --> 00:44:13,270
ასე რომ, თუ ჩვენ გვინდა ვიყოთ super anal, ეს მართლაც სწორი დაწერა კონკრეტული ხასიათი

693
00:44:13,270 --> 00:44:17,490
ზე შ საიდან გამოყენებით ამ რიცხვითი მისამართები და ამ ვარსკვლავი ოპერატორი,

694
00:44:17,490 --> 00:44:20,470
მაგრამ გულწრფელად ვამბობ, ეს მხოლოდ იმდენად სუფთა. ასე რომ, ეს არ არის ცუდი.

695
00:44:20,470 --> 00:44:26,720
არანაირი მიზეზი, რომ შეწყვიტოს აკეთებს ხაზი 27 აქ, მაგრამ 26 არის ფუნქციურად იგივე,

696
00:44:26,720 --> 00:44:31,570
და ეს ფუნქციურად იგივე ზუსტად მიზეზებს, რომ ჩვენ განხილვას ჯერჯერობით.

697
00:44:31,570 --> 00:44:33,650
და ბოლოს, 29 მხოლოდ კარგი პრაქტიკის.

698
00:44:33,650 --> 00:44:38,420
Calling უფასო s ნიშნავს, რომ ახლა თქვენ იძლევიან მეხსიერების რომ GetString მისცა თქვენ

699
00:44:38,420 --> 00:44:41,630
რადგან ერთხელ, როგორც აღვნიშნე ორშაბათი, GetString კვირების განმავლობაში

700
00:44:41,630 --> 00:44:44,180
უკვე შემოღების bug თქვენს კოდი.

701
00:44:44,180 --> 00:44:46,490
შენი კოდი კვირის განმავლობაში საკმაოდ მეხსიერების გაჟონვის

702
00:44:46,490 --> 00:44:49,970
რომლითაც თქვენ უკვე სვამს GetString მეხსიერების მაგრამ თქვენ არასოდეს ვაძლევთ მას უკან.

703
00:44:49,970 --> 00:44:53,410
და ეს შეგნებულად, ჩვენს მიერ არჩეული pedagogically

704
00:44:53,410 --> 00:44:55,880
რადგან უბრალოდ ძალიან ბევრი ფიქრი დილით.

705
00:44:55,880 --> 00:44:57,710
მაგრამ ახლა ჩვენ გვჭირდება მეტი სიმეტრია.

706
00:44:57,710 --> 00:45:00,830
თუ ვთხოვ კომპიუტერში მეხსიერების, როგორც არის საქმე GetString,

707
00:45:00,830 --> 00:45:02,820
როგორც არის საქმე როგორც ჩანს ამისთვის malloc,

708
00:45:02,820 --> 00:45:07,970
თქვენ უნდა ამისთვის pset 4 Onward ასევე უფასოდ ნებისმიერი ასეთი მეხსიერება.

709
00:45:07,970 --> 00:45:11,650
გაითვალისწინეთ ეს განსხვავდება ამბობდა int n.

710
00:45:11,650 --> 00:45:15,040
თქვენ არ გჭირდებათ გასათავისუფლებლად, რადგან თქვენ არ გამოიძახა GetString

711
00:45:15,040 --> 00:45:16,890
და თქვენ არ მოვუწოდებთ malloc.

712
00:45:16,890 --> 00:45:20,610
>> და მაშინაც კი თუ თქვენ მოუწოდა GetInt როგორც ჩვენ საბოლოოდ ვხედავთ,

713
00:45:20,610 --> 00:45:25,520
GetInt არ გამოყოს მეხსიერება თქვენთვის იმიტომ, რომ თქვენ შეიძლება რეალურად გაივლის გარშემო მთელი რიცხვები

714
00:45:25,520 --> 00:45:29,430
და მოძრავი და სიმბოლო უბრალოდ გზა ჩვენ ვაკეთებთ კვირების განმავლობაში.

715
00:45:29,430 --> 00:45:33,960
სიმები, თუმცა, განსაკუთრებული, რადგან რეალურად ისინი გაერთიანების მრავალჯერადი სიმბოლო.

716
00:45:33,960 --> 00:45:37,450
ასე რომ, ისინი უბრალოდ განსხვავებული chars და მოძრავი და ints და ასე შემდეგ.

717
00:45:37,450 --> 00:45:39,980
მაგრამ ამას დაბრუნებას, რომ ხანგრძლივი.

718
00:45:39,980 --> 00:45:44,920
ნებისმიერი კითხვები მაშინ ამ დასაწყისში პოინტერები? Yeah.

719
00:45:44,920 --> 00:45:49,690
[Inaudible სტუდენტი კითხვა]

720
00:45:49,690 --> 00:45:51,440
Ah, ძალიან კარგი კითხვაა.

721
00:45:51,440 --> 00:45:55,790
ერთი იმ რამდენიმე რამ C რეალურად აკეთებს თქვენთვის, რომელიც მოსახერხებელია,

722
00:45:55,790 --> 00:46:00,110
იგი გათვლით out for, თუ რა ზომის არის მონაცემები ტიპის

723
00:46:00,110 --> 00:46:03,060
და შემდეგ აკეთებს, რომ სახის გამრავლება თქვენთვის.

724
00:46:03,060 --> 00:46:06,610
ეს არის შეუსაბამო იმ შემთხვევაში სიმბოლო, რადგან თითქმის ყოველთვის char არის 1 byte,

725
00:46:06,610 --> 00:46:08,150
ასე რომ, ეს უბრალოდ მუშაობს.

726
00:46:08,150 --> 00:46:11,220
მაგრამ გულისთვის დისკუსია, თუ თქვენ რეალურად დაბეჭდვის რიცხვებით

727
00:46:11,220 --> 00:46:15,500
და თქვენ ცდილობდნენ ამობეჭდოთ გარკვეული მნიშვნელობა s, რომელიც მიუთითებს მთელი რიცხვი,

728
00:46:15,500 --> 00:46:20,720
თქვენ ერთნაირად არ უნდა გავაკეთოთ + 4 * მე მხოლოდ იმიტომ, რომ int არის 4 ბაიტი.

729
00:46:20,720 --> 00:46:25,780
Pointer არითმეტიკული ნიშნავს, რომ C და შემდგენელი ყველაფერი რომ მათემატიკის თქვენთვის.

730
00:46:25,780 --> 00:46:29,190
ყველაფერი რაც თქვენ უნდა აღელვებს არის დათვლა წელს სახის ადამიანის გრძნობათა. Yeah.

731
00:46:29,190 --> 00:46:35,200
[სტუდენტი] თუ განაცხადოს სიმებიანი შიგნით ამისთვის მარყუჟის, გაქვთ გასათავისუფლებლად მოგვიანებით?

732
00:46:35,200 --> 00:46:36,760
კარგი კითხვაა.

733
00:46:36,760 --> 00:46:41,390
>> თუ დეკლარირებული სიმებიანი შიგნით ამისთვის მარყუჟის, გჭირდებათ გასათავისუფლებლად მოგვიანებით?

734
00:46:41,390 --> 00:46:47,520
თქვენ მხოლოდ უნდა თავისუფალი მეხსიერება, რომ თქვენ გამოყოფს ერთად GetString ან malloc.

735
00:46:47,520 --> 00:46:53,110
ასე რომ, თუ თქვენ უბრალოდ ამბობენ რაღაც - ნება მიბოძეთ Curly braces არის, ასე რომ ყველა კოდი არის დაკავშირებული.

736
00:46:53,110 --> 00:46:58,580
თუ თქვენ გააკეთეთ რამე, თუმცა buggily, ასე, char * t = s,

737
00:46:58,580 --> 00:47:03,450
თქვენ არ გჭირდებათ თავისუფალი t რადგან t არ ჩავრთოთ ნებისმიერი ნახსენები malloc ან GetString.

738
00:47:03,450 --> 00:47:08,960
თუ პირიქით გააკეთეთ თქვენ ამ, GetString, მაშინ დიახ, თქვენ უნდა უფასო ტ.

739
00:47:08,960 --> 00:47:14,350
და რეალურად, თქვენი ერთადერთი შანსი გავაკეთოთ, რომ არის შიგნით ამ მარყუჟის, იმავე საკითხის ფარგლებს

740
00:47:14,350 --> 00:47:16,060
რომ ჩვენ განიხილეს წარსულში.

741
00:47:16,060 --> 00:47:18,830
წინააღმდეგ შემთხვევაში თქვენ მინდა იყოს გამოყოფის მეხსიერება, გამოყოფის მეხსიერება, გამოყოფის მეხსიერება,

742
00:47:18,830 --> 00:47:21,230
და დასასრულს პროგრამა იმიტომ, რომ თქვენ გარეთ რომ მარყუჟი,

743
00:47:21,230 --> 00:47:24,240
t არ არსებობს, მაგრამ თქვენ არ უთხრა ოპერაციული სისტემა

744
00:47:24,240 --> 00:47:26,750
რომ თქვენ არ გვჭირდება, რომ მეხსიერების უქმნით.

745
00:47:26,750 --> 00:47:30,430
მანამდე ხანგრძლივი, ამისთვის pset 4 ან 5 ჩვენ აღჭურვა თქვენ პროგრამას სახელწოდებით Valgrind,

746
00:47:30,430 --> 00:47:34,160
რაც მსგავსი სულისკვეთებით უნდა GDB რომ ის მიიღო გარკვეულწილად of arcane ინტერფეისი,

747
00:47:34,160 --> 00:47:35,750
მაგრამ მისი მიზანი ცხოვრებაში არის დაგეხმაროთ.

748
00:47:35,750 --> 00:47:39,380
და Valgrind არის პროგრამა, რომელიც მომავალში ძებნის თქვენს პროგრამები

749
00:47:39,380 --> 00:47:42,550
ეძებს მეხსიერების ტბები, თუ არა საწყისი GetString ან malloc,

750
00:47:42,550 --> 00:47:47,800
რაც დავიწყებთ გამოყენებით უფრო როგორც ჩვენ შეწყვიტოს გამოყენებით CS50 ბიბლიოთეკა იმდენი.

751
00:47:47,800 --> 00:47:53,030
ჩვენ საბოლოოდ ახლა სახის ლექსიკა და ერთგვარი ფსიქიკური მოდელის თეორია

752
00:47:53,030 --> 00:47:55,170
რომელთანაც მოსაგვარებლად ამ გატეხილი პროგრამა.

753
00:47:55,170 --> 00:47:59,410
>> ასე რომ ამ პროგრამის გატეხილი, swap მუშაობს შიგნით swap,

754
00:47:59,410 --> 00:48:05,280
მაგრამ მას არასოდეს რეალურად მუშაობდა მთავარ რადგან ძირითად გადავიდა x და y, გაწვევას,

755
00:48:05,280 --> 00:48:07,260
და იმ გადაეცა მიერ ღირებულებების, ასე ვთქვათ.

756
00:48:07,260 --> 00:48:09,330
ასლები მათ გადაეცათ სვოპ.

757
00:48:09,330 --> 00:48:12,520
ბოლოსთვის swap, და ბ იყო მართლაც გაცვალეს,

758
00:48:12,520 --> 00:48:16,120
თუმცა, რა თქმა x და y, როგორც ჩვენ განვიხილეთ ორშაბათს, არ ყოფილა.

759
00:48:16,120 --> 00:48:19,940
ამიტომ მე ვთავაზობ, მწვანე აქ რომ ეს რეალურად გადაწყვეტა აქ.

760
00:48:19,940 --> 00:48:22,640
და ფაქტობრივად, ნება მომეცით გადაადგილება ჩემი ვარსკვლავს მხოლოდ იყოს თანმიმდევრული

761
00:48:22,640 --> 00:48:24,440
მიუხედავად იმისა, კიდევ ერთხელ, ფუნქციურად ეს მნიშვნელობა არ აქვს.

762
00:48:24,440 --> 00:48:28,730
მომავალში კვირის ჩვენ ავუხსნათ, თუ როდის და რატომ არ აქვს მნიშვნელობა.

763
00:48:28,730 --> 00:48:30,600
ასე რომ, მწვანე ახლა არის გადაწყვეტა.

764
00:48:30,600 --> 00:48:33,700
გულწრფელად ვამბობ, ეს გამოიყურება მთელი ლოტი messier რადგან ყველა ეს ვარსკვლავი.

765
00:48:33,700 --> 00:48:35,380
ნება მომეცით აღვნიშნო, ერთი რამ.

766
00:48:35,380 --> 00:48:40,040
ზედა ხაზი აქ, სადაც იგი აცხადებს, int * და int * ბ

767
00:48:40,040 --> 00:48:42,820
ძირეულად აკეთებს იმავეს, როგორც ეს ყოველთვის აქვს.

768
00:48:42,820 --> 00:48:47,070
იგი გამოცხადების 2 არგუმენტები ან პარამეტრების სვოპ,

769
00:48:47,070 --> 00:48:49,940
პირველი რომლის int მაჩვენებელი მოუწოდა,

770
00:48:49,940 --> 00:48:53,100
მეორე რომლის int მაჩვენებელი მოუწოდა ბ.

771
00:48:53,100 --> 00:48:55,770
ერთადერთი, რაც არის ახალი ამ ეტაპზე არის ის, რომ იქ ვარსკვლავი არსებობს.

772
00:48:55,770 --> 00:48:59,340
>> რას ნიშნავს ეს? არ არის int, ბ არ არის int.

773
00:48:59,340 --> 00:49:04,100
არის მისამართი int და ბ არის მისამართი სხვადასხვა int.

774
00:49:04,100 --> 00:49:06,980
Down აქ, ეს არის სადაც მე ვაღიარებ C იღებს დამაბნეველი.

775
00:49:06,980 --> 00:49:09,790
ახლა ჩვენ გამოყენებით ვარსკვლავი, მაგრამ მას აქვს სხვადასხვა მნიშვნელობა მოცემულ კონტექსტში.

776
00:49:09,790 --> 00:49:13,150
იმის გამო, რომ ჩვენ არ გამოცხადების პოინტერები როგორც ჩვენ აქ,

777
00:49:13,150 --> 00:49:15,500
აქ ჩვენ dereferencing რამ.

778
00:49:15,500 --> 00:49:21,520
ასე რომ ტექნიკურად, ვარსკვლავი ამ კონტექსტში პირველი, მეორე და მესამე ხაზის შიგნით swap

779
00:49:21,520 --> 00:49:24,560
არის dereference ოპერატორი, რომელიც მხოლოდ იმას ნიშნავს, იქ.

780
00:49:24,560 --> 00:49:27,400
ასე რომ ისევე როგორც ჩემი თითი მოჰყვა ისარი h,

781
00:49:27,400 --> 00:49:31,100
* საშუალების წასვლა რომ მისამართი და იპოვოს ჩემთვის int რომ იქ.

782
00:49:31,100 --> 00:49:34,250
* ბ საშუალებით წასვლა მისამართი და გაივლის რა არის იქ.

783
00:49:34,250 --> 00:49:40,730
მოდით მეთოდით გადასინჯვის სურათზე ორშაბათიდან ახლა გამოყენებით დასტის ჩარჩოების,

784
00:49:40,730 --> 00:49:43,130
ქვედა რომელთაგან ერთი იქნება ძირითადი,

785
00:49:43,130 --> 00:49:47,600
ზედა რომელთაგან ერთი იქნება swap,

786
00:49:47,600 --> 00:49:50,880
ასე რომ ჩვენი სამყაროს გამოიყურება, ისევე, ორშაბათს, მოსწონს ეს.

787
00:49:50,880 --> 00:49:53,620
აქ არის ბლოკი მეხსიერება, რომ ძირითადი აპირებს გამოიყენოს.

788
00:49:53,620 --> 00:49:56,520
>> შეგახსენებთ, ორშაბათიდან, რომ პროგრამა მხოლოდ ჰქონდა 2 ცვლადები,

789
00:49:56,520 --> 00:50:01,930
ერთი მოუწოდა x და ერთი მოუწოდა Y, და მე დააყენა ციფრები 1 და 2 არსებობს.

790
00:50:01,930 --> 00:50:06,580
ახლა, როდესაც მე მოვუწოდებ სვოპ მოსწონს მე ორშაბათს,

791
00:50:06,580 --> 00:50:11,000
ადრე, როდესაც მე წითელი ვერსია ამ პროგრამის, რომელიც ასე გამოიყურება,

792
00:50:11,000 --> 00:50:17,470
მე მივიღე 2 პარამეტრების, და B, და რა მივიღეთ წერენ აქ და აქ?

793
00:50:17,470 --> 00:50:21,160
მხოლოდ 1 და 2, სიტყვასიტყვით ასლები x და y.

794
00:50:21,160 --> 00:50:23,070
დღეს შევცვლით, რომ.

795
00:50:23,070 --> 00:50:28,510
დღეს ნაცვლად გადადის ints და ბ ჩვენ ვაპირებთ კორიდორი 2 მისამართები.

796
00:50:28,510 --> 00:50:34,290
იმ მისამართებზე მოხდეს აღვნიშნო, რომ ints, მაგრამ იმ მისამართებზე არ ints თავს.

797
00:50:34,290 --> 00:50:37,330
ისინი მისამართები. ეს მოსწონს საფოსტო მისამართი ნაცვლად.

798
00:50:37,330 --> 00:50:40,580
ახლა ჩვენ გვჭირდება უბრალოდ მივცეთ თავს ცოტა მეტი დეტალი ეკრანზე.

799
00:50:40,580 --> 00:50:43,250
ეს არის ჩემი კომპიუტერის მეხსიერებაში, ეს იყო მთელი დღე.

800
00:50:43,250 --> 00:50:45,120
ახლა ჩვენ გვჭირდება გარკვეული თვითნებური ნუმერაციის სქემა.

801
00:50:45,120 --> 00:50:50,580
მოდით უბრალოდ, ვამბობთ, უბრალოდ შანსი, რომ ეს არის მეხსიერების მისამართი 123, 124.

802
00:50:50,580 --> 00:50:55,660
მოდით უბრალოდ ვიტყვი, რომ ეს 125, ეს არის 126, და ა.შ., მაგრამ ეს სრულიად უკანონო.

803
00:50:55,660 --> 00:50:58,590
ჩვენ უბრალოდ უნდა გარკვეული ნუმერაციის სქემა ჩემი მეხსიერება.

804
00:50:58,590 --> 00:51:04,030
ასე რომ ახლა, როცა მე რეალურად კორიდორი x და y, მე არ ვაპირებ კორიდორი x და y;

805
00:51:04,030 --> 00:51:08,400
მე ვაპირებ კორიდორი საფოსტო მისამართი, ასე ვთქვათ, X-ის და Y

806
00:51:08,400 --> 00:51:11,870
ასე რომ, თუ რა ხდება აქ ინახება და აქ არ არის 1 და 2

807
00:51:11,870 --> 00:51:16,030
მაგრამ თუ ხედავთ ჩემს პატარა ტექსტი, რა ხდება წელს მიღებული აქ და აქ?

808
00:51:16,030 --> 00:51:23,340
[Inaudible სტუდენტი საპასუხოდ] >> ზუსტად. 123 იღებს დააყენა აქ და 124 იღებს დააყენა აქ.

809
00:51:23,340 --> 00:51:28,910
>> ახლა, როდესაც მე ვარსკვლავი სწორედ ამ პირველი ხაზი გზა აქ ყველაზე,

810
00:51:28,910 --> 00:51:34,340
ჩემი პროგრამა უბრალოდ იცის, რომ 123 და 124, მიუხედავად იმისა, რომ ისინი აშკარად რიცხვებით

811
00:51:34,340 --> 00:51:40,160
რომ ნებისმიერი ადამიანის შეეძლო შეამჩნევთ, ისინი უნდა განიმარტოს, როგორც მისამართები, numeric მისამართები.

812
00:51:40,160 --> 00:51:43,250
ისინი არ არიან და თავს ints, ისინი მისამართები,

813
00:51:43,250 --> 00:51:46,120
და ეს იმიტომ, რომ მე არ მკაფიოდ დააყენა ვარსკვლავები არსებობს.

814
00:51:46,120 --> 00:51:51,360
ახლა ჩემი პირველი, მეორე და მესამე ხაზის ფაქტობრივი კოდი რა ხდება აქ?

815
00:51:51,360 --> 00:51:53,380
მოდით დავხატოთ დანარჩენი სურათზე.

816
00:51:53,380 --> 00:51:56,980
TMP არის, ისევე, როგორც ეს იყო ორშაბათს. არაფერი სპეციალური შესახებ tmp.

817
00:51:56,980 --> 00:52:03,060
ეს მხოლოდ ადგილობრივი 32 ბიტი ცვლადი, და შიგნით რომ მე აშკარად შენახვის ღირებულება *.

818
00:52:03,060 --> 00:52:08,580
ახლა, თუ უბრალოდ თქვა tmp =, რა მე ზუსტად აქ? >> [სტუდენტი] 123.

819
00:52:08,580 --> 00:52:10,370
123. მაგრამ ეს არ არის ის, რაც მე ვაკეთებ.

820
00:52:10,370 --> 00:52:13,670
მე ვამბობ, tmp = *. Star საშუალებით წასასვლელად.

821
00:52:13,670 --> 00:52:19,370
ასე რომ აქ არის, 123. როგორ შემიძლია იქ? იმიტირებული მოსწონს არსებობს arrow.

822
00:52:19,370 --> 00:52:24,460
კარგად, იქ არის, 1. მერე რა იღებს შენახული tmp, სავარაუდოდ? მხოლოდ 1.

823
00:52:24,460 --> 00:52:29,620
ასე რომ, სხვა სიტყვებით, tmp არის *, * საშუალებების წასვლა მისამართი, რომელიც ამჟამად,

824
00:52:29,620 --> 00:52:31,320
რომელიც სავარაუდოდ 123.

825
00:52:31,320 --> 00:52:33,910
>> Okay, აქ ჩვენ ვიმყოფებით საიდან 123, ვხედავ ნომერი 1,

826
00:52:33,910 --> 00:52:35,670
ამიტომ მე ვაპირებ დააყენა ნომერი 1 იქ.

827
00:52:35,670 --> 00:52:39,020
ახლა რა გავაკეთოთ ხაზი 2, * = * ბ?

828
00:52:39,020 --> 00:52:44,570
ეს ერთი არის ცოტა უფრო ჩართული, ვინაიდან, ახლა, რა არის? ეს 123.

829
00:52:44,570 --> 00:52:50,220
ასე * სადაც? უფლება, სადაც მე ვიყავი ადრე. ასე რომ იქ. Okay.

830
00:52:50,220 --> 00:52:53,420
ახლა, ბოლოს, და მაშინ საბოლოოდ ამ დაიწყებს აზრი, იმედია,

831
00:52:53,420 --> 00:53:00,280
* ბ ნიშნავს რა B? 124. ასე რომ უნდა წავიდეთ იქ, რომელიც 2.

832
00:53:00,280 --> 00:53:03,430
რა შემიძლია დააყენა აქ?

833
00:53:03,430 --> 00:53:10,100
2 გადადის აქ იმიტომ * ბ შედის *. ასე რომ, მე გავაკეთებ, რომ.

834
00:53:10,100 --> 00:53:13,120
და შეგიძლიათ უკვე ვხედავთ, ალბათ, რომ ჩვენ კარგები უფრო ახლოს

835
00:53:13,120 --> 00:53:17,710
გადაჭრას ეს სულელური, მარტივი პრობლემის სწორად პირველად

836
00:53:17,710 --> 00:53:20,920
რადგან ახლა ჩვენ კვლავ უნდა მოგონებაა, თუ რა x იყო,

837
00:53:20,920 --> 00:53:23,230
გვაქვს 2 ცალი, admittedly, რა Y,

838
00:53:23,230 --> 00:53:25,850
მაგრამ ხაზი 3 ახლა ამბობს * ბ.

839
00:53:25,850 --> 00:53:31,080
ასე რომ აქ ბ. * ბ საშუალებით წასასვლელად. ისე სად არის საიდან 124?

840
00:53:31,080 --> 00:53:35,560
ეს აშკარად აქ. რა შემიძლია დააყენა აქ? ცხადია, tmp.

841
00:53:35,560 --> 00:53:39,600
ასე რომ ახლა მე ამ. ასე მაქვს 1 აქ და 2 აქ.

842
00:53:39,600 --> 00:53:43,560
და ახლა რაც შეეხება ყველა ამ, 123, 124, და 1?

843
00:53:43,560 --> 00:53:47,910
როგორც კი swap ანაზღაურება, ამ მეხსიერების როგორც კარგი, როგორც დაკარგა

844
00:53:47,910 --> 00:53:51,070
რადგან როგორც კი swap ანაზღაურება, ოპერაციული სისტემა

845
00:53:51,070 --> 00:53:54,190
კი იყენებს, რომ მეხსიერების მომავალში თავიდან აცილება.

846
00:53:54,190 --> 00:53:58,870
მხოლოდ ძირითადი ხსოვნას ბოლოში ამ ე.წ. დასტის ჩხირები ირგვლივ.

847
00:53:58,870 --> 00:54:01,470
>> ასე რომ, ჩვენ საბოლოოდ აქვს ახლა სამუშაო ვერსია.

848
00:54:01,470 --> 00:54:06,310
ნება მომეცით წასვლას swap.c და გავითვალისწინოთ შემდეგი.

849
00:54:06,310 --> 00:54:11,280
ზედა პროგრამით მე შეიცვალა ჩემი პროტოტიპი იქნება int * და int * ბ.

850
00:54:11,280 --> 00:54:15,000
ამიტომ ერთადერთი, რაც მე შეიცვალა წასვლა წითელი, რომელიც იყო ცუდი, მწვანე, რომელიც არის კარგი,

851
00:54:15,000 --> 00:54:17,350
არის მე დასძინა ამ ვარსკვლავს დღეს.

852
00:54:17,350 --> 00:54:21,520
მაგრამ შემდეგ ქვევით აქ სვოპ თავად მომიწია ასლი, პასტა, თუ რა იყო მხოლოდ slide.

853
00:54:21,520 --> 00:54:24,140
მე ვარსკვლავი აქ, ვარსკვლავი აქ - რომ სიას პროტოტიპი -

854
00:54:24,140 --> 00:54:27,930
და მაშინ ყველა ამ საკითხზე უკვე ვარსკვლავს გარდა tmp

855
00:54:27,930 --> 00:54:30,680
რადგან გამოყენების დროებითი ცვლადი, არაფერი ახალი იქ.

856
00:54:30,680 --> 00:54:33,040
მე უბრალოდ უნდა დროებითი შენახვისა და int.

857
00:54:33,040 --> 00:54:34,820
ამიტომ, ჩვენ არ გვჭირდება ვარსკვლავი არსებობს.

858
00:54:34,820 --> 00:54:39,310
ჩვენ უბრალოდ უნდა ვარსკვლავი ისე, რომ ჩვენ შეგვიძლია გადაკვეთს ამ სახის თვითნებური საზღვრის

859
00:54:39,310 --> 00:54:42,900
შორის 2 ფარგლებში ჩემი კომპიუტერის მეხსიერებაში.

860
00:54:42,900 --> 00:54:45,630
მაგრამ ერთი რამ ბოლო უნდა შეიცვალოს, და ალბათ glimpsed უკვე.

861
00:54:45,630 --> 00:54:48,810
სხვა რა ხაზი აშკარად სხვადასხვა არის? >> [სტუდენტი] & x.

862
00:54:48,810 --> 00:54:53,270
>> ჰო, ასე რომ 25 არის ბოლო ხაზი კოდი უნდა შეცვალოს ამ მუშაობას.

863
00:54:53,270 --> 00:54:58,360
ერთი კვირის წინ და კიდევ ორშაბათს ხაზი 25 ჰგავდა ამ, სვოპ x და y,

864
00:54:58,360 --> 00:55:02,020
და ეს მხოლოდ გატეხილი რადგან თუ ამბობთ swap (x, y)

865
00:55:02,020 --> 00:55:05,660
თქვენ მიცემის ასლები x და y to სვოპ, მაშინ ის აკეთებს რამ,

866
00:55:05,660 --> 00:55:09,080
მაგრამ თქვენ არასოდეს რეალურად შეცვლის x და y თავად.

867
00:55:09,080 --> 00:55:12,880
ისე კი, თუ თქვენ არასოდეს მინახავს ეს პერსონაჟი სანამ ერთად ampersand კოდის,

868
00:55:12,880 --> 00:55:15,860
უბრალოდ მიიღოს ამოიცნობთ. რას ampersand გავაკეთოთ, როგორც ჩანს?

869
00:55:15,860 --> 00:55:17,890
[სტუდენტი] იღებს მისამართზე. >> იღებს მისამართზე.

870
00:55:17,890 --> 00:55:21,160
ამიტომ ampersand ამბობს მომეცი მისამართი x.

871
00:55:21,160 --> 00:55:25,590
ვინ იცის, სადაც ეს არის? ეს ხდება, რომ იყოს 123. არ მაინტერესებს. უბრალოდ მომეცი მისამართი x.

872
00:55:25,590 --> 00:55:28,340
& Y ნიშნავს მომეცი მისამართი წ.

873
00:55:28,340 --> 00:55:34,450
და იმ ეტაპზე ამბავი სავსებით შეესაბამება სურათზე ჩვენ გაამახვილა მომენტში წინ.

874
00:55:34,450 --> 00:55:38,310
>> ასე რომ მე ვაღიარებ პოინტერები, რა თქმა უნდა, ჩემთვის, როცა მე პირველად დაიწყო სასწავლო ეს,

875
00:55:38,310 --> 00:55:40,570
იყო ნამდვილად ერთი უმძიმესი რამ გადაიტანოთ ჩემი აზრით გარშემო.

876
00:55:40,570 --> 00:55:43,760
მაგრამ გააცნობიეროს, განსაკუთრებით როგორც ჩვენ შევინარჩუნოთ თამაშობდა ასეთი რამ,

877
00:55:43,760 --> 00:55:48,030
თუ დაარღვიოს მისი დანგრევა ამ სუპერ მარტივი სახის ინტელექტუალურად uninteresting პრობლემები

878
00:55:48,030 --> 00:55:52,270
მხოლოდ მოძრავი ციფრები გარშემო, პასუხი ბევრი გაიგივება პოინტერები

879
00:55:52,270 --> 00:55:56,590
მართლაც შეიძლება აღნიშნულიდან გამომდინარე ძალიან საბაზისო მექანიკა.

880
00:55:56,590 --> 00:55:59,070
აქ მისამართზე. იქ ერთად ვარსკვლავი.

881
00:55:59,070 --> 00:56:03,830
ან პირიქით, აქ ampersand. გაერკვნენ, რა მისამართზე რეალურად არის.

882
00:56:03,830 --> 00:56:06,270
ყველა უფლება.

883
00:56:06,270 --> 00:56:09,000
ისე სად არის ყველა ამ მეხსიერების მოდის?

884
00:56:09,000 --> 00:56:12,360
ჩვენ შემუშავებული ამ სურათს რამდენჯერმე, და მე შენარჩუნება პერსპექტიული ჩვენ დავბრუნდებით კი

885
00:56:12,360 --> 00:56:14,920
მაგრამ აქ არის წარმომადგენლობა თქვენი კომპიუტერის მეხსიერების

886
00:56:14,920 --> 00:56:17,420
რომ ცოტა მეტი შეაფასა, ვიდრე ჩვენი chalkboard აქ არის.

887
00:56:17,420 --> 00:56:21,590
ტექსტის სეგმენტის ზედა წარმოადგენს რა მიმართ თქვენი პროგრამა?

888
00:56:21,590 --> 00:56:26,090
[Inaudible სტუდენტი საპასუხოდ] >> უკაცრავად? ვიმეორებ.

889
00:56:26,090 --> 00:56:28,660
[სტუდენტი] ფაქტობრივი პროგრამა. >> ფაქტობრივი პროგრამა.

890
00:56:28,660 --> 00:56:32,430
>> ამიტომ 0S და 1s, რომ თქვენ არ შედგენილი დაწერის შემდეგ C კოდი და შემდეგ გაშვებული Clang

891
00:56:32,430 --> 00:56:35,910
და გამოიმუშავებს 0S და 1s მთავრდება მიღების tucked იქ მეხსიერება

892
00:56:35,910 --> 00:56:38,570
რადგან, როდესაც თქვენ ორმაგად დაწკაპეთ ხატი თქვენს Mac ან PC

893
00:56:38,570 --> 00:56:43,010
ან აწარმოებს ბრძანების მოსწონს mario თქვენს სწრაფი, თქვენი 0S და 1s საწყისი დისკზე

894
00:56:43,010 --> 00:56:45,700
მისაღებად დატვირთული მეხსიერებაში ასე რომ კომპიუტერი შეიძლება მანიპულირება მათ

895
00:56:45,700 --> 00:56:47,540
და შეასრულოს ისინი უფრო სწრაფად.

896
00:56:47,540 --> 00:56:50,880
ასე რომ ინიციალიზაცია მონაცემები და uninitialized მონაცემები, ჩვენ არ გაიგო, თუ იმ,

897
00:56:50,880 --> 00:56:52,420
მაგრამ იმ უბრალოდ გლობალური ცვლადები.

898
00:56:52,420 --> 00:56:54,710
ინიციალიზაცია ნიშნავს გლობალური ცვლადები, რომ თქვენ მისცა ფასეულობები;

899
00:56:54,710 --> 00:56:59,300
uninitialized ნიშნავს გლობალური ცვლადები, რომ თქვენ არ გაუკეთებია მისცეს ფასეულობები.

900
00:56:59,300 --> 00:57:01,900
მაშინ არსებობს ამ გარემოს ცვლადები რომელიც მე სრულიად ტალღის ჩემი ხელი,

901
00:57:01,900 --> 00:57:04,860
მაგრამ ისინი იქ და რომ მაღაზიებში რამ, როგორიცაა თქვენი სახელი

902
00:57:04,860 --> 00:57:08,090
და სხვა სახის ქვედა დონეზე დეტალები.

903
00:57:08,090 --> 00:57:12,880
მაგრამ juiciest ცალი მეხსიერების ს განლაგება არის ეს საგანი მოუწოდა დასტის და ბევრი.

904
00:57:12,880 --> 00:57:17,470
დასტის ერთხელ, უნდა იყოს ნათელი, არის მეხსიერების რომ გამოიყენება, როდესაც ფუნქციები მოუწოდა,

905
00:57:17,470 --> 00:57:19,710
როდესაც არსებობს ადგილობრივი ცვლადები

906
00:57:19,710 --> 00:57:22,120
და მაშინ, როდესაც არსებობს პარამეტრების მიმდინარეობს გავიდა გარშემო.

907
00:57:22,120 --> 00:57:24,490
ყველა რომ ხდება Stack.

908
00:57:24,490 --> 00:57:29,570
ბევრი არ გვაქვს ისაუბრა, მაგრამ მიიღოს ვინ იყენებს ბევრი.

909
00:57:31,120 --> 00:57:32,690
უბრალოდ სხვადასხვა ბლოკი მეხსიერება.

910
00:57:32,690 --> 00:57:36,620
ეს ხდება, რომ იყოს აქ ზედა, მაგრამ ეს თვითნებური ფერწერული კონვენციას.

911
00:57:36,620 --> 00:57:41,670
ვინ აშკარად იყენებს მეხსიერების საწყისი ბევრი კვირების განმავლობაში?

912
00:57:41,670 --> 00:57:44,830
ეს ტექნიკურად, მაგრამ არაპირდაპირ. >> [სტუდენტი] GetString.

913
00:57:44,830 --> 00:57:47,950
GetString და malloc. ასე რომ აქ ფუნდამენტური განსხვავება.

914
00:57:47,950 --> 00:57:51,300
>> თქვენ იცით, რომ ბოლო რამდენიმე კვირის განმავლობაში, რომ თუ საჭიროა მეხსიერების, უბრალოდ განაცხადოს ცვლადი.

915
00:57:51,300 --> 00:57:54,560
თუ თქვენ გჭირდებათ უამრავი მეხსიერება, განაცხადოს მასივი უფლება შიგნით თქვენი ფუნქცია.

916
00:57:54,560 --> 00:57:59,620
მაგრამ პრობლემა ჩვენ წინაშე დგას ინახება არის თუ განაცხადოს ცვლადები ადგილობრივად შიგნით ფუნქციების,

917
00:57:59,620 --> 00:58:05,340
როგორც კი ფუნქცია დააბრუნებს, რა მოხდება ხსოვნას და იმ ცვლადების?

918
00:58:05,340 --> 00:58:09,620
უბრალოდ სახის ეს აღარ შენია, არა? უბრალოდ ქრება სახის კონცეპტუალურად.

919
00:58:09,620 --> 00:58:13,950
ეს ჯერ კიდევ ფიზიკურად არ არსებობს, ბუნებრივია, მაგრამ ეს უკვე აღარ თქვენი გამოყენების უფლება.

920
00:58:13,950 --> 00:58:17,160
ეს არის აშკარად პრობლემატური თუ გსურთ დაწეროთ ფუნქციების ცხოვრებაში

921
00:58:17,160 --> 00:58:20,440
რომ რეალურად გამოყოს მეხსიერება და არ აძლევენ უკან დაუყოვნებლივ.

922
00:58:20,440 --> 00:58:24,180
მაგალითია: GetString მიზანი ცხოვრებაში არის არ ვიცი წინასწარ

923
00:58:24,180 --> 00:58:26,390
როგორ დიდი სიმებიანი მე ვაპირებ აკრიფეთ კლავიატურაზე,

924
00:58:26,390 --> 00:58:30,390
მაგრამ რაღაც უნდა იყოს შეუძლია გამოყოს მეხსიერება გამართავს დავით ან მიესალმები

925
00:58:30,390 --> 00:58:32,860
ან მთელი ესსე, რომ მომხმარებლის შესაძლოა აკრეფილი შემოსული

926
00:58:32,860 --> 00:58:35,280
ამიტომ GetString უკვე გამოყენებით malloc.

927
00:58:35,280 --> 00:58:38,910
Malloc ამიტომ უნდა გამოყენებით არ დასტის;

928
00:58:38,910 --> 00:58:40,770
ნაცვლად ის იყენებს ამ რამ მოუწოდა ბევრი.

929
00:58:40,770 --> 00:58:44,430
არაფერია განსხვავდება მეხსიერება. ეს არ არის სწრაფად ან ნელა ან არაფერი რომ.

930
00:58:44,430 --> 00:58:46,570
უბრალოდ ფიზიკურად სხვადასხვა ადგილას.

931
00:58:46,570 --> 00:58:50,120
>> მაგრამ წესი არის ის, რომ მეხსიერების რომ გამოყოფილი ბევრი

932
00:58:50,120 --> 00:58:56,180
არასოდეს არ იქნება წაართვეს თქვენ სანამ რეკავთ - Take ამოიცნობთ - უფასო.

933
00:58:56,180 --> 00:59:00,510
პირიქით, ნებისმიერი მეხსიერების თქვენ საჭიროა დასტის მხოლოდ გამოცხადების მასივი

934
00:59:00,510 --> 00:59:03,320
ან გამოცხადების ცვლადი როგორიც ჩვენ აკეთებს კვირის განმავლობაში,

935
00:59:03,320 --> 00:59:05,640
რომ იყოს მთავრდება on Stack.

936
00:59:05,640 --> 00:59:09,550
და რომ მუშაობს დიდი 90%, მაგრამ იმ rarer შემთხვევები

937
00:59:09,550 --> 00:59:12,470
სადაც გსურთ გამოყოს მეხსიერება და შეინახოს იგი დაახლოებით,

938
00:59:12,470 --> 00:59:14,730
მაშინ თქვენ უნდა გამოვიყენოთ ფუნქცია, როგორიცაა malloc.

939
00:59:14,730 --> 00:59:19,370
ან ჩვენ არ გამოიყენება ფუნქცია, როგორიცაა GetString, რაც თავის მხრივ იყენებს malloc.

940
00:59:19,370 --> 00:59:23,300
ვნახოთ, სადაც ეს შეიძლება ჩაიშალოს და შემდეგ მიიღოს peek at Binky.

941
00:59:23,300 --> 00:59:25,820
ჩვენ დაბრუნდება, რომ მომავალში.

942
00:59:25,820 --> 00:59:29,270
აქ არის სუპერ მარტივი პროგრამა, რომელიც პირველ 2 ხაზი აკეთებს იმას?

943
00:59:29,270 --> 00:59:33,460
ინგლისურ, რას ეს პირველი 2 ხაზი კოდი გავაკეთოთ შიგნით ძირითადი?

944
00:59:33,460 --> 00:59:35,600
[Inaudible სტუდენტი საპასუხოდ]

945
00:59:35,600 --> 00:59:37,880
ფრთხილად. ეს არ მაძლევს მისამართი x ან y.

946
00:59:37,880 --> 00:59:41,840
[სტუდენტი] აძლევს მითითებას ints. >> კარგი. მომეცი 2 მითითებას რიცხვებით.

947
00:59:41,840 --> 00:59:45,130
სხვა სიტყვებით, მომეცი 2 მოცულობით მეხსიერების რომ მე შენარჩუნება ნახაზი დღეს,

948
00:59:45,130 --> 00:59:46,950
მიუხედავად იმისა, რომ მე წაშლილია ახლა, როგორც სკვერები.

949
00:59:46,950 --> 00:59:50,000
მომეცი 2 მოცულობით მეხსიერება, ერთი მოუწოდა x, ერთი მოუწოდა Y -

950
00:59:50,000 --> 00:59:54,320
ადრე დავურეკე მათ და T - და რა არის გაცნობის რომ ბლოკი მეხსიერება?

951
00:59:54,320 --> 00:59:57,160
იგი აპირებს შესანახად მისამართზე.

952
00:59:57,160 --> 00:59:59,110
ეს ტიპის int *.

953
00:59:59,110 --> 01:00:01,630
>> ასე რომ მისამართი int საბოლოოდ ცხოვრობს x,

954
01:00:01,630 --> 01:00:03,860
მისამართი int საბოლოოდ ცხოვრობს Y,

955
01:00:03,860 --> 01:00:08,460
მაგრამ თავდაპირველად, რა შიგნით x და y? ვინ იცის? Garbage ღირებულებებს.

956
01:00:08,460 --> 01:00:10,180
მას არაფერი აქვს საერთო პოინტერები.

957
01:00:10,180 --> 01:00:12,720
თუ ჩვენ არ დააყენა რაღაც არსებობს, რომელმაც იცის რა არის რეალურად არსებობს?

958
01:00:12,720 --> 01:00:18,950
ახლა x. რა ხდება აქ? ეს არის legit, რადგან X-ის მაჩვენებელი. ეს int *.

959
01:00:18,950 --> 01:00:21,870
ასე რომ, რაც იმას ნიშნავს, შემიძლია დააყენა x მისამართი ზოგიერთი ბლოკი მეხსიერება.

960
01:00:21,870 --> 01:00:25,120
რას malloc დაბრუნებას? სრულყოფილი, ის დააბრუნებს მისამართები,

961
01:00:25,120 --> 01:00:28,510
მისამართი პირველი byte წელს მთელი ბლოკი მეხსიერება.

962
01:00:28,510 --> 01:00:31,140
რამდენი ბაიტი ეს აშკარად გამოყოფის, მაგალითად, ელექტრო?

963
01:00:31,140 --> 01:00:33,510
რა ზომის int? 4.

964
01:00:33,510 --> 01:00:36,600
თუ ფიქრობთ თავში კვირაში 1, ეს არ super მნიშვნელოვანია ყოველთვის გვახსოვდეს, რომ,

965
01:00:36,600 --> 01:00:38,870
მაგრამ ამ შემთხვევაში ეს სასარგებლო იცოდეს, 4 ბაიტი.

966
01:00:38,870 --> 01:00:41,770
ასე რომ, ეს გამოყოფის თაობაზე ბევრი 4 ბაიტი

967
01:00:41,770 --> 01:00:46,110
და ეს დაბრუნების მისამართი პირველი ჩემთვის თვითნებურად.

968
01:00:46,110 --> 01:00:47,700
ახლა, რა არის x აკეთებთ?

969
01:00:47,700 --> 01:00:52,200
* X = 42 აკეთებს რა?

970
01:00:52,200 --> 01:00:57,150
თუ ამ დროისთვის ამბავი გვაქვს x, რომელიც ასე გამოიყურება რამდენიმე ნაგვის ღირებულება,

971
01:00:57,150 --> 01:01:04,120
ამ არის Y ზოგიერთ ნაგვის ღირებულება, ახლა ხაზი 3 მე გამოყოფილი 4 ბაიტი.

972
01:01:04,120 --> 01:01:06,950
ეს სურათი არსებითად ასე გამოიყურება.

973
01:01:06,950 --> 01:01:12,010
ან უფრო კონკრეტულად, თუ ეს თვითნებური მისამართი 123, ეს არის ის, რაც ჩვენი ამბავი ახლა ჰგავს.

974
01:01:12,010 --> 01:01:23,940
* X = 42 ახლა ნიშნავს რა? ეს იმას ნიშნავს, გადადით მისამართზე 123 და ამით ხმების 42 იქ.

975
01:01:23,940 --> 01:01:26,220
მე არ უნდა მიაპყროს ამ ხაზების რადგან ჩვენ არ ვაკეთებთ სტრიქონები.

976
01:01:26,220 --> 01:01:29,480
>> მე უნდა მხოლოდ წერილობითი მას მოსწონს, და მხოლოდ სადემონსტრაციოდ ის გულისთვის,

977
01:01:29,480 --> 01:01:33,240
42 როგორც int ტიპის იკავებს დიდი ადგილი, 4 ბაიტი.

978
01:01:33,240 --> 01:01:35,960
ასე რომ, რა მოხდა იქ, მაგრამ პრობლემა არის.

979
01:01:35,960 --> 01:01:40,580
* Y = 13. რა მოხდება აქ?

980
01:01:40,580 --> 01:01:46,470
პრობლემა ის არის, * Y ჩვენს გამარტივებული მსოფლიოს მხოლოდ იმას ნიშნავს, გადადით მისამართზე წ.

981
01:01:46,470 --> 01:01:48,590
რა Y? ეს რაღაც ნაგავი ღირებულება.

982
01:01:48,590 --> 01:01:53,150
მოდით ვივარაუდოთ, რომ ნაგვის ღირებულება შეადგენს 5551212, რაღაც გიჟური იგრძნობა.

983
01:01:53,150 --> 01:01:56,750
* Y საშუალებით წასვლა მივმართო 5551212.

984
01:01:56,750 --> 01:02:00,450
ასეთი მეტი აქ. ის არ არსებობს, მაგალითად.

985
01:02:00,450 --> 01:02:05,310
ასე * Y იღებს 13 საშუალებებით ვცდილობ გავამახვილო 13 აქ. ის არ არსებობს.

986
01:02:05,310 --> 01:02:08,790
მე გადააჭარბა სეგმენტი დაფაზე. რა მივიღო?

987
01:02:08,790 --> 01:02:14,930
რომ cryptic გაგზავნა სეგმენტაცია ბრალია, რადგან ვცდილობ დასვა მეხსიერება

988
01:02:14,930 --> 01:02:19,470
ღირებულება მოსწონს 13 ადგილზე რომ არ არსებობს.

989
01:02:19,470 --> 01:02:23,900
დანარჩენი პროგრამა შესაძლოა მუშაობა okay, მაგრამ მანამდე ეს არ.

990
01:02:23,900 --> 01:02:25,350
მოდით ცდილობენ ვუთხრა ეს ამბავი.

991
01:02:25,350 --> 01:02:27,830
ჩვენ დავბრუნდებით რომ ერთხელ ჩვენ ვისაუბრეთ hex.

992
01:02:27,830 --> 01:02:30,290
მოდით დავუბრუნდეთ ამ და დადოს ამ რამ მოუწოდა Binky,

993
01:02:30,290 --> 01:02:33,710
რომელიც გაწვევას არის სტენფორდის პროფესორი ზის სახლში თამაშობდა claymation,

994
01:02:33,710 --> 01:02:36,380
ვუთხრა ამბავი ზუსტად რომ იმავე პროგრამით.

995
01:02:36,380 --> 01:02:40,580
უბრალოდ დაახლოებით 3 წუთის განმავლობაში. აქ Binky.

996
01:02:40,580 --> 01:02:45,030
[კაცი პარლამენტის თავმჯდომარესთან video] Hey Binky, ვიღვიძებ. დროა მაჩვენებელი გართობა.

997
01:02:45,030 --> 01:02:50,080
[Binky] რა არის რომ? ბუნებაში პოინტერები? ოჰ, GOODY!

998
01:02:50,080 --> 01:02:53,700
[კაცი სპიკერი] ისე, უნდა დავიწყოთ, ვფიქრობ ჩვენ ვაპირებთ გვჭირდება რამდენიმე მითითებას.

999
01:02:53,700 --> 01:02:57,890
>> [Binky] Okay. ეს კოდი გამოყოფს 2 პოინტერები რომელიც შეიძლება აღვნიშნო, რომ რიცხვებით.

1000
01:02:57,890 --> 01:03:02,220
[კაცი სპიკერი] Okay. ისე, მე ვხედავ 2 პოინტერები, მაგრამ ისინი არ ჩანს, მიუთითებს არაფერი.

1001
01:03:02,220 --> 01:03:05,550
[Binky] სწორედ უფლება. თავდაპირველად, პოინტერები არ აღვნიშნო, რომ არაფერს.

1002
01:03:05,550 --> 01:03:09,270
რამ მათ აღვნიშნო, რომ უწოდებენ pointees და ხუფებით დახურეს არის ცალკე ნაბიჯი.

1003
01:03:09,270 --> 01:03:12,330
[კაცი სპიკერი] Oh, უფლება, უფლება. ვიცოდი, რომ. Pointees განცალკევებული.

1004
01:03:12,330 --> 01:03:15,630
Er, ასე როგორ გამოყოფს pointee?

1005
01:03:15,630 --> 01:03:21,510
[Binky] Okay. ეს კოდი გამოყოფს ახალი რიცხვი pointee, და ეს ნაწილი ადგენს x აღვნიშნო მას.

1006
01:03:21,510 --> 01:03:23,500
[კაცი სპიკერი] Hey, რომ უკეთესია.

1007
01:03:23,500 --> 01:03:26,030
ასე რომ ეს რაღაც. >> [Binky] Okay.

1008
01:03:26,030 --> 01:03:30,300
მე dereference კურსორი x შესანახად ხმების 42 მის pointee.

1009
01:03:30,300 --> 01:03:34,410
ამ შეასრულა მე დაგჭირდებათ ჩემი ჯადოსნური ჯოხი of dereferencing.

1010
01:03:34,410 --> 01:03:38,610
[კაცი სპიკერი] შენი ჯადოსნური ჯოხი of dereferencing? სწორედ დიდი.

1011
01:03:38,610 --> 01:03:44,230
[Binky] ეს არის ის, რაც კოდი ჰგავს. მე უბრალოდ შეიქმნა ნომერი და ... [Popping sound]

1012
01:03:44,230 --> 01:03:46,100
[კაცი სპიკერი] Hey გამოიყურება, იქ მიდის.

1013
01:03:46,100 --> 01:03:50,990
ამით dereference on x შემდეგნაირად arrow წვდომისათვის მისი pointee,

1014
01:03:50,990 --> 01:03:53,230
ამ შემთხვევაში შესანახად 42 იქ.

1015
01:03:53,230 --> 01:03:57,630
Hey, სცადეთ ეს შესანახად ნომერი 13 გზით სხვა მაჩვენებელი, Y.

1016
01:03:57,630 --> 01:04:03,250
[Binky] Okay. მე უბრალოდ მეტი აქ Y და მიიღეთ ხმების 13 შეიქმნა

1017
01:04:03,250 --> 01:04:08,360
და შემდეგ მიიღოს კვერთხის of dereferencing და მხოლოდ ... [Buzzing sound] Whoa!

1018
01:04:08,360 --> 01:04:10,980
[კაცი სპიკერი] Oh hey, რომ არ მუშაობდა.

1019
01:04:10,980 --> 01:04:14,870
>> ამბობენ, Binky, არა მგონია, dereferencing Y არის კარგი იდეა

1020
01:04:14,870 --> 01:04:17,880
რადგან შექმნის pointee არის ცალკე ნაბიჯი

1021
01:04:17,880 --> 01:04:19,850
და არა მგონია, ჩვენ ოდესმე ეს.

1022
01:04:19,850 --> 01:04:21,770
[Binky] Hmm, კარგი წერტილი.

1023
01:04:21,770 --> 01:04:26,640
[კაცი სპიკერი] Yeah. ჩვენ გამოყოფილი მაჩვენებელი y მაგრამ ჩვენ არასოდეს ვაყენებთ მას აღვნიშნო, რომ pointee.

1024
01:04:26,640 --> 01:04:28,780
[Binky] Hmm, ძალიან დაკვირვებათა.

1025
01:04:28,780 --> 01:04:30,690
[კაცი სპიკერი] Hey, თქვენ ეძებთ კარგი იქ, Binky.

1026
01:04:30,690 --> 01:04:34,160
შეგიძლიათ დაფიქსირება ისე, რომ Y რაოდენობა იმავე pointee როგორც x? >> [Binky] რა თქმა უნდა.

1027
01:04:34,160 --> 01:04:37,100
მე გამოიყენოთ ჩემი ჯადოსნური ჯოხი of მაჩვენებელი საბუთი.

1028
01:04:37,100 --> 01:04:39,070
[კაცი სპიკერი] ის არის, რომ იქნება პრობლემა, როგორიცაა წინაშე?

1029
01:04:39,070 --> 01:04:40,840
[Binky] არა, ეს არ შეეხოთ pointees.

1030
01:04:40,840 --> 01:04:44,780
უბრალოდ ცვლის ერთ მომცეთ აღვნიშნო, რომ იგივე რამ, როგორც სხვა. [Popping sound]

1031
01:04:44,780 --> 01:04:48,570
[კაცი სპიკერი] Oh, ვხედავ. ახლა Y რაოდენობა იმავე ადგილას, როგორც x.

1032
01:04:48,570 --> 01:04:51,140
ასე რომ დაველოდოთ. ახლა Y დაფიქსირდა. მას აქვს pointee.

1033
01:04:51,140 --> 01:04:54,520
ასე, რომ თქვენ შეგიძლიათ სცადოთ კვერთხის of dereferencing კვლავ გამოაგზავნოს 13 დასრულდა.

1034
01:04:54,520 --> 01:04:58,130
[Binky] Uh, okay. აქ გადის. [Popping sound]

1035
01:04:58,130 --> 01:05:01,250
[კაცი სპიკერი] Hey, შევხედოთ, რომ. ახლა dereferencing სამუშაოები წ.

1036
01:05:01,250 --> 01:05:05,200
და რადგან მითითებები გაზიარებას, რომ ერთი pointee, ორივე ვხედავთ 13.

1037
01:05:05,200 --> 01:05:06,910
[Binky] ჰო, გაზიარება. როგორიც არ უნდა იყოს.

1038
01:05:06,910 --> 01:05:08,880
>> აქედან გამომდინარე, ჩვენ ვაპირებთ გადართვის ადგილებში ახლა?

1039
01:05:08,880 --> 01:05:11,420
[კაცი სპიკერი] Oh look, ჩვენ გარეთ დრო. >> [Binky] მაგრამ -

1040
01:05:11,420 --> 01:05:13,880
[კაცი სპიკერი] აბა გაიხსენეთ 3 კურსორი წესები.

1041
01:05:13,880 --> 01:05:18,630
ხმების 1, ძირითადი სტრუქტურა არის ის, რომ თქვენ გაქვთ მაჩვენებელი და ეს მიუთითებს იმ pointee.

1042
01:05:18,630 --> 01:05:23,120
მაგრამ კურსორი და pointee არიან ცალკე და საერთო შეცდომა შექმნას მაჩვენებელი

1043
01:05:23,120 --> 01:05:25,680
მაგრამ დავიწყება მისცეს მას pointee.

1044
01:05:25,680 --> 01:05:29,580
ხმების 2, კურსორი dereferencing იწყება კურსორი და შეასრულებს arrow მეტი

1045
01:05:29,580 --> 01:05:31,060
წვდომისათვის მისი pointee.

1046
01:05:31,060 --> 01:05:34,340
როგორც ვიცით, მუშაობს მხოლოდ მაშინ თუ არსებობს pointee,

1047
01:05:34,340 --> 01:05:36,460
რაც სახის იღებს თავში გამორიცხავს ნომერი 1.

1048
01:05:36,460 --> 01:05:39,870
ხმების 3, კურსორი დავალება იღებს ერთ კურსორი და ცვლის მას

1049
01:05:39,870 --> 01:05:42,390
უნდა აღვნიშნო, რომ იგივე pointee მორიგ მაჩვენებელი.

1050
01:05:42,390 --> 01:05:45,890
ამიტომ მას შემდეგ, რაც დავალება, 2 პოინტერები იქნება აღვნიშნო, რომ იგივე pointee.

1051
01:05:45,890 --> 01:05:47,800
ზოგჯერ, რომ ე.წ. გაზიარების.

1052
01:05:47,800 --> 01:05:50,910
>> და ეს ყველაფერი არსებობს, რათა ის რეალურად. Bye-bye არის.

1053
01:05:50,910 --> 01:05:55,840
ეს არის Binky. ეს არის CS50. ჩვენ დავინახავთ, თქვენ მომავალ კვირას. [ტაში]

1054
01:05:55,840 --> 01:05:59,000
>> [CS50.TV]