1
00:00:00,000 --> 00:00:02,520
[Powered by Google Translate] [ნაწილი 4 - უფრო კომფორტული]

2
00:00:02,520 --> 00:00:04,850
[Rob Bowden - ჰარვარდის უნივერსიტეტი]

3
00:00:04,850 --> 00:00:07,370
[ეს არის CS50. - CS50.TV]

4
00:00:08,920 --> 00:00:13,350
ჩვენ გვყავს Quiz ხვალ, იმ შემთხვევაში თუ თქვენ ბიჭები არ იცოდა, რომ.

5
00:00:14,810 --> 00:00:20,970
ეს ძირითადად ყველაფერზე თქვენ შეეძლო ჩანს კლასის ან უნდა გენახათ კლასში.

6
00:00:20,970 --> 00:00:26,360
რომელიც მოიცავს მითითებას, თუმცა ისინი ძალიან ბოლო თემას.

7
00:00:26,360 --> 00:00:29,860
თქვენ მაინც უნდა გვესმოდეს, მაღალი დონის მათ.

8
00:00:29,860 --> 00:00:34,760
რამე რომ იყო წასული მეტი კლასში თქვენ უნდა გვესმოდეს, რომ ვიქტორინა.

9
00:00:34,760 --> 00:00:37,320
ასე რომ თუ თქვენ გაქვთ შეკითხვები მათზე, შეგიძლიათ ვთხოვთ ახლა.

10
00:00:37,320 --> 00:00:43,280
მაგრამ ეს იქნება ძალიან სტუდენტი ეგიდით სხდომა, სადაც თქვენ ბიჭები კითხვის დასმის,

11
00:00:43,280 --> 00:00:45,060
ასე იმედია ხალხს კითხვები.

12
00:00:45,060 --> 00:00:48,020
ვინმეს აქვს კითხვები?

13
00:00:49,770 --> 00:00:52,090
დიახ. >> [სტუდენტი] შეგიძლიათ წასვლა მეტი პოინტერები ერთხელ?

14
00:00:52,090 --> 00:00:54,350
მე წასვლა მეტი პოინტერები.

15
00:00:54,350 --> 00:00:59,180
ყველა თქვენი ცვლადები აუცილებლად ცხოვრობს მეხსიერება,

16
00:00:59,180 --> 00:01:04,450
მაგრამ, როგორც წესი, თქვენ არ ინერვიულოთ, რომ და უბრალოდ ამბობენ x + 2 და Y + 3

17
00:01:04,450 --> 00:01:07,080
და შემდგენელი იქნება გაერკვნენ, სადაც ყველაფერი ცხოვრობს თქვენთვის.

18
00:01:07,080 --> 00:01:12,990
ერთხელ თქვენ საქმე გჭირდებათ, ახლა თქვენ მკაფიოდ გამოყენებით იმ მეხსიერების მისამართები.

19
00:01:12,990 --> 00:01:19,800
ასე რომ ერთი ცვლადი იქნება მხოლოდ ოდესმე ცხოვრობს მარტოხელა მისამართი ნებისმიერ მოცემულ დროს.

20
00:01:19,800 --> 00:01:24,040
თუ გვინდა განვაცხადოთ, მაჩვენებელი, თუ რა ტიპის აპირებს გამოიყურებოდეს?

21
00:01:24,040 --> 00:01:26,210
>> მინდა განვაცხადო, კურსორი გვ. რას ტიპის გამოიყურებოდეს?

22
00:01:26,210 --> 00:01:33,530
[სტუდენტი] int * p. >> Yeah. ასე int * p.

23
00:01:33,530 --> 00:01:38,030
და როგორ უნდა იყოს იგი პასუხისმგებელი x? >> [სტუდენტი] Ampersand.

24
00:01:40,540 --> 00:01:45,300
[Bowden] ასე ampersand არის სიტყვასიტყვით მოუწოდა მისამართი ოპერატორს.

25
00:01:45,300 --> 00:01:50,460
ამიტომ როდესაც ვამბობ, რომ & x ის მიღების მეხსიერების მისამართი ცვლადი x.

26
00:01:50,460 --> 00:01:56,790
ახლა მაქვს მაჩვენებელი P, და სადმე ჩემი კოდი შემიძლია * P

27
00:01:56,790 --> 00:02:02,960
ან მე ვერ გამოიყენებს x და ეს იქნება ზუსტად იგივე რამ.

28
00:02:02,960 --> 00:02:09,520
(* P). რა არის ეს აკეთებს? რას ნიშნავს ვარსკვლავი?

29
00:02:09,520 --> 00:02:13,120
[სტუდენტი] ეს ნიშნავს ღირებულება იმ ეტაპზე. >> Yeah.

30
00:02:13,120 --> 00:02:17,590
ასე რომ, თუ დავაკვირდებით, ეს შეიძლება იყოს ძალიან სასარგებლო შესამუშაევბლად დიაგრამების

31
00:02:17,590 --> 00:02:22,230
როდესაც ეს პატარა ყუთი მეხსიერების x, რომელიც ხდება აქვს ღირებულება 4,

32
00:02:22,230 --> 00:02:25,980
მაშინ ჩვენ გვაქვს პატარა ყუთი მეხსიერების P,

33
00:02:25,980 --> 00:02:31,590
და ა.შ. P მიუთითებს x, ამიტომ ჩვენ მიაპყროს arrow საწყისი P to x.

34
00:02:31,590 --> 00:02:40,270
ასე რომ, როდესაც ჩვენ ვამბობთ * P ჩვენ ვამბობთ, წასვლა ყუთი რომ არის გვ.

35
00:02:40,270 --> 00:02:46,480
Star არის დაიცვას arrow და მერე რაც გაგიხარდებათ, რომ ყუთში უფლება არსებობს.

36
00:02:46,480 --> 00:03:01,090
ასე რომ შემიძლია ვთქვა * p = 7 და რომ წავა ყუთი რომ არის X და ცვლილება, რომელიც მას 7.

37
00:03:01,090 --> 00:03:13,540
ან მე შეიძლება ითქვას, int z = * P * 2; რაც გაუგებარია, რადგან ეს ვარსკვლავი, ვარსკვლავი.

38
00:03:13,540 --> 00:03:19,230
ერთ ვარსკვლავს dereferencing P, სხვა ვარსკვლავს გამრავლებით მიერ 2.

39
00:03:19,230 --> 00:03:26,780
გაითვალისწინეთ შემეძლო მხოლოდ ისევე შეცვალა * P ერთად x.

40
00:03:26,780 --> 00:03:29,430
თქვენ შეგიძლიათ გამოიყენოთ ისინი იგივე გზით.

41
00:03:29,430 --> 00:03:38,000
და შემდეგ მოგვიანებით შემიძლია აქვს P წერტილი სრულიად ახალი რამ.

42
00:03:38,000 --> 00:03:42,190
მე შემიძლია მხოლოდ ვთქვა, P = &z;

43
00:03:42,190 --> 00:03:44,940
ახლა P აღარ მიუთითებს x, ეს მიუთითებს ჩ.

44
00:03:44,940 --> 00:03:50,510
და ნებისმიერ დროს გავაკეთო * P ეს იგივე როგორც აკეთებს z.

45
00:03:50,510 --> 00:03:56,170
ასე სასარგებლო რამ შესახებ ეს ერთხელ ჩვენ ვიწყებთ მისაღებად შევიდა ფუნქციები.

46
00:03:56,170 --> 00:03:59,790
>> ეს სახის აზრი არ განაცხადოს მაჩვენებელი, რომელიც მიუთითებს რაიმე

47
00:03:59,790 --> 00:04:03,140
და შემდეგ, თქვენ მხოლოდ dereferencing ეს

48
00:04:03,140 --> 00:04:06,060
როდესაც თქვენ შეეძლო გამოყენებული ორიგინალური ცვლადი იწყება.

49
00:04:06,060 --> 00:04:18,190
მაგრამ როდესაც თქვენ შეღწევას ფუნქციები - ასე ვთქვათ ჩვენ გვაქვს რამდენიმე ფუნქცია, int foo,

50
00:04:18,190 --> 00:04:32,810
რომ იღებს მაჩვენებელი და მხოლოდ ს * p = 6;

51
00:04:32,810 --> 00:04:39,990
როგორც ჩვენ ვნახეთ ადრე ერთად swap, ვერ გააკეთებს ეფექტური swap და ცალკე ფუნქცია

52
00:04:39,990 --> 00:04:45,180
მხოლოდ გავლით რიცხვებით რადგან ყველაფერი C ყოველთვის ავლით ღირებულება.

53
00:04:45,180 --> 00:04:48,360
მაშინაც კი, როდესაც თქვენ ავლით პოინტერები თქვენ ავლით ღირებულება.

54
00:04:48,360 --> 00:04:51,940
ეს უბრალოდ ისე ხდება, რომ ეს ღირებულებები მეხსიერების მისამართები.

55
00:04:51,940 --> 00:05:00,770
ამიტომ როდესაც ვამბობ, რომ foo (P); მე ჩაბარების მაჩვენებელი შევიდა ფუნქცია foo

56
00:05:00,770 --> 00:05:03,910
და შემდეგ foo აკეთებს * p = 6;

57
00:05:03,910 --> 00:05:08,600
ასე რომ შიგნით რომ ფუნქცია, * P კვლავ ექვივალენტი x,

58
00:05:08,600 --> 00:05:12,720
მაგრამ მე მას ვერ გამოიყენებს x შიგნით რომ ფუნქცია, რადგან ეს არ scoped ფარგლებში, რომ ფუნქცია.

59
00:05:12,720 --> 00:05:19,510
ასე * p = 6 ეს არის ერთადერთი გზა მე შეუძლიათ ადგილობრივი ცვლადი სხვა ფუნქცია.

60
00:05:19,510 --> 00:05:23,600
ან, ასევე, მითითებები ერთადერთი გზა მე შეუძლიათ ადგილობრივი ცვლადი სხვა ფუნქცია.

61
00:05:23,600 --> 00:05:31,600
[სტუდენტი] ვთქვათ თქვენ სურდა დაბრუნების მაჩვენებელი. როგორ ზუსტად არ იცით ეს?

62
00:05:31,600 --> 00:05:44,270
[Bowden] დაბრუნება კურსორი როგორც რაღაც int y = 3; დაბრუნების & Y? >> [სტუდენტი] Yeah.

63
00:05:44,270 --> 00:05:48,480
[Bowden] Okay. თქვენ არასდროს არ უნდა ამის გაკეთება. ეს არის ცუდი.

64
00:05:48,480 --> 00:05:59,480
ვფიქრობ ვნახე ამ ლექციის სლაიდები თქვენ დაიწყო ვხედავთ ამ მთელი დიაგრამის მეხსიერება

65
00:05:59,480 --> 00:06:02,880
სადაც აქ თქვენ მოხვდით მეხსიერების მისამართი 0

66
00:06:02,880 --> 00:06:09,550
და ქვევით აქ თქვენ გაქვთ მეხსიერების მისამართი 4 gigs ან 2 დან 32.

67
00:06:09,550 --> 00:06:15,120
ასეა, მაშინ თქვენ მოხვდით რაღაცები და რაღაცები და შემდეგ თქვენ გაქვთ თქვენი დასტის

68
00:06:15,120 --> 00:06:21,780
და თქვენ მოხვდით თქვენი ბევრი, რომელიც უბრალოდ დაიწყო სწავლის შესახებ, იზრდებოდა.

69
00:06:21,780 --> 00:06:24,390
[სტუდენტი] არ არის ბევრი ზემოთ დასტის?

70
00:06:24,390 --> 00:06:27,760
>> Yeah. ბევრი არის თავზე, არ არის ეს? >> [სტუდენტი] ისე, მან 0 თავზე.

71
00:06:27,760 --> 00:06:30,320
[სტუდენტი] Oh, მან 0 თავზე. >> [სტუდენტი] Oh, okay.

72
00:06:30,320 --> 00:06:36,060
შენიშვნა: Anywhere ერთად CS50 თქვენ აპირებს დანახვა ამ გზით. >> [სტუდენტი] Okay.

73
00:06:36,060 --> 00:06:40,290
უბრალოდ, როდესაც თქვენ პირველი ხედავს stacks,

74
00:06:40,290 --> 00:06:45,000
მოეწონა, როცა ფიქრობთ დასტის ფიქრობთ დაწყობა რამ თავზე ერთმანეთს.

75
00:06:45,000 --> 00:06:50,810
ამიტომ, ჩვენ გვსურს წავახალისოთ Flip ეს დაახლოებით ასე დასტის იზრდება მოსწონს დასტის ჩვეულებრივ აკეთებთ

76
00:06:50,810 --> 00:06:55,940
ნაცვლად დასტის ჩამოკიდებული ქვემოთ. >> [სტუდენტი] ნუ heaps ტექნიკურად იზრდებიან ძალიან, თუმცა?

77
00:06:55,940 --> 00:07:01,100
ეს დამოკიდებულია, რაც თქვენ გულისხმობთ იზრდებიან.

78
00:07:01,100 --> 00:07:04,010
დასტის და ბევრი ყოველთვის იზრდებოდნენ საპირისპირო მიმართულებით.

79
00:07:04,010 --> 00:07:09,420
დასტის ყოველთვის იზრდებოდა, იმ გაგებით, რომ ის იზრდებოდა

80
00:07:09,420 --> 00:07:12,940
მიმართ უმაღლესი მეხსიერების მისამართები, და ბევრი იზრდება ქვევით

81
00:07:12,940 --> 00:07:17,260
რომ ის მზარდი მიმართ ქვედა მეხსიერების მისამართები.

82
00:07:17,260 --> 00:07:20,250
ასე რომ ყველაზე არის 0 და ბოლოში არის მაღალი მეხსიერება მისამართები.

83
00:07:20,250 --> 00:07:26,390
ისინი ორივე იზრდება, მხოლოდ დაპირისპირებულ მიმართულებით.

84
00:07:26,390 --> 00:07:29,230
[სტუდენტი] მე მხოლოდ იმას ნიშნავდა, რომ რადგან თქვენ თქვით თქვენ დააყენა დასტის ქვედა

85
00:07:29,230 --> 00:07:33,640
რადგანაც როგორც ჩანს უფრო ინტუიტიური რადგან დასტის დაიწყოს ზედა ბევრი,

86
00:07:33,640 --> 00:07:37,520
ბევრი არის თავზე თავად ძალიან, ასე that's - >> Yeah.

87
00:07:37,520 --> 00:07:44,960
თქვენ ასევე ვფიქრობ ბევრი როგორც იზრდებოდა და უფრო დიდი, მაგრამ დასტის მით უმეტეს.

88
00:07:44,960 --> 00:07:50,280
ამიტომ დასტის არის ერთი, რომ ჩვენ სახის სურს, იზრდებოდა.

89
00:07:50,280 --> 00:07:55,390
მაგრამ ყველგან გადავხედავთ სხვაგვარად აპირებს ნახოთ მისამართზე 0 ზედა

90
00:07:55,390 --> 00:07:59,590
და უმაღლესი მეხსიერების მისამართი ბოლოში, ასე რომ ეს არის თქვენი ჩვეულებრივი ხედი მეხსიერება.

91
00:07:59,590 --> 00:08:02,100
>> გაქვთ შეკითხვა?

92
00:08:02,100 --> 00:08:04,270
[სტუდენტი] შეგიძლიათ გვითხრათ უფრო მეტი ბევრი?

93
00:08:04,270 --> 00:08:06,180
Yeah. მე მისაღებად რომ მეორე.

94
00:08:06,180 --> 00:08:12,220
პირველი, ბრუნდება რატომ დაბრუნების & Y არის ცუდი რამ,

95
00:08:12,220 --> 00:08:18,470
on დასტის გაქვთ bunch of დასტის ფარგლებში, რომელიც წარმოადგენს ყველა ფუნქციებს

96
00:08:18,470 --> 00:08:20,460
რომლებიც მოუწოდა.

97
00:08:20,460 --> 00:08:27,990
ასე იგნორირება წინა ნივთები, ზევით თქვენი დასტის ყოველთვის იქნება მთავარი ფუნქცია

98
00:08:27,990 --> 00:08:33,090
რადგან ეს არის ის პირველი ფუნქცია, რომელიც მიმდინარეობს მოუწოდა.

99
00:08:33,090 --> 00:08:37,130
და მაშინ როცა რეკავთ სხვა ფუნქცია, დასტის აპირებს იზრდება ქვევით.

100
00:08:37,130 --> 00:08:41,640
ასე რომ, თუ მოვუწოდებ ზოგიერთი ფუნქცია, foo, და იგი იღებს საკუთარი დასტის ჩარჩო,

101
00:08:41,640 --> 00:08:47,280
მას შეუძლია მოვუწოდებთ ზოგიერთი ფუნქცია, ბარი; იგი იღებს საკუთარი დასტის ჩარჩო.

102
00:08:47,280 --> 00:08:49,840
და ბარი შეიძლება იყოს რეკურსიული და ეს შეიძლება მოუწოდოს თავად,

103
00:08:49,840 --> 00:08:54,150
და ისე, რომ მეორე ზარი ბარი აპირებს საკუთარი დასტის ჩარჩო.

104
00:08:54,150 --> 00:08:58,880
და მერე რა მიდის ამ დასტის ფარგლებში ყველა ადგილობრივი ცვლადები

105
00:08:58,880 --> 00:09:03,450
და ყველა ფუნქციის არგუმენტები, რომ -

106
00:09:03,450 --> 00:09:08,730
ნებისმიერი რამ, რომლებიც ადგილობრივად scoped ამ ფუნქციის წასვლა ამ დასტის ფარგლებში.

107
00:09:08,730 --> 00:09:21,520
ასე რომ, რაც იმას ნიშნავს, როდესაც ვთქვი რაღაც ბარი არის ფუნქცია,

108
00:09:21,520 --> 00:09:29,270
მე უბრალოდ აპირებს გამოაცხადოს რიცხვი და შემდეგ დაბრუნდნენ მომცეთ, რომ მთელი რიცხვი.

109
00:09:29,270 --> 00:09:33,790
ასე რომ სად Y ცხოვრობენ?

110
00:09:33,790 --> 00:09:36,900
[სტუდენტი] Y ცხოვრობს ბარი. >> [Bowden] Yeah.

111
00:09:36,900 --> 00:09:45,010
სადღაც ამ პატარა მოედანზე მეხსიერების littler მოედანზე, რომელსაც აქვს Y მას.

112
00:09:45,010 --> 00:09:53,370
როდესაც მე დაბრუნებას & Y, მე დაბრუნების მომცეთ ამ პატარა ბლოკი მეხსიერება.

113
00:09:53,370 --> 00:09:58,400
მაგრამ შემდეგ, როდესაც ფუნქცია დააბრუნებს, მისი დასტის ჩარჩოში იღებს popped off Stack.

114
00:10:01,050 --> 00:10:03,530
და ამიტომ ე.წ. დასტის.

115
00:10:03,530 --> 00:10:06,570
ეს მოსწონს დასტის მონაცემები სტრუქტურის, თუ იცით რას რომ არის.

116
00:10:06,570 --> 00:10:11,580
ან თუნდაც მოსწონს Stack of უჯრები ყოველთვის მაგალითად,

117
00:10:11,580 --> 00:10:16,060
მთავარი აპირებს წავიდეს ქვედა, მაშინ პირველი ფუნქცია რეკავთ აპირებს წავიდეს თავზე რომ,

118
00:10:16,060 --> 00:10:20,400
და ვერ დავუბრუნდეთ მთავარ სანამ არ დაბრუნდება ყველა ფუნქცია, რომელიც მოუწოდა

119
00:10:20,400 --> 00:10:22,340
რომ უკვე განთავსებული ზევით იგი.

120
00:10:22,340 --> 00:10:28,650
>> [სტუდენტი] ასე რომ, თუ თქვენ ამაზე გავაკეთოთ დაბრუნების & Y, რომ ღირებულება შეიძლება შეიცვალოს გაფრთხილების გარეშე.

121
00:10:28,650 --> 00:10:31,290
დიახ, it's - >> [სტუდენტი] ეს შეიძლება იყოს ახლით. >> Yeah.

122
00:10:31,290 --> 00:10:34,660
ეს სრულიად - თუ თქვენ ცდილობენ და -

123
00:10:34,660 --> 00:10:38,040
ეს ასევე იქნება int * ბარი რადგანაც ეს დაბრუნების მაჩვენებელი,

124
00:10:38,040 --> 00:10:41,310
ამიტომ მისი დაბრუნების პირობა არის int *.

125
00:10:41,310 --> 00:10:46,500
თუ თქვენ ცდილობენ გამოიყენონ დაბრუნებული მნიშვნელობა ამ ფუნქციას, ეს გაურკვეველი ქცევა

126
00:10:46,500 --> 00:10:51,770
იმიტომ, რომ მაჩვენებელი მიუთითებს ცუდი მეხსიერება. >> [სტუდენტი] Okay.

127
00:10:51,770 --> 00:11:01,250
მერე რა, რომ, მაგალითად, თქვენ განაცხადა int * y = malloc (sizeof (int))?

128
00:11:01,250 --> 00:11:03,740
რომ სჯობს. დიახ.

129
00:11:03,740 --> 00:11:07,730
[სტუდენტი] ვისაუბრეთ იმაზე, თუ როგორ, როდესაც ჩვენ გადაიტანეთ რამ ჩვენს recycle bin

130
00:11:07,730 --> 00:11:11,750
ისინი რეალურად არ წაშლილია, ჩვენ უბრალოდ კარგავენ პოინტერები.

131
00:11:11,750 --> 00:11:15,550
ასე რომ ამ შემთხვევაში ჩვენ ფაქტობრივად წაშლას ღირებულება თუ ჯერ კიდევ არსებობს მეხსიერებაში?

132
00:11:15,550 --> 00:11:19,130
უმეტესწილად, ეს აპირებს კვლავ იყოს იქ.

133
00:11:19,130 --> 00:11:24,220
მაგრამ ვთქვათ ჩვენ მოხდეს მოვუწოდებთ ზოგიერთი სხვა ფუნქცია, baz.

134
00:11:24,220 --> 00:11:28,990
Baz აპირებს საკუთარი დასტის ჩარჩო აქ.

135
00:11:28,990 --> 00:11:31,470
ეს იქნება overwriting ყველა ამ პერსონალის,

136
00:11:31,470 --> 00:11:34,180
და მაშინ თუ გვიან შეეცდება და გამოიყენოთ მაჩვენებელი, შენ წინაშე,

137
00:11:34,180 --> 00:11:35,570
ეს არ იქნება იგივე ღირებულება.

138
00:11:35,570 --> 00:11:38,150
იგი აპირებს შეიცვალა მხოლოდ იმიტომ, რომ თქვენ მოუწოდა ფუნქცია baz.

139
00:11:38,150 --> 00:11:43,080
[სტუდენტი] მაგრამ ჩვენ არ, რომ ჩვენ მაინც 3?

140
00:11:43,080 --> 00:11:44,990
[Bowden] ყველა ალბათობა, თქვენ აკეთებთ.

141
00:11:44,990 --> 00:11:49,670
მაგრამ ვერ დაეყრდნონ, რომ. C უბრალოდ ამბობს გაურკვეველი ქცევა.

142
00:11:49,670 --> 00:11:51,920
>> [სტუდენტი] ოჰ, ეს იმას. Okay.

143
00:11:51,920 --> 00:11:58,190
ასე რომ, როდესაც თქვენ გინდათ დაბრუნების მაჩვენებელი, ეს არის სადაც malloc მოდის გამოიყენება.

144
00:12:00,930 --> 00:12:15,960
მე წერა რეალურად მხოლოდ დაბრუნების malloc (3 * sizeof (int)).

145
00:12:17,360 --> 00:12:24,050
ჩვენ წავიდეთ მეტი malloc მეტი მეორე, მაგრამ იდეა malloc არის ყველა თქვენი ადგილობრივი ცვლადები

146
00:12:24,050 --> 00:12:26,760
ყოველთვის გაგრძელდება Stack.

147
00:12:26,760 --> 00:12:31,570
არაფერი რომ malloced გრძელდება ბევრი იქნება, და ეს სამუდამოდ და ყოველთვის იქნება ბევრი

148
00:12:31,570 --> 00:12:34,490
სანამ თქვენ მკაფიოდ გასათავისუფლებლად იგი.

149
00:12:34,490 --> 00:12:42,130
ასე რომ, ეს იმას ნიშნავს, რომ როდესაც თქვენ malloc რაღაც, ის აპირებს გადარჩება შემდეგ ფუნქცია დააბრუნებს.

150
00:12:42,130 --> 00:12:46,800
[სტუდენტი] უნდა ეს გადარჩება შემდეგ პროგრამა აჩერებს გაშვებული? >> პოსტები

151
00:12:46,800 --> 00:12:53,180
Okay, ასე რომ იქნება იქ, სანამ პროგრამა ყველა გზა გაკეთდეს გაშვებული. >> დიახ.

152
00:12:53,180 --> 00:12:57,510
ჩვენ შეგვიძლია წავიდეთ მეტი დეტალები, თუ რა ხდება, როდესაც პროგრამა აჩერებს გაშვებული.

153
00:12:57,510 --> 00:13:02,150
ალბათ უნდა მაგონებს, მაგრამ ეს ცალკე რამ მთლიანად.

154
00:13:02,150 --> 00:13:04,190
[სტუდენტი] ასე malloc ქმნის მაჩვენებელი? >> Yeah.

155
00:13:04,190 --> 00:13:13,030
Malloc - >> [სტუდენტი] ვფიქრობ malloc აღნიშვნას ბლოკი მეხსიერება რომ მომცეთ შეგიძლიათ გამოიყენოთ.

156
00:13:15,400 --> 00:13:19,610
[Bowden] მინდა რომ დიაგრამაზე ერთხელ. >> [სტუდენტი] ასე რომ, ეს ფუნქცია მუშაობს, თუმცა?

157
00:13:19,610 --> 00:13:26,430
[სტუდენტი] ჰო, malloc აღნიშვნას ბლოკი მეხსიერება, რომელიც შეგიძლიათ გამოიყენოთ,

158
00:13:26,430 --> 00:13:30,470
და მაშინ ის დააბრუნებს მისამართი პირველი ბლოკი, რომ მეხსიერებაში.

159
00:13:30,470 --> 00:13:36,750
>> [Bowden] Yeah. ასე რომ, როდესაც თქვენ malloc, თქვენ grabbing ზოგიერთი ბლოკი მეხსიერება

160
00:13:36,750 --> 00:13:38,260
რომ ამჟამად ბევრი.

161
00:13:38,260 --> 00:13:43,040
თუ ბევრი მცირეა, მაშინ ბევრი უბრალოდ აპირებს იზრდება, და ეს იზრდება ამ მიმართულებით.

162
00:13:43,040 --> 00:13:44,650
ასე ვთქვათ ბევრი მცირეა.

163
00:13:44,650 --> 00:13:49,960
მაშინ ის შესახებ გაიზარდოს ცოტა და დააბრუნოს მომცეთ ამ ბლოკში რომ მხოლოდ გაიზარდა.

164
00:13:49,960 --> 00:13:55,130
როცა თავისუფალი პერსონალი, თქვენ უფრო ოთახში ბევრი,

165
00:13:55,130 --> 00:14:00,030
ასეა, მაშინ მოგვიანებით დარეკვა malloc შეგიძლიათ reuse რომ მეხსიერება, რომ თქვენ ადრე გაათავისუფლეს.

166
00:14:00,030 --> 00:14:09,950
მთავარია შესახებ malloc და თავისუფალი არის ის, რომ გაძლევთ სრულ კონტროლს

167
00:14:09,950 --> 00:14:12,700
მეტი ცხოვრებისეული ამ მეხსიერების ბლოკები.

168
00:14:12,700 --> 00:14:15,420
გლობალური ცვლადები ყოველთვის ცოცხალია.

169
00:14:15,420 --> 00:14:18,500
ლოკალური ცვლადები ცოცხალი მათ ფარგლებს.

170
00:14:18,500 --> 00:14:22,140
როგორც კი წავიდეთ წარსულში Curly გაუწიოს, ადგილობრივი ცვლადები მკვდარი.

171
00:14:22,140 --> 00:14:28,890
Malloced მეხსიერების ცოცხალია როდესაც გსურთ, რომ იყოს ცოცხალი

172
00:14:28,890 --> 00:14:33,480
და მაშინ გამოვიდა, როცა ვამბობ, რომ უნდა განთავისუფლდეს.

173
00:14:33,480 --> 00:14:38,420
ეს ის რეალურად მხოლოდ 3 ტიპის მეხსიერება, ნამდვილად.

174
00:14:38,420 --> 00:14:41,840
არსებობს ავტომატური მეხსიერების მართვა, რომელიც დასტის.

175
00:14:41,840 --> 00:14:43,840
რამ ხდება თქვენთვის ავტომატურად.

176
00:14:43,840 --> 00:14:46,910
როცა ამბობენ int x, მეხსიერების გამოყოფილი int x.

177
00:14:46,910 --> 00:14:51,630
როდესაც x გადის ფარგლებს, მეხსიერების reclaimed ამისთვის x.

178
00:14:51,630 --> 00:14:54,790
მაშინ არსებობს დინამიური მეხსიერების მართვა, რაც malloc არის,

179
00:14:54,790 --> 00:14:56,740
რაც როდესაც თქვენ კონტროლი.

180
00:14:56,740 --> 00:15:01,290
თქვენ დინამიურად გადასაწყვეტია, როდის მეხსიერების უნდა და არ უნდა გამოყო.

181
00:15:01,290 --> 00:15:05,050
და მაშინ არსებობს სტატიკური, რომელიც მხოლოდ იმას ნიშნავს, რომ ის ცხოვრობს სამუდამოდ,

182
00:15:05,050 --> 00:15:06,610
რაც გლობალური ცვლადები არიან.

183
00:15:06,610 --> 00:15:10,240
ისინი უბრალოდ ყოველთვის მეხსიერებაში.

184
00:15:10,960 --> 00:15:12,760
>> კითხვები?

185
00:15:14,490 --> 00:15:17,230
[სტუდენტი] შეგიძლიათ განსაზღვროს ბლოკი უბრალოდ გამოყენებით Curly braces

186
00:15:17,230 --> 00:15:21,220
მაგრამ არ მქონე აქვს თუ განაცხადი ან ხოლო განაცხადი ან არაფერი რომ?

187
00:15:21,220 --> 00:15:29,130
თქვენ შეგიძლიათ განსაზღვროს ბლოკი როგორც ფუნქცია, მაგრამ რომ აქვს Curly braces ძალიან.

188
00:15:29,130 --> 00:15:32,100
[სტუდენტი] ასე რომ თქვენ არა მხოლოდ აქვს, როგორიც შემთხვევითი წყვილი Curly braces თქვენს კოდი

189
00:15:32,100 --> 00:15:35,680
რომ აქვს ადგილობრივი ცვლადები? >> დიახ, შეგიძლიათ.

190
00:15:35,680 --> 00:15:45,900
შიგნით int ბარი ჩვენ შეგვეძლო {int y = 3;}.

191
00:15:45,900 --> 00:15:48,440
რომ უნდა იყოს უფლება აქ.

192
00:15:48,440 --> 00:15:52,450
მაგრამ ეს მთლიანად განსაზღვრავს ფარგლებს int y.

193
00:15:52,450 --> 00:15:57,320
ამის შემდეგ მეორე Curly გაუწიოს, Y არ გამოიყენება უქმნით.

194
00:15:57,910 --> 00:16:00,630
თქვენ თითქმის არასოდეს გავაკეთებთ, თუმცა.

195
00:16:02,940 --> 00:16:07,370
დავუბრუნდეთ რა ხდება, როდესაც პროგრამა დამთავრდა,

196
00:16:07,370 --> 00:16:18,760
არსებობს სახის misconception / ნახევარი ტყუილი, რომ ვაძლევთ, რათა მხოლოდ მიიღოს რამ ადვილია.

197
00:16:18,760 --> 00:16:24,410
ჩვენ გითხრათ, რომ როდესაც თქვენ გამოყოს მეხსიერება

198
00:16:24,410 --> 00:16:29,860
თქვენ გამოყოფის ზოგიერთი ბლოკი RAM რომ ცვლადი.

199
00:16:29,860 --> 00:16:34,190
მაგრამ თქვენ არ რეალურად პირდაპირ ეხება RAM ოდესმე თქვენს პროგრამებში.

200
00:16:34,190 --> 00:16:37,490
თუ ფიქრობთ, ეს, რა მიიპყრო -

201
00:16:37,490 --> 00:16:44,330
და ფაქტობრივად, თუ თქვენ გავლა in GDB დაინახავთ იგივე.

202
00:16:51,120 --> 00:16:57,590
მიუხედავად რამდენჯერ თქვენ აწარმოებს თქვენი პროგრამის ან რა პროგრამა თქვენ გაშვებული,

203
00:16:57,590 --> 00:16:59,950
დასტის ყოველთვის იწყებს -

204
00:16:59,950 --> 00:17:06,510
თქვენ ყოველთვის აპირებს ვხედავ ცვლადებს გარშემო მისამართი oxbffff რაღაც.

205
00:17:06,510 --> 00:17:09,470
ეს, როგორც წესი, სადღაც, რომ რეგიონში.

206
00:17:09,470 --> 00:17:18,760
მაგრამ როგორ შეიძლება 2 პროგრამები შესაძლოა აქვს მითითებას იგივე მეხსიერება?

207
00:17:20,640 --> 00:17:27,650
[სტუდენტი] არსებობს რამდენიმე თვითნებური დანიშნულება აქ oxbfff უნდა იყოს RAM

208
00:17:27,650 --> 00:17:31,320
რომ შეიძლება რეალურად იყოს სხვადასხვა ადგილებში დამოკიდებულია როდესაც ფუნქციის ეწოდა.

209
00:17:31,320 --> 00:17:35,920
Yeah. ტერმინი არის ვირტუალური მეხსიერება.

210
00:17:35,920 --> 00:17:42,250
იდეა ისაა, რომ თითოეული პროცესი, თითოეული პროგრამა, რომელიც არის გაშვებული თქვენს კომპიუტერში

211
00:17:42,250 --> 00:17:49,450
აქვს საკუთარი - მოდით ვივარაუდოთ, 32 ბიტი - სრულიად დამოუკიდებელი მისამართი სივრცეში.

212
00:17:49,450 --> 00:17:51,590
ეს არის მისამართი სივრცეში.

213
00:17:51,590 --> 00:17:56,220
აქვს საკუთარი სრულიად დამოუკიდებელი 4 გბ გამოიყენოს.

214
00:17:56,220 --> 00:18:02,220
>> ასე რომ, თუ თქვენ აწარმოებს 2 პროგრამები ერთდროულად, ამ პროგრამის ხედავს 4 გბ, თვით

215
00:18:02,220 --> 00:18:04,870
ამ პროგრამის ხედავს 4 გბ, თვით

216
00:18:04,870 --> 00:18:07,720
და ეს შეუძლებელია ამ პროგრამის dereference მაჩვენებელი

217
00:18:07,720 --> 00:18:10,920
და დასრულდება მდე მეხსიერების ამ პროგრამის.

218
00:18:10,920 --> 00:18:18,200
და რა ვირტუალური მეხსიერების არის რუკების საწყისი პროცესების მისამართი სივრცეში

219
00:18:18,200 --> 00:18:20,470
ნამდვილ რამ on RAM.

220
00:18:20,470 --> 00:18:22,940
ამიტომ მდე თქვენი ოპერაციული სისტემა იცოდეს, რომ,

221
00:18:22,940 --> 00:18:28,080
hey, როცა ამ ბიჭს dereferences მაჩვენებელი oxbfff, რომ ნამდვილად ნიშნავს

222
00:18:28,080 --> 00:18:31,040
რომ მას სურს RAM byte 1000,

223
00:18:31,040 --> 00:18:38,150
ხოლო თუ ამ პროგრამის dereferences oxbfff, მას მართლაც სურს RAM byte 10000.

224
00:18:38,150 --> 00:18:41,590
ეს შეიძლება იყოს თვითნებურად შორს გარდა.

225
00:18:41,590 --> 00:18:48,730
ეს არის კიდევ ნამდვილი რამ ერთ პროცესების მისამართი სივრცეში.

226
00:18:48,730 --> 00:18:54,770
ასე რომ, როგორც ეს ხედავს ყველა 4 გბ, არამედ ვთქვათ -

227
00:18:54,770 --> 00:18:57,290
[სტუდენტი] არა თითოეული პროცესი -

228
00:18:57,290 --> 00:19:01,350
ვთქვათ თქვენ გაქვთ კომპიუტერი მხოლოდ 4 გბ ოპერატიული მეხსიერება.

229
00:19:01,350 --> 00:19:06,430
ამჯამად თითოეული პროცესი მთლიანად ჩანს 4 გიგაბაიტი? >> დიახ.

230
00:19:06,430 --> 00:19:13,060
მაგრამ 4 გიგაბაიტი ის ხედავს არის ტყუილი.

231
00:19:13,060 --> 00:19:20,460
უბრალოდ ეს მიაჩნია მას ყველა ამ მეხსიერების რადგან ეს არ ვიცი არც ერთი სხვა პროცესი არსებობს.

232
00:19:20,460 --> 00:19:28,140
ეს იქნება მხოლოდ იმდენი მეხსიერება, როგორც ეს რეალურად სჭირდება.

233
00:19:28,140 --> 00:19:32,340
ოპერაციული სისტემა დათმობას არ აპირებს მეხსიერება ამ პროცესში

234
00:19:32,340 --> 00:19:35,750
თუ ეს არ გამოყენებით ნებისმიერი მეხსიერების ამ მთელი რეგიონისთვის.

235
00:19:35,750 --> 00:19:39,300
ის დათმობას არ აპირებს იგი მეხსიერებაში, რომ რეგიონში.

236
00:19:39,300 --> 00:19:54,780
მაგრამ იდეა ისაა, რომ - ვცდილობ ვფიქრობ - მე ვერ ვფიქრობ ანალოგია.

237
00:19:54,780 --> 00:19:56,780
ანალოგიების რთულია.

238
00:19:57,740 --> 00:20:02,700
ერთი საკითხი ვირტუალური მეხსიერების ან ერთი რამ ეს გადაჭრის

239
00:20:02,700 --> 00:20:06,810
ის არის, რომ პროცესი უნდა მთლიანად იცის ერთმანეთს.

240
00:20:06,810 --> 00:20:12,140
და ასე რომ თქვენ შეგიძლიათ დაწეროთ ნებისმიერი პროგრამა, რომელიც მხოლოდ dereferences ნებისმიერი მაჩვენებელი,

241
00:20:12,140 --> 00:20:19,340
მინდა უბრალოდ წერენ პროგრამა, რომელიც ამბობს * (ox1234),

242
00:20:19,340 --> 00:20:22,890
და ეს dereferencing მეხსიერების მისამართი 1234.

243
00:20:22,890 --> 00:20:28,870
>> მაგრამ ეს მდე ოპერაციული სისტემის შემდეგ თარგმნოს რა 1234 საშუალებებით.

244
00:20:28,870 --> 00:20:33,960
ასე რომ, თუ 1234 მოხდება იქნება სწორი მეხსიერების მისამართი ამ პროცესში,

245
00:20:33,960 --> 00:20:38,800
მოსწონს ეს on დასტის ან რამე, მაშინ ეს დაბრუნდება ღირებულება რომ მეხსიერების მისამართი

246
00:20:38,800 --> 00:20:41,960
რამდენადაც პროცესი იცის.

247
00:20:41,960 --> 00:20:47,520
მაგრამ თუ 1234 არ არის სწორი მისამართი, როგორც ეს ხდება მიწის

248
00:20:47,520 --> 00:20:52,910
ზოგიერთ პატარა ნაჭერი მეხსიერება აქ რომ სცილდება დასტის და მის ფარგლებს გარეთ ბევრი

249
00:20:52,910 --> 00:20:57,200
და თქვენ ნამდვილად არ გამოიყენება, რომ, მაშინ, რომ როდესაც თქვენ რამ, როგორიცაა segfaults

250
00:20:57,200 --> 00:21:00,260
იმიტომ, რომ თქვენ შეხება მეხსიერების, რომ თქვენ არ უნდა ეხება.

251
00:21:07,180 --> 00:21:09,340
ეს არის ასევე ჭეშმარიტი -

252
00:21:09,340 --> 00:21:15,440
32-bit სისტემა, 32 ბიტი ნიშნავს გაქვთ 32 ბიტი, განისაზღვროს მეხსიერების მისამართზე.

253
00:21:15,440 --> 00:21:22,970
ეს რატომ მითითებები 8 ბაიტი, რადგან 32 ბიტი არის 8 ბაიტი - ან 4 ბაიტი.

254
00:21:22,970 --> 00:21:25,250
მითითებები 4 ბაიტი.

255
00:21:25,250 --> 00:21:33,680
ასე რომ, როდესაც თქვენ ხედავთ, მაჩვენებელი, როგორიცაა oxbfffff, რომ არის -

256
00:21:33,680 --> 00:21:40,080
ფარგლებში ნებისმიერ მოცემულ პროგრამაში შეგიძლიათ უბრალოდ აშენება ნებისმიერი თვითნებური მაჩვენებელი,

257
00:21:40,080 --> 00:21:46,330
ყველგან საწყისი ox0 to ox 8 f's - ffffffff.

258
00:21:46,330 --> 00:21:49,180
[სტუდენტი] არ ამბობენ ისინი 4 ბაიტი? >> Yeah.

259
00:21:49,180 --> 00:21:52,730
[სტუდენტი] თითოეული byte ექნება - >> [Bowden] თექვსმეტობითი.

260
00:21:52,730 --> 00:21:59,360
თექვსმეტობითი - 5, 6, 7, 8. ამიტომ პოინტერები თქვენ აპირებს ყოველთვის ვხედავთ თექვსმეტობითი.

261
00:21:59,360 --> 00:22:01,710
უბრალოდ, რა არის ჩვენი დაალაგეთ პოინტერები.

262
00:22:01,710 --> 00:22:05,240
ყოველ 2 ციფრით თექვსმეტობითი არის 1 ბაიტი.

263
00:22:05,240 --> 00:22:09,600
ასე იქნება 8 თექვსმეტობითი ციფრები 4 ბაიტი.

264
00:22:09,600 --> 00:22:14,190
ამიტომ თითოეული კურსორი on 32-bit სისტემა იქნება 4 ბაიტი,

265
00:22:14,190 --> 00:22:18,550
რაც იმას ნიშნავს, რომ თქვენს პროცესში შეგიძლიათ აშენება ნებისმიერი თვითნებური 4 ბაიტი

266
00:22:18,550 --> 00:22:20,550
და მიიღოს მაჩვენებელი გარეთ,

267
00:22:20,550 --> 00:22:32,730
რაც იმას ნიშნავს, რომ რამდენადაც ეს იცის, მას შეუძლია მიმართოს მთელი 2 დან 32 ბაიტი მეხსიერება.

268
00:22:32,730 --> 00:22:34,760
მიუხედავად იმისა, რომ ნამდვილად არ აქვს დაშვება, რომ,

269
00:22:34,760 --> 00:22:40,190
მაშინაც კი, თუ თქვენს კომპიუტერს აქვს მხოლოდ 512 მბ, ეს ფიქრობს, მას, რომ ბევრი რამ მეხსიერებაში.

270
00:22:40,190 --> 00:22:44,930
და საოპერაციო სისტემის smart საკმარისი, რომ იგი მხოლოდ გამოყოფს, რაც თქვენ რეალურად სჭირდება.

271
00:22:44,930 --> 00:22:49,630
იგი არ უბრალოდ, OH, ახალ პროცესს: 4 gigs.

272
00:22:49,630 --> 00:22:51,930
>> Yeah. >> [სტუდენტი] რას ნიშნავს ox? რატომ წერთ ამას?

273
00:22:51,930 --> 00:22:54,980
უბრალოდ სიმბოლო თექვსმეტობითი.

274
00:22:54,980 --> 00:22:59,590
როდესაც ხედავთ ხმების იწყება ox, თანმიმდევრული რამ თექვსმეტობითი.

275
00:23:01,930 --> 00:23:05,760
[სტუდენტი] იყავით ხსნიდა შესახებ, თუ რა ხდება, როდესაც პროგრამა დასრულდება. >> დიახ.

276
00:23:05,760 --> 00:23:09,480
რა ხდება, როდესაც პროგრამა დამთავრდა არის ოპერაციული სისტემა

277
00:23:09,480 --> 00:23:13,600
უბრალოდ შლის mappings, რომ მას ამ მისამართები, და ამით ყველაფერი მთავრდება.

278
00:23:13,600 --> 00:23:17,770
ოპერაციული სისტემა შეიძლება ახლა მხოლოდ მისცეს, რომ მეხსიერების სხვა პროგრამა გამოიყენოს.

279
00:23:17,770 --> 00:23:19,490
[სტუდენტი] Okay.

280
00:23:19,490 --> 00:23:24,800
ასე რომ, როდესაც თქვენ გამოყოფს რაღაც ბევრი ან დასტის ან გლობალური ცვლადები ან არაფერი,

281
00:23:24,800 --> 00:23:27,010
ისინი ყველა უბრალოდ გაქრება, როგორც კი პროგრამა დასრულდება

282
00:23:27,010 --> 00:23:32,120
რადგან ოპერაციული სისტემა არის უფასო მისცეს, რომ მეხსიერების რაიმე სხვა პროცესი.

283
00:23:32,120 --> 00:23:35,150
[სტუდენტი] მიუხედავად იმისა, რომ არსებობს ალბათ მაინც ღირებულებების დაწერილი? >> Yeah.

284
00:23:35,150 --> 00:23:37,740
ღირებულებები სავარაუდოდ ჯერ კიდევ არსებობს.

285
00:23:37,740 --> 00:23:41,570
უბრალოდ ეს იქნება რთული მისაღებად მათ.

286
00:23:41,570 --> 00:23:45,230
ეს ბევრად უფრო რთული მისაღებად მათ ვიდრე მისაღებად საათზე წაშლილი ფაილი

287
00:23:45,230 --> 00:23:51,450
რადგან წაშლილი ფაილის სახის ზის იქ დიდი ხნის განმავლობაში და ხისტ დისკზე არის ბევრი დიდია.

288
00:23:51,450 --> 00:23:54,120
ამიტომ აპირებს გადავაწერო სხვადასხვა კუთხეში მეხსიერება

289
00:23:54,120 --> 00:23:58,640
სანამ ეს მოხდება გადავაწერო ბლოკი მეხსიერება, რომ ფაილი იზრდებოდნენ.

290
00:23:58,640 --> 00:24:04,520
მაგრამ მთავარ მეხსიერება, RAM, თქვენ ციკლის მეშვეობით ბევრი უფრო სწრაფად,

291
00:24:04,520 --> 00:24:08,040
ამიტომ აპირებს ძალიან სწრაფად იყოს ახლით.

292
00:24:10,300 --> 00:24:13,340
კითხვები ამ ან სხვა რამეზე?

293
00:24:13,340 --> 00:24:16,130
[სტუდენტი] მაქვს შეკითხვები სხვადასხვა თემაზე. >> Okay.

294
00:24:16,130 --> 00:24:19,060
ვინმეს აქვს კითხვები ამ?

295
00:24:20,170 --> 00:24:23,120
>> Okay. სხვადასხვა თემას. >> [სტუდენტი] Okay.

296
00:24:23,120 --> 00:24:26,550
მივდიოდი მეშვეობით ზოგიერთი პრაქტიკა ტესტები,

297
00:24:26,550 --> 00:24:30,480
და ერთ მათგანს იყო ლაპარაკი sizeof

298
00:24:30,480 --> 00:24:35,630
და ღირებულება, რომ ის დააბრუნებს ან სხვადასხვა ცვლადი ტიპები. >> დიახ.

299
00:24:35,630 --> 00:24:45,060
და ეს აღნიშნა, რომ ორივე int და ხანგრძლივი ორივე დაბრუნების 4, ამიტომ ისინი ორივე 4 ბაიტი ხანგრძლივი.

300
00:24:45,060 --> 00:24:48,070
არსებობს თუ არა განსხვავება int და ხანგრძლივი, თუ იგივე?

301
00:24:48,070 --> 00:24:50,380
დიახ, არსებობს განსხვავება.

302
00:24:50,380 --> 00:24:52,960
C სტანდარტი -

303
00:24:52,960 --> 00:24:54,950
მე ალბათ აპირებს mess up.

304
00:24:54,950 --> 00:24:58,800
C სტანდარტი ისევე რა არის C, ოფიციალური დოკუმენტაცია C.

305
00:24:58,800 --> 00:25:00,340
ეს არის ის, რაც ნათქვამია.

306
00:25:00,340 --> 00:25:08,650
ამიტომ C სტანდარტული უბრალოდ ამბობს, რომ char სამუდამოდ და ყოველთვის იქნება 1 ბაიტი.

307
00:25:10,470 --> 00:25:19,040
ყველაფერი ამის შემდეგ - მოკლე ყოველთვის მხოლოდ განსაზღვრული როგორც მეტია ან ტოლია char.

308
00:25:19,040 --> 00:25:23,010
ეს შეიძლება იყოს მკაცრად მეტი, მაგრამ არა დადებითი.

309
00:25:23,010 --> 00:25:31,940
Int მხოლოდ განსაზღვრული როგორც მეტია ან ტოლია მოკლე.

310
00:25:31,940 --> 00:25:36,210
და ხანგრძლივი მხოლოდ განსაზღვრული როგორც მეტია ან ტოლია int.

311
00:25:36,210 --> 00:25:41,600
და ხანგრძლივი ხანგრძლივი მეტია ან ტოლია ხანგრძლივი.

312
00:25:41,600 --> 00:25:46,610
ასე რომ ერთადერთი C სტანდარტი საზღვრავს არის ნათესავი რიგი ყველაფერი.

313
00:25:46,610 --> 00:25:54,880
ფაქტობრივი რაოდენობის მეხსიერება, რაც რამ დასჭირდეს ზოგადად მდე განხორციელების,

314
00:25:54,880 --> 00:25:57,640
მაგრამ კარგად განსაზღვრული ამ ეტაპზე. >> [სტუდენტი] Okay.

315
00:25:57,640 --> 00:26:02,490
ასე რომ შორტები თითქმის ყოველთვის იქნება 2 ბაიტი.

316
00:26:04,920 --> 00:26:09,950
Ints თითქმის ყოველთვის იქნება 4 ბაიტი.

317
00:26:12,070 --> 00:26:15,340
დიდხანს longs თითქმის ყოველთვის იქნება 8 ბაიტი.

318
00:26:17,990 --> 00:26:23,160
და longs, ეს დამოკიდებულია თუ არა თქვენ იყენებთ 32-bit ან 64-bit სისტემა.

319
00:26:23,160 --> 00:26:27,450
ასე ხანგრძლივი აპირებს შეესაბამება ტიპის სისტემა.

320
00:26:27,450 --> 00:26:31,920
თუ თქვენ იყენებთ 32-bit სისტემის მსგავსად ელექტრო მოწყობილობების, ეს იქნება 4 ბაიტი.

321
00:26:34,530 --> 00:26:42,570
თუ თქვენ გამოყენებით 64-bit, როგორიც ბევრი ბოლო კომპიუტერები, ეს იქნება 8 ბაიტი.

322
00:26:42,570 --> 00:26:45,230
>> Ints თითქმის ყოველთვის 4 ბაიტი ამ ეტაპზე.

323
00:26:45,230 --> 00:26:47,140
დიდხანს longs თითქმის ყოველთვის 8 ბაიტი.

324
00:26:47,140 --> 00:26:50,300
წარსულში, ints გამოყენებული იყოს მხოლოდ 2 ბაიტს.

325
00:26:50,300 --> 00:26:56,840
მაგრამ შეამჩნია, რომ ეს სრულიად აკმაყოფილებს ყველა ამ ურთიერთობების მეტია და ტოლია.

326
00:26:56,840 --> 00:27:01,280
ცოტა ხნის სრულიად დასაშვებია იყოს იგივე ზომა, როგორც მთელი რიცხვი,

327
00:27:01,280 --> 00:27:04,030
და ასევე უფლება აქვთ იგივე ზომა, როგორც ხანგრძლივი ხანგრძლივი.

328
00:27:04,030 --> 00:27:11,070
და ეს ასე მოხდება, იყოს, რომ 99,999% სისტემების, ეს იქნება ტოლი

329
00:27:11,070 --> 00:27:15,800
ან int ან ხანგრძლივი ხანგრძლივი. უბრალოდ დამოკიდებულია 32-bit ან 64-bit. >> [სტუდენტი] Okay.

330
00:27:15,800 --> 00:27:24,600
In მოძრავი, თუ როგორ არის ათობითი წერტილი დანიშნული თვალსაზრისით ბიტი?

331
00:27:24,600 --> 00:27:27,160
ისევე როგორც ორობითი? >> Yeah.

332
00:27:27,160 --> 00:27:30,570
თქვენ არ უნდა იცოდეთ, რომ CS50.

333
00:27:30,570 --> 00:27:32,960
თქვენ კი არ სწავლობენ, რომ 61.

334
00:27:32,960 --> 00:27:37,350
თქვენ არ ვისწავლოთ, რომ მართლაც რაიმე რა თქმა უნდა.

335
00:27:37,350 --> 00:27:42,740
უბრალოდ წარმომადგენლობა.

336
00:27:42,740 --> 00:27:45,440
მე დაგვავიწყდეს ზუსტი bit allotments.

337
00:27:45,440 --> 00:27:53,380
იდეა მცურავი წერტილი არის ის, რომ თქვენ გამოყოფს კონკრეტული რაოდენობის ბიტი წარმოადგენს -

338
00:27:53,380 --> 00:27:56,550
ძირითადად, ყველაფერი სამეცნიერო ნოტაცია.

339
00:27:56,550 --> 00:28:05,600
ასე, რომ თქვენ გამოყოფს კონკრეტული რაოდენობის ბიტი წარმოადგენს ნომერი თავად მოსწონს 1,2345.

340
00:28:05,600 --> 00:28:10,200
მე შემიძლია არასოდეს წარმოადგენენ ხმების მეტი ციფრები, ვიდრე 5.

341
00:28:12,200 --> 00:28:26,300
მაშინ თქვენ ასევე გამოყოს კონკრეტული რაოდენობის ბიტი ისე, რომ იგი აპირებს იყოს

342
00:28:26,300 --> 00:28:32,810
თქვენ შეგიძლიათ მხოლოდ ახვიდეთ გარკვეული რაოდენობა, როგორიცაა რომ უმსხვილეს მაჩვენებლებით შეგიძლიათ,

343
00:28:32,810 --> 00:28:36,190
და თქვენ მხოლოდ იქ შეგვიძლია ქვემოთ გარკვეული მაჩვენებლებით,

344
00:28:36,190 --> 00:28:38,770
მინდა, რომ ყველაზე პატარა მაჩვენებლებით შეგიძლიათ.

345
00:28:38,770 --> 00:28:44,410
>> მე არ მახსოვს ზუსტი გზა ბიტი გვაკისრია ყველა ამ ფასეულობების,

346
00:28:44,410 --> 00:28:47,940
მაგრამ გარკვეული რაოდენობის ბიტი ეძღვნება 1,2345,

347
00:28:47,940 --> 00:28:50,930
კიდევ ერთი გარკვეული რაოდენობის ბიტი ეძღვნება მაჩვენებლებით,

348
00:28:50,930 --> 00:28:55,670
და ეს შესაძლებელია მხოლოდ წარმოადგენენ მაჩვენებლებით გარკვეული ზომით.

349
00:28:55,670 --> 00:29:01,100
[სტუდენტი] და ორმაგი? არის ის, რომ მოსწონს დამატებითი ხანგრძლივი float? >> Yeah.

350
00:29:01,100 --> 00:29:07,940
ეს იგივე როგორც float გარდა ახლა თქვენ იყენებთ 8 ბაიტი ნაცვლად 4 ბაიტი.

351
00:29:07,940 --> 00:29:11,960
ახლა თქვენ შეძლებთ გამოიყენოთ 9 ციფრისგან ან 10 ნიშნა,

352
00:29:11,960 --> 00:29:16,630
და ამ შეძლებს ახვიდეთ 300 ნაცვლად 100. >> [სტუდენტი] Okay.

353
00:29:16,630 --> 00:29:21,550
და მოძრავი ასევე 4 ბაიტი. >> დიახ.

354
00:29:21,550 --> 00:29:27,520
ისე, კიდევ ერთხელ, ალბათ დამოკიდებულია საერთო საერთო შესრულების,

355
00:29:27,520 --> 00:29:30,610
მაგრამ მოძრავი არიან 4 ბაიტი, ორადგილიანი არიან 8.

356
00:29:30,610 --> 00:29:33,440
ორადგილიანი ეწოდება ორმაგი რადგან ისინი ორმაგი ზომის მოძრავი.

357
00:29:33,440 --> 00:29:38,380
[სტუდენტი] Okay. და თუ არიან ორმაგი ორჯერ? >> არ არსებობს.

358
00:29:38,380 --> 00:29:43,660
ვფიქრობ - >> [სტუდენტი] მსგავსად ხანგრძლივი longs? >> Yeah. მე ასე არ ვფიქრობ. დიახ.

359
00:29:43,660 --> 00:29:45,950
[სტუდენტი] On შარშანდელი ტესტი იყო შეკითხვა მთავარი ფუნქცია

360
00:29:45,950 --> 00:29:49,490
მქონე ნაწილი იყოს თქვენი პროგრამა.

361
00:29:49,490 --> 00:29:52,310
პასუხი იყო, რომ ეს არ უნდა იყოს ნაწილი თქვენი პროგრამა.

362
00:29:52,310 --> 00:29:55,100
რა სიტუაციაში? რაც ვნახე.

363
00:29:55,100 --> 00:29:59,090
[Bowden] როგორც ჩანს - >> [სტუდენტი] რა სიტუაციაში?

364
00:29:59,090 --> 00:30:02,880
გაქვთ პრობლემა? >> [სტუდენტი] ჰო, მე შემიძლია ცალსახად დახევის it up.

365
00:30:02,880 --> 00:30:07,910
იგი არ უნდა იყოს, ტექნიკურად, მაგრამ ძირითადად ეს იქნება.

366
00:30:07,910 --> 00:30:10,030
[სტუდენტი] ვნახე ერთი განსხვავებული წლის.

367
00:30:10,030 --> 00:30:16,220
თითქოს True ან False: მოქმედებს - >> Oh,. გ ფაილი?

368
00:30:16,220 --> 00:30:18,790
[სტუდენტი] ნებისმიერი. გ ფაილი უნდა ჰქონდეს - [როგორც საუბრისას კიდევ ერთხელ - გაუგებარია]

369
00:30:18,790 --> 00:30:21,120
Okay. ასე რომ ცალკე.

370
00:30:21,120 --> 00:30:26,800
>> . გ ფაილი უბრალოდ სჭირდება შეიცავდეს ფუნქციები.

371
00:30:26,800 --> 00:30:32,400
შეგიძლიათ კომპილაციის ფაილის შევიდა მანქანა კოდი, ორობითი, რასაც,

372
00:30:32,400 --> 00:30:36,620
მის გარეშე ყოფნა შესრულებადი ამჟამად.

373
00:30:36,620 --> 00:30:39,420
ძალაში შესრულებადი უნდა ჰქონდეს ძირითად ფუნქციას.

374
00:30:39,420 --> 00:30:45,460
თქვენ შეგიძლიათ დაწეროთ 100 ფუნქციების 1 ფაილი მაგრამ არა ძირითადი

375
00:30:45,460 --> 00:30:48,800
და შემდეგ ადგენენ, რომ ქვემოთ ორობითი,

376
00:30:48,800 --> 00:30:54,460
შემდეგ ვწერთ სხვა ფაილი, რომელიც მხოლოდ ძირითად, არამედ ის მოუწოდებს bunch ამ ფუნქციების

377
00:30:54,460 --> 00:30:56,720
ამ ორობითი ფაილი აქ.

378
00:30:56,720 --> 00:31:01,240
და ამრიგად, როდესაც თქვენ მიღების შესრულებადი არის ის, რაც linker აკეთებს

379
00:31:01,240 --> 00:31:05,960
იგი აერთიანებს ამ 2 ორობითი ფაილს შესრულებადი.

380
00:31:05,960 --> 00:31:11,400
ასე რომ. გ ფაილი არ უნდა მთავარი ფუნქცია იყო.

381
00:31:11,400 --> 00:31:19,220
და დიდი კოდი ბაზების დაინახავთ ათასობით. გ ფაილი და 1 მთავარი ფაილი.

382
00:31:23,960 --> 00:31:26,110
სხვა კითხვები?

383
00:31:29,310 --> 00:31:31,940
[სტუდენტი] იყო სხვა საკითხია.

384
00:31:31,940 --> 00:31:36,710
მისი თქმით მიიღოს არის შემდგენელი. True ან ყალბი?

385
00:31:36,710 --> 00:31:42,030
და პასუხი იყო ყალბი, და მივხვდი, რატომ არ მოსწონს Clang.

386
00:31:42,030 --> 00:31:44,770
მაგრამ, ჩვენ მოვუწოდებთ მიიღოს თუ არა?

387
00:31:44,770 --> 00:31:49,990
ჩადება ძირითადად მხოლოდ - მე ვხედავ, ზუსტად რა ის მოუწოდებს მას.

388
00:31:49,990 --> 00:31:52,410
მაგრამ ეს მხოლოდ ეშვება ბრძანებები.

389
00:31:53,650 --> 00:31:55,650
ჩადება.

390
00:31:58,240 --> 00:32:00,870
შემიძლია დახევის ეს ყველაფერი. Yeah.

391
00:32:10,110 --> 00:32:13,180
Oh, yeah. ჩადება ასევე აკეთებს, რომ.

392
00:32:13,180 --> 00:32:17,170
ეს ამბობს მიზნით კომუნალური არის, რათა დადგინდეს ავტომატურად

393
00:32:17,170 --> 00:32:19,610
რომელიც ცალი დიდი პროგრამა საჭიროებს recompiled

394
00:32:19,610 --> 00:32:22,350
და გასცემს ბრძანებას recompile მათ.

395
00:32:22,350 --> 00:32:27,690
შეგიძლიათ გააკეთოთ მიიღოს ფაილი, რომელიც აბსოლუტურად უზარმაზარი.

396
00:32:27,690 --> 00:32:33,210
ჩადება უყურებს დრო მარკების ფაილი და, როგორც ჩვენ დაწყებამდე განაცხადა,

397
00:32:33,210 --> 00:32:36,930
შეგიძლიათ კომპილაციის ინდივიდუალური ფაილი down, და ეს არ სანამ თქვენ მიიღებთ linker

398
00:32:36,930 --> 00:32:39,270
რომ ისინი ერთად შევიდა შესრულებადი.

399
00:32:39,270 --> 00:32:43,810
ასე რომ, თუ თქვენ გაქვთ 10 სხვადასხვა ფაილები და თქვენ ცვლილების 1 მათგანი,

400
00:32:43,810 --> 00:32:47,870
მაშინ რა მარკა აპირებს მხოლოდ recompile რომ 1 ფაილის

401
00:32:47,870 --> 00:32:50,640
და შემდეგ relink ყველაფერი ერთად.

402
00:32:50,640 --> 00:32:53,020
მაგრამ ეს ბევრად dumber ვიდრე რომ.

403
00:32:53,020 --> 00:32:55,690
ეს თქვენი გადასაწყვეტია მთლიანად განმარტავენ, რომ არის ის, რაც უნდა აკეთებს.

404
00:32:55,690 --> 00:32:59,560
ეს იყოს გააჩნია უნარი აღიარებს ამ დროის შტამპი პერსონალის,

405
00:32:59,560 --> 00:33:03,220
მაგრამ თქვენ შეგიძლიათ დაწეროთ მარკა ფაილის არაფერს.

406
00:33:03,220 --> 00:33:09,150
თქვენ შეგიძლიათ დაწეროთ მიიღოს ფაილი ისე, რომ როდესაც თქვენ ტიპი იყოს იგი უბრალოდ CD-ს სხვა დირექტორია.

407
00:33:09,150 --> 00:33:15,560
მე მიღების იმედგაცრუებული რადგანაც მე Tack ყველაფერი შიგნით ჩემი ელექტრო მოწყობილობების

408
00:33:15,560 --> 00:33:21,740
და მაშინ მე PDF საწყისი Mac.

409
00:33:21,740 --> 00:33:30,720
>> ამიტომ მე წასვლა Finder და შემიძლია წადი, სერვერთან დაკავშირება,

410
00:33:30,720 --> 00:33:36,950
და სერვერზე მე ვუკავშირდები არის ჩემი ელექტრო მოწყობილობების, და მერე გახსენით PDF

411
00:33:36,950 --> 00:33:40,190
რომ იღებს მიერ შედგენილი ლატექსის.

412
00:33:40,190 --> 00:33:49,320
მაგრამ მე არც იმედგაცრუებული, რადგან თითოეული დროს მე საჭირო ამოცნობა PDF,

413
00:33:49,320 --> 00:33:53,900
მომიწია კოპირება კონკრეტული დირექტორია, რომ იგი შესაძლოა შედიხართ

414
00:33:53,900 --> 00:33:57,710
და ეს მიღების უსიამოვნოს.

415
00:33:57,710 --> 00:34:02,650
ასე რომ ნაცვლად დავწერე მარკა ფაილი, რომელშიც თქვენ უნდა განისაზღვროს, თუ როგორ იგი ქმნის რამ.

416
00:34:02,650 --> 00:34:06,130
როგორ გახდით ამ არის PDF ლატექსის.

417
00:34:06,130 --> 00:34:10,090
ისევე, როგორც ნებისმიერი სხვა მარკა ფაილი - ან მე ვფიქრობ თქვენ არ მინახავს მარკა ფაილი

418
00:34:10,090 --> 00:34:13,510
მაგრამ გვაქვს ელექტრო გლობალური მარკა ფაილი, უბრალოდ ამბობს,

419
00:34:13,510 --> 00:34:16,679
თუ თქვენ შედგენის C ფაილი, გამოიყენოთ Clang.

420
00:34:16,679 --> 00:34:20,960
და ა.შ. აქ ჩემი მარკა ფაილი, მე ვამბობ,

421
00:34:20,960 --> 00:34:25,020
ამ ფაილის თქვენ აპირებს გვინდა კომპილირდება ერთად PDF ლატექსის.

422
00:34:25,020 --> 00:34:27,889
და ამიტომ PDF ლატექსის რომ აკეთებს შედგენა.

423
00:34:27,889 --> 00:34:31,880
ჩადება არ არის შედგენა. უბრალოდ გაშვებული ეს ბრძანებები დადგენილი თანმიმდევრობით I მითითებული.

424
00:34:31,880 --> 00:34:36,110
ასე რომ ის მუშაობს PDF ლატექსის, მას აკოპირებს მას დირექტორია მინდა მას იყოს დაკოპირებული,

425
00:34:36,110 --> 00:34:38,270
ეს CD-ს დირექტორიაში და არ სხვა რამ,

426
00:34:38,270 --> 00:34:42,380
მაგრამ ყველა ეს იმას არ არის აღიარონ როდესაც ფაილის ცვლილებები,

427
00:34:42,380 --> 00:34:45,489
და თუ ეს ცვლილებები, მაშინ იგი მიიღებს ბრძანებები, რომ ის უნდა აწარმოებს

428
00:34:45,489 --> 00:34:48,760
როდესაც ფაილი ცვლილებები. >> [სტუდენტი] Okay.

429
00:34:50,510 --> 00:34:54,420
მე არ ვიცი სად გლობალური მარკა ფაილი ჩემთვის შეამოწმეთ იგი out.

430
00:34:57,210 --> 00:35:04,290
გაქვთ სხვა კითხვები? არაფერს წარსულში ტესტებში? ნებისმიერი მაჩვენებელი რამ?

431
00:35:06,200 --> 00:35:08,730
არსებობს დახვეწილი რამ ერთად პოინტერები მოსწონს -

432
00:35:08,730 --> 00:35:10,220
მე არ ვაპირებ შევძლოთ Quiz საკითხი მას -

433
00:35:10,220 --> 00:35:16,250
მაგრამ ისევე, როგორც ამ სახის რამ.

434
00:35:19,680 --> 00:35:24,060
დარწმუნდით, რომ თქვენ გესმით, რომ როდესაც ვამბობ, რომ int * x * Y -

435
00:35:24,890 --> 00:35:28,130
ეს არ არის ზუსტად არაფერი აქ, ვფიქრობ.

436
00:35:28,130 --> 00:35:32,140
მაგრამ მოსწონს * x * Y, ეს ის 2 ცვლადები, რომლებიც Stack.

437
00:35:32,140 --> 00:35:37,220
როდესაც ვამბობ x = malloc (sizeof (int)), x კვლავ ცვლადი on დასტის,

438
00:35:37,220 --> 00:35:41,180
malloc არის ზოგიერთი ბლოკის დასრულდა ბევრი და ჩვენ მქონე x წერტილი ბევრი.

439
00:35:41,180 --> 00:35:43,900
>> ასე რომ რაღაც დასტის მიუთითებს ბევრი.

440
00:35:43,900 --> 00:35:48,100
როდესაც თქვენ malloc არაფერი, თქვენ აუცილებლად შენახვა ეს შიგნით მაჩვენებელი.

441
00:35:48,100 --> 00:35:55,940
ასე რომ კურსორი არის დასტის, malloced ბლოკი არის ბევრი.

442
00:35:55,940 --> 00:36:01,240
ბევრი ხალხი დაბნეული და აცხადებენ int * x = malloc; x არის ბევრი.

443
00:36:01,240 --> 00:36:04,100
პოსტები რა x მიუთითებს არის ბევრი.

444
00:36:04,100 --> 00:36:08,540
x თავად არის დასტის, თუ სხვადსხვა მიზეზის გამო თქვენ არ x იყოს გლობალური ცვლადი,

445
00:36:08,540 --> 00:36:11,960
ამ შემთხვევაში ხდება, რომ კიდევ ერთ რეგიონში მეხსიერება.

446
00:36:13,450 --> 00:36:20,820
ასე შენახვა ტრეკზე, ეს ყუთი და arrow დიაგრამების საკმაოდ საერთოა ვიქტორინა.

447
00:36:20,820 --> 00:36:25,740
ან თუ არა ინტელექტუალური 0, ეს იქნება ვიქტორინა 1.

448
00:36:27,570 --> 00:36:31,940
თქვენ უნდა იცოდეს, ყველა ეს, ნაბიჯები შედგენა

449
00:36:31,940 --> 00:36:35,740
მას შემდეგ, რაც თქვენ გქონდათ უპასუხოს კითხვებს იმ. დიახ.

450
00:36:35,740 --> 00:36:38,940
[სტუდენტი] ვერ ჩვენ მივდივართ იმ ნაბიჯების - >> დარწმუნებული.

451
00:36:48,340 --> 00:36:58,640
სანამ ნაბიჯები და შედგენა გვაქვს preprocessing,

452
00:36:58,640 --> 00:37:16,750
შედგენა, იკრიბებიან, და აკავშირებს.

453
00:37:16,750 --> 00:37:21,480
Preprocessing. რას აკეთებთ?

454
00:37:29,720 --> 00:37:32,290
ეს არის ყველაზე იოლი ნაბიჯი - კარგად, არ მოსწონს -

455
00:37:32,290 --> 00:37:35,770
ეს არ ნიშნავს, რომ ეს უნდა იყოს აშკარა, მაგრამ ეს იოლი ნაბიჯი.

456
00:37:35,770 --> 00:37:38,410
თქვენ ბიჭები შეეძლო განეხორციელებინა იგი თქუენგან. Yeah.

457
00:37:38,410 --> 00:37:43,410
[სტუდენტი] Take რაც თქვენ თქვენი მოიცავს მოსწონს ეს და ის ასლი და შემდეგ ასევე განსაზღვრავს.

458
00:37:43,410 --> 00:37:49,250
იგი ეძებს რამ, როგორიცაა # include და # განსაზღვრავს,

459
00:37:49,250 --> 00:37:53,800
და ეს მხოლოდ ასლები და პასტები რა იმ რეალურად ნიშნავს.

460
00:37:53,800 --> 00:37:59,240
ასე რომ, როდესაც თქვენ ამბობთ # მოიცავს cs50.h, preprocessor არის კოპირება და pasting cs50.h

461
00:37:59,240 --> 00:38:01,030
შევიდა, რომ ხაზი.

462
00:38:01,030 --> 00:38:06,640
როცა ამბობენ, # define x იყოს 4, preprocessor გადის მთელი პროგრამა

463
00:38:06,640 --> 00:38:10,400
და ცვლის ყველა ინსტანციის x ერთად 4.

464
00:38:10,400 --> 00:38:17,530
ამიტომ preprocessor იღებს მოქმედებს C ფაილი და შედეგები ძალაში C ფაილი

465
00:38:17,530 --> 00:38:20,300
აქ რამ გადაწერა და pasted.

466
00:38:20,300 --> 00:38:24,230
ახლა შედგენა. რას აკეთებთ?

467
00:38:25,940 --> 00:38:28,210
[სტუდენტი] ეს მიემართება C-დან ორობითი.

468
00:38:28,210 --> 00:38:30,970
>> [Bowden] იგი არ წავიდეთ ყველა გზა ორობითი.

469
00:38:30,970 --> 00:38:34,220
[სტუდენტი], რათა მანქანა კოდი მაშინ? >> ეს არ მანქანა კოდი.

470
00:38:34,220 --> 00:38:35,700
[სტუდენტი] ასამბლეის? >> ასამბლეის.

471
00:38:35,700 --> 00:38:38,890
ეს ღებულობენ ასამბლეის სანამ მიდის ყველა გზა C კოდი,

472
00:38:38,890 --> 00:38:45,010
და საუკეთესო ენებზე რაღაც მოსწონს ეს.

473
00:38:47,740 --> 00:38:50,590
Pick ნებისმიერი მაღალი დონის ენა და, თუ თქვენ აპირებს მისი კომპილირება,

474
00:38:50,590 --> 00:38:52,390
ეს სავარაუდოდ კომპილაციის წელს ნაბიჯები.

475
00:38:52,390 --> 00:38:58,140
პირველი ის აპირებს კომპილაციის Python to C, მაშინ იგი აპირებს კომპილაციის C შეკრებისა,

476
00:38:58,140 --> 00:39:01,600
და მაშინ ასამბლეის აპირებს მისაღებად ითარგმნა ენაზე ორობითი.

477
00:39:01,600 --> 00:39:07,800
ამიტომ შედგენას აპირებს მოუტანს იგი C შეკრებისა.

478
00:39:07,800 --> 00:39:12,130
სიტყვა შედგენა ჩვეულებრივ გულისხმობს იგი მაღალ დონეზე

479
00:39:12,130 --> 00:39:14,340
to ქვედა დონის პროგრამირების ენაზე.

480
00:39:14,340 --> 00:39:19,190
ასე რომ, ეს მხოლოდ ნაბიჯი შედგენაში, სადაც თქვენ იწყება მაღალი დონის ენა

481
00:39:19,190 --> 00:39:23,270
და დასრულდება up in დაბალი დონის ენა, და ამიტომაც ნაბიჯი ეწოდება შედგენა.

482
00:39:25,280 --> 00:39:33,370
[სტუდენტი] დროს შედგენა, ვთქვათ, რომ თქვენ გავაკეთეთ # მოიცავს cs50.h.

483
00:39:33,370 --> 00:39:42,190
უილ შემდგენელი recompile cs50.h, როგორიცაა ფუნქციებს, რომლებიც იქ,

484
00:39:42,190 --> 00:39:45,280
და თარგმნოს რომ შევიდა ასამბლეის კოდი ისევე,

485
00:39:45,280 --> 00:39:50,830
ან იქნება ეს დააკოპირეთ და ჩასვით ის, რაც უკვე წინასწარ ასამბლეის?

486
00:39:50,830 --> 00:39:56,910
cs50.h იქნება საკმაოდ ბევრი არასოდეს დასრულდება up in ასამბლეის.

487
00:39:59,740 --> 00:40:03,680
პერსონალის მოსწონს ფუნქცია პროტოტიპები და სიტუაცია უბრალოდ თქვენ ფრთხილად.

488
00:40:03,680 --> 00:40:09,270
იგი გარანტიას, რომ შემდგენელი შეგიძლიათ შეამოწმოთ რამ, როგორიცაა თქვენ მოუწოდებდა ფუნქციები

489
00:40:09,270 --> 00:40:12,910
უფლების მქონე დაბრუნების ტიპის და უფლება არგუმენტები და პერსონალი.

490
00:40:12,910 --> 00:40:18,350
>> ამიტომ cs50.h იქნება preprocessed შევიდა ფაილი, ხოლო შემდეგ, როდესაც ის შედგენა

491
00:40:18,350 --> 00:40:22,310
ის ძირითადად დააგდეს დაშორებით მას შემდეგ, რაც ხდის დარწმუნებული, რომ ყველაფერი მიმდინარეობს მოუწოდა სწორად.

492
00:40:22,310 --> 00:40:29,410
მაგრამ ფუნქციები განისაზღვრება CS50 ბიბლიოთეკა, რომლებიც დამოუკიდებლად cs50.h,

493
00:40:29,410 --> 00:40:33,610
იმ არ იქნება ცალკე შედგენილი.

494
00:40:33,610 --> 00:40:37,270
რომ რეალურად მოდის ქვემოთ აკავშირებს ნაბიჯი, ამიტომ ჩვენ მისაღებად რომ მეორე.

495
00:40:37,270 --> 00:40:40,100
მაგრამ პირველი, რასაც იკრიბებიან?

496
00:40:41,850 --> 00:40:44,500
[სტუდენტი] ასამბლეის ორობითი? >> Yeah.

497
00:40:46,300 --> 00:40:48,190
იკრიბებიან.

498
00:40:48,190 --> 00:40:54,710
ჩვენ არ ეძახით შედგენა რადგან ასამბლეა საკმაოდ ბევრი სუფთა თარგმანი ორობითი.

499
00:40:54,710 --> 00:41:00,230
არსებობს ძალიან მცირე ლოგიკით მიდის საწყისი ასამბლეის ორობითი.

500
00:41:00,230 --> 00:41:03,180
უბრალოდ მინდა ეძებს up in მაგიდა, OH, ჩვენ გვაქვს ამ ინსტრუქციით;

501
00:41:03,180 --> 00:41:06,290
რაც შეესაბამება ორობითი 01110.

502
00:41:10,200 --> 00:41:15,230
და ა.შ. ფაილი, რომელიც იკრიბება ზოგადად მასალები არიან. O ფაილი.

503
00:41:15,230 --> 00:41:19,020
და. O ფაილი რასაც ვამბობდით ადრე,

504
00:41:19,020 --> 00:41:21,570
როგორ ფაილი არ უნდა მთავარი ფუნქცია.

505
00:41:21,570 --> 00:41:27,640
ნებისმიერი ფაილი შეიძლება იყოს შედგენილი ქვემოთ. O ფაილი რადგან ეს სწორი C ფაილი.

506
00:41:27,640 --> 00:41:30,300
ეს შეიძლება იყოს შედგენილი ქვემოთ. O.

507
00:41:30,300 --> 00:41:43,030
ახლა აკავშირებს არის ის, რაც რეალურად მოაქვს bunch of. O ფაილი და მოაქვს მათ შესრულებადი.

508
00:41:43,030 --> 00:41:51,110
და მერე რა აკავშირებს არ არის შეგიძლიათ წარმოიდგინოთ, რომ CS50 ბიბლიოთეკა. O ფაილი.

509
00:41:51,110 --> 00:41:56,980
ეს უკვე შედგენილი ორობითი ფაილი.

510
00:41:56,980 --> 00:42:03,530
და ამრიგად, როდესაც თქვენ კომპილაციის თქვენი ფაილი, თქვენი hello.c, რომელიც მოუწოდებს GetString,

511
00:42:03,530 --> 00:42:06,360
hello.c იღებს შედგენილი ქვემოთ hello.o,

512
00:42:06,360 --> 00:42:08,910
hello.o ახლა ორობითი.

513
00:42:08,910 --> 00:42:12,830
მასში გამოყენებულია GetString, ამიტომ მას სჭირდება წასვლა მეტი cs50.o,

514
00:42:12,830 --> 00:42:16,390
და linker smooshes მათ ერთად და აკოპირებს GetString შევიდა ამ ფაილის

515
00:42:16,390 --> 00:42:20,640
და გამოდის შესრულებადი რომ ყველა ფუნქციით სჭირდება.

516
00:42:20,640 --> 00:42:32,620
ამიტომ cs50.o არ არის რეალურად O ფაილი, მაგრამ მჭიდრო საკმარისი, რომ არ არსებობს ფუნდამენტური განსხვავება.

517
00:42:32,620 --> 00:42:36,880
ასე აკავშირებს მხოლოდ მოაქვს bunch of ფაილი ერთად

518
00:42:36,880 --> 00:42:41,390
რომ ცალკე შეიცავდეს ყველა ფუნქციებს მე უნდა გამოვიყენოთ

519
00:42:41,390 --> 00:42:46,120
და ქმნის შესრულებად, რომელიც რეალურად აწარმოებს.

520
00:42:48,420 --> 00:42:50,780
>> და ისე, რომ ასევე რასაც ვამბობდით ადრე

521
00:42:50,780 --> 00:42:55,970
სადაც შეგიძლიათ აქვს 1000. გ ფაილი თქვენ კომპილაციის მათ ყველა. o ფაილი

522
00:42:55,970 --> 00:43:00,040
რომელიც სავარაუდოდ ხოლო, მაშინ შეცვლის 1. გ ფაილი.

523
00:43:00,040 --> 00:43:05,480
თქვენ მხოლოდ უნდა recompile რომ 1. გ ფაილი და შემდეგ relink ყველაფერი,

524
00:43:05,480 --> 00:43:07,690
დაუკავშირონ ყველაფერი უკან ერთად.

525
00:43:09,580 --> 00:43:11,430
[სტუდენტი] როდესაც ჩვენ აკავშირებს ჩვენ წერენ lcs50?

526
00:43:11,430 --> 00:43:20,510
Yeah, ეგრეთ lcs50. რომ დროშა სიგნალებს linker რომ თქვენ უნდა აკავშირებს ამ ბიბლიოთეკაში.

527
00:43:26,680 --> 00:43:28,910
კითხვები?

528
00:43:41,310 --> 00:43:46,860
გვაქვს წავიდა მეტი ორობითი გარდა, რომ 5 წამში პირველ ლექციას?

529
00:43:50,130 --> 00:43:53,010
მე ასე არ ვფიქრობ.

530
00:43:55,530 --> 00:43:58,820
თქვენ უნდა იცოდეს, ყველა დიდი Os რომ ჩვენ წავიდა მეტი,

531
00:43:58,820 --> 00:44:02,670
და თქვენ უნდა შეეძლოს, თუ მივეცით თქვენ ფუნქცია,

532
00:44:02,670 --> 00:44:09,410
თქვენ უნდა შეეძლოს იმის თქმა, რომ ეს დიდი O, უხეშად. ან კარგად, დიდი O არის უხეში.

533
00:44:09,410 --> 00:44:15,300
ასე რომ, თუ ხედავთ წყობილი ამისთვის მარყუჟების looping იმავე რაოდენობის ნივთები,

534
00:44:15,300 --> 00:44:22,260
მოსწონს int i, მე <n; int j, j <N - >> [სტუდენტი] N კვადრატში. >> ეს tends უნდა იყოს N კვადრატში.

535
00:44:22,260 --> 00:44:25,280
თუ თქვენ არ სამმაგი წყობილი, ეს tends უნდა იყოს N cubed.

536
00:44:25,280 --> 00:44:29,330
ასე რომ ერთგვარი რაც თქვენ უნდა შეეძლოს აღვნიშნო, დაუყოვნებლივ.

537
00:44:29,330 --> 00:44:33,890
თქვენ უნდა იცოდეთ Insertion დალაგება და ბუშტი დალაგება და შერწყმის დალაგება და ყველა იმ.

538
00:44:33,890 --> 00:44:41,420
უფრო ადვილია მესმის, რატომ არიან ისინი იმ N კვადრატში და N შესვლა N და ყველა რომ

539
00:44:41,420 --> 00:44:47,810
რადგან ვფიქრობ, იქ იყო ვიქტორინა ერთი წლის სადაც ჩვენ ძირითადად მისცა თქვენ

540
00:44:47,810 --> 00:44:55,050
განხორციელების bubble sort და თქვა: "რა არის ქრონომეტრაჟი ამ ფუნქციას?"

541
00:44:55,050 --> 00:45:01,020
ასე რომ, თუ თქვენ აღიარებს მას, როგორც ბუშტი დალაგების, მაშინ დაუყოვნებლივ ამბობენ N კვადრატში.

542
00:45:01,020 --> 00:45:05,470
მაგრამ თუ უბრალოდ შეხედეთ მას, თქვენ კი არ უნდა გააცნობიეროს მისი ბუშტი დალაგება;

543
00:45:05,470 --> 00:45:08,990
შეგიძლიათ უბრალოდ ვიტყვი, რომ ეს ამით და ამ. ეს არის n კვადრატში.

544
00:45:12,350 --> 00:45:14,710
[სტუდენტი] არსებობს რაიმე მკაცრი მაგალითები შეგიძლიათ ამუშავება,

545
00:45:14,710 --> 00:45:20,370
მოსწონს მსგავსი იდეა მჭიდროდაა გარეთ?

546
00:45:20,370 --> 00:45:24,450
>> მე არ ვფიქრობ, რომ ჩვენ მოგცემთ ნებისმიერი მკაცრი მაგალითები.

547
00:45:24,450 --> 00:45:30,180
Bubble sort რამ არის, როგორც მკაცრი, როგორც ჩვენ წავიდოდა,

548
00:45:30,180 --> 00:45:36,280
და კიდევ, რომ, როგორც თქვენ გვესმის, რომ თქვენ iterating მეტი მასივი

549
00:45:36,280 --> 00:45:41,670
თითოეული ელემენტი მასივი, რომელიც იქნება რაღაც რომ n კვადრატში.

550
00:45:45,370 --> 00:45:49,940
არსებობს ზოგადი კითხვები, როგორიცაა უფლება აქ გვაქვს - Oh.

551
00:45:55,290 --> 00:45:58,530
უბრალოდ მეორე დღეს, დაგ მტკიცებით, "მე არ გამოიგონა ალგორითმი რომ შეგიძლიათ დაალაგოთ მასივი

552
00:45:58,530 --> 00:46:01,780
"საქართველოს N ნომრები O (შესვლა N) დროს!"

553
00:46:01,780 --> 00:46:04,900
მაშ როგორ ვიცით, რომ შეუძლებელია?

554
00:46:04,900 --> 00:46:08,850
[Inaudible სტუდენტი საპასუხოდ] >> Yeah.

555
00:46:08,850 --> 00:46:13,710
სულ ცოტა, თქვენ უნდა შეეხოთ თითოეულ ელემენტს მასივი,

556
00:46:13,710 --> 00:46:16,210
ამიტომ შეუძლებელია დასალაგებლად მასივი -

557
00:46:16,210 --> 00:46:20,850
თუ ყველაფერი არასორტირებული მიზნით, მაშინ თქვენ უნდა ეხება ყველაფერს მასივი,

558
00:46:20,850 --> 00:46:25,320
ამიტომ შეუძლებელია ამის გაკეთება ნაკლებ O of n.

559
00:46:27,430 --> 00:46:30,340
[სტუდენტი] თქვენ დაგვანახა, რომ მაგალითად, რომ ვერ გააკეთებს ამას O of n

560
00:46:30,340 --> 00:46:33,920
თუ თქვენ იყენებთ მეხსიერების დიდ ნაწილს. >> Yeah.

561
00:46:33,920 --> 00:46:37,970
და that's - მე დაგვავიწყდეს, თუ რა that's - ეს არის ის დათვლის დალაგება?

562
00:46:47,360 --> 00:46:51,330
Hmm. სწორედ რიცხვი დახარისხება ალგორითმი.

563
00:46:59,850 --> 00:47:05,100
მე ეძებდა სპეციალური სახელი ამ რომ მე ვერ გაიხსენა გასულ კვირას.

564
00:47:05,100 --> 00:47:13,000
Yeah. ეს არის სახის ჯიშები, რომელსაც შეუძლია სრულფასოვნად რამ დიდი O of n.

565
00:47:13,000 --> 00:47:18,430
მაგრამ არსებობს შეზღუდვები, როგორიც შეგიძლიათ მხოლოდ მთელი რიცხვები მდე გარკვეული რაოდენობა.

566
00:47:20,870 --> 00:47:24,560
Plus თუ თქვენ ცდილობს დასალაგებლად რაღაც that's -

567
00:47:24,560 --> 00:47:30,750
თუ თქვენი მასივი 012, -12, 151, 4 მილიონი,

568
00:47:30,750 --> 00:47:35,120
მაშინ ეს ერთჯერადი ელემენტს აპირებს მთლიანად ჩაშლის მთელი დახარისხება.

569
00:47:42,060 --> 00:47:44,030
>> კითხვები?

570
00:47:49,480 --> 00:47:58,870
[სტუდენტი] თუ თქვენ გაქვთ რეკურსიული ფუნქცია და უბრალოდ იღებს რეკურსიული მოუწოდებს

571
00:47:58,870 --> 00:48:02,230
ფარგლებში დაბრუნების განაცხადი, რომ კუდი რეკურსიული,

572
00:48:02,230 --> 00:48:07,360
და ასე იქნება, რომ არ გამოიყენოთ მეტი მეხსიერების დროს Runtime

573
00:48:07,360 --> 00:48:12,550
ან იქნებოდა მინიმუმ გამოიყენოთ შესადარებელი მეხსიერების როგორც iterative გამოსავალი?

574
00:48:12,550 --> 00:48:14,530
[Bowden] დიახ.

575
00:48:14,530 --> 00:48:19,840
იგი სავარაუდოდ ერთგვარად ნელა, მაგრამ ნამდვილად არ.

576
00:48:19,840 --> 00:48:23,290
კუდი რეკურსიული არის საკმაოდ კარგი.

577
00:48:23,290 --> 00:48:32,640
ვეძებთ კვლავ დასტის ფარგლებში, ვთქვათ გვაქვს მთავარი

578
00:48:32,640 --> 00:48:42,920
და ჩვენ გვაქვს int ბარი (int x) ან რამე.

579
00:48:42,920 --> 00:48:52,310
ეს არ არის სრულყოფილი რეკურსიული ფუნქცია, მაგრამ დაბრუნების ბარი (x - 1).

580
00:48:52,310 --> 00:48:57,620
ამიტომ ცხადია, რომ ეს არის სრულყოფილი. თქვენ უნდა ბაზის შემთხვევებში და პერსონალი.

581
00:48:57,620 --> 00:49:00,360
მაგრამ იდეა აქ მდგომარეობს იმაში, რომ ეს კუდი რეკურსიული,

582
00:49:00,360 --> 00:49:06,020
რაც იმას ნიშნავს, როდესაც მთავარ მოუწოდებს ბარი იგი აპირებს მიიღოს მისი დასტის ჩარჩო.

583
00:49:09,550 --> 00:49:12,440
ამ დასტის ჩარჩო იქ იქნება პატარა ბლოკი მეხსიერება

584
00:49:12,440 --> 00:49:17,490
რაც შეესაბამება მისი არგუმენტი x.

585
00:49:17,490 --> 00:49:25,840
და ასე ვთქვათ ძირითადი ხდება მოვუწოდო ბარი (100);

586
00:49:25,840 --> 00:49:30,050
ამიტომ x იწყებს, როგორც 100.

587
00:49:30,050 --> 00:49:35,660
თუ შემდგენელი აღიარებს, რომ ეს არის კუდი რეკურსიული ფუნქცია,

588
00:49:35,660 --> 00:49:38,540
მაშინ, როდესაც ბარი იცავს თავის რეკურსიული ზარი ბარი,

589
00:49:38,540 --> 00:49:45,490
ნაცვლად მიღების ახალი დასტის ფორმატი, რომელიც არის სადაც დასტის იწყებს მზარდი დიდწილად,

590
00:49:45,490 --> 00:49:48,220
საბოლოოდ იგი გადაეყარონ ბევრი და შემდეგ თქვენ მიიღებთ segfaults

591
00:49:48,220 --> 00:49:51,590
რადგან მეხსიერების იწყება colliding.

592
00:49:51,590 --> 00:49:54,830
>> ასე რომ ნაცვლად მიღების საკუთარი დასტის ჩარჩოში, მას შეუძლია გააცნობიეროს,

593
00:49:54,830 --> 00:49:59,080
Hey, მე არასოდეს რეალურად უნდა დაუბრუნდეს ამ დასტის ჩარჩო,

594
00:49:59,080 --> 00:50:08,040
ასე ნაცვლად მე უბრალოდ შეცვალეთ ეს არგუმენტი ერთად 99 და შემდეგ დაიწყოს ბარი მთელი.

595
00:50:08,040 --> 00:50:11,810
და მერე ამას კვლავ და მიაღწევს დაბრუნების ბარი (x - 1),

596
00:50:11,810 --> 00:50:17,320
და ნაცვლად მიღების ახალი დასტის ჩარჩოს, იგი მხოლოდ შეცვლის მისი ამჟამინდელი არგუმენტი ერთად 98

597
00:50:17,320 --> 00:50:20,740
და მაშინ ხტომა თავში დასაბამიდანვე ბარი.

598
00:50:23,860 --> 00:50:30,430
იმ ოპერაციებს, შეცვლის, რომ 1 ღირებულება დასტის და jumping დასაწყისში,

599
00:50:30,430 --> 00:50:32,430
საკმაოდ ეფექტური.

600
00:50:32,430 --> 00:50:41,500
ასე არა მხოლოდ არის ამ იგივე მეხსიერების გამოყენებას, როგორც ცალკეული ფუნქცია რომელიც iterative

601
00:50:41,500 --> 00:50:45,390
იმიტომ, რომ თქვენ მხოლოდ გამოყენებით 1 დასტის ჩარჩო, მაგრამ თქვენ არ განიცდიდა downsides

602
00:50:45,390 --> 00:50:47,240
, რომელმაც უნდა მოვუწოდებთ ფუნქციები.

603
00:50:47,240 --> 00:50:50,240
დარეკვის ფუნქციები შეიძლება იყოს გარკვეულწილად ძვირი, რადგან მას ყველაფერი ამ კონფიგურაციის

604
00:50:50,240 --> 00:50:52,470
და teardown და ყველა ამ პერსონალის.

605
00:50:52,470 --> 00:50:58,160
ასე რომ, ეს კუდი უკან არის კარგი.

606
00:50:58,160 --> 00:51:01,170
[სტუდენტი] რატომ არ შევქმნათ ახალი ნაბიჯები?

607
00:51:01,170 --> 00:51:02,980
რადგან ეს აცნობიერებს ამას არ სჭირდება.

608
00:51:02,980 --> 00:51:07,800
ზარი ბარი მხოლოდ დაბრუნების რეკურსიული ზარი.

609
00:51:07,800 --> 00:51:12,220
ასე რომ, ეს არ უნდა გავაკეთოთ არაფერი დაბრუნებული მნიშვნელობა.

610
00:51:12,220 --> 00:51:15,120
უბრალოდ აპირებს დაუყოვნებლივ დაბრუნება.

611
00:51:15,120 --> 00:51:20,530
ამიტომ უბრალოდ აპირებს შეცვალოს საკუთარი არგუმენტი და დაიწყონ ზე.

612
00:51:20,530 --> 00:51:25,780
და ასევე, თუ თქვენ არ კუდი რეკურსიული ვერსია,

613
00:51:25,780 --> 00:51:31,460
მაშინ თქვენ გაქვთ ყველა ამ ბარები, სადაც როცა ეს ბარი ბრუნდება

614
00:51:31,460 --> 00:51:36,010
ეს უნდა დაიბრუნოს ღირებულება ამ ერთი, მაშინ ეს ბარი დაუყოვნებლივ დააბრუნებს

615
00:51:36,010 --> 00:51:39,620
და ის დააბრუნებს მისი ღირებულება ამ ერთი, მაშინ ის უბრალოდ აპირებს დაუყოვნებლივ დაბრუნდეს

616
00:51:39,620 --> 00:51:41,350
და დაიბრუნოს ღირებულება ამ ერთ.

617
00:51:41,350 --> 00:51:45,350
ასე რომ თქვენ გადარჩენის ამ popping ყველა ამ საკითხზე გამორთვა დასტის

618
00:51:45,350 --> 00:51:48,730
მას შემდეგ, რაც დაბრუნების ღირებულება მხოლოდ აპირებს გადაეცემა ყველა გზა უკან მდე მაინც.

619
00:51:48,730 --> 00:51:55,400
რატომ არა მხოლოდ ჩაანაცვლოს ჩვენი არგუმენტი მიაწოდა უახლესი არგუმენტი და დაიწყონ ზე?

620
00:51:57,460 --> 00:52:01,150
თუ ფუნქცია არ არის კუდი რეკურსიული, თუ რაღაც მსგავსი -

621
00:52:01,150 --> 00:52:07,530
[სტუდენტი] თუ ბარი (x + 1). >> Yeah.

622
00:52:07,530 --> 00:52:11,770
>> ასე რომ, თუ თქვენ დააყენოს ის მდგომარეობა, მაშინ თქვენ აკეთებთ რაღაც ერთად დაბრუნებული მნიშვნელობა.

623
00:52:11,770 --> 00:52:16,260
ან თუნდაც, თუ თქვენ უბრალოდ დაბრუნების 2 * ბარი (x - 1).

624
00:52:16,260 --> 00:52:23,560
ახლა ბარი (x - 1) სჭირდება დაბრუნებას, რათა ეს გამოთვლა 2 ჯერ რომ ღირებულება,

625
00:52:23,560 --> 00:52:26,140
ახლა ეს იმას სჭირდება საკუთარი ცალკე დასტის ჩარჩო,

626
00:52:26,140 --> 00:52:31,180
და ახლა, რაც არ უნდა მძიმე თქვენ ცდილობენ, თქვენ აპირებს უნდა -

627
00:52:31,180 --> 00:52:34,410
ეს არ არის კუდი რეკურსიული.

628
00:52:34,410 --> 00:52:37,590
[სტუდენტი] უნდა ვეცადოთ, რათა უკან დაბრუნების მიზანია ამისთვის კუდი უკან -

629
00:52:37,590 --> 00:52:41,450
[Bowden] In იდეალური მსოფლიოში, მაგრამ CS50 თქვენ არ.

630
00:52:43,780 --> 00:52:49,280
მისაღებად კუდი უკან, ძირითადად, შეიქმნას დამატებითი არგუმენტი

631
00:52:49,280 --> 00:52:53,550
სადაც ბარი მიიღებს int x შევიდა Y

632
00:52:53,550 --> 00:52:56,990
და Y შეესაბამება საბოლოო რამ გსურთ დაბრუნებას.

633
00:52:56,990 --> 00:53:03,650
ასე რომ მაშინ ეს თქვენ უნდა დაბრუნების ბარი (x - 1), 2 * Y.

634
00:53:03,650 --> 00:53:09,810
ასე რომ უბრალოდ მაღალი დონის, თუ როგორ გარდაქმნის რამ იქნება კუდი რეკურსიული.

635
00:53:09,810 --> 00:53:13,790
მაგრამ ზედმეტი არგუმენტი -

636
00:53:13,790 --> 00:53:17,410
ხოლო შემდეგ დასრულდება, როდესაც თქვენ მიღწევა თქვენი ბაზა შემთხვევაში, უბრალოდ დაბრუნების Y

637
00:53:17,410 --> 00:53:22,740
რადგან თქვენ უკვე დაგროვების მთელი დროის დაბრუნებული მნიშვნელობა რომ გსურთ.

638
00:53:22,740 --> 00:53:27,280
თქვენ სახის უკვე აკეთებს ამას iteratively მაგრამ მისი გამოყენება რეკურსიული მოუწოდებს.

639
00:53:32,510 --> 00:53:34,900
კითხვები?

640
00:53:34,900 --> 00:53:39,890
[სტუდენტი] იქნებ შესახებ კურსორი არითმეტიკა, ასე, როდესაც გამოყენებით სტრიქონები. >> დარწმუნებული.

641
00:53:39,890 --> 00:53:43,610
Pointer არითმეტიკული.

642
00:53:43,610 --> 00:53:48,440
გამოყენებისას სიმები ადვილი რადგან სიმები არიან char ვარსკვლავი,

643
00:53:48,440 --> 00:53:51,860
chars არიან სამუდამოდ და ყოველთვის ერთი ბაიტი,

644
00:53:51,860 --> 00:53:57,540
და ა.შ. კურსორის არითმეტიკული უდრის რეგულარული არითმეტიკული როცა თქვენ საქმე სტრიქონები.

645
00:53:57,540 --> 00:54:08,790
მოდით უბრალოდ, ვამბობთ char * s = "Hello".

646
00:54:08,790 --> 00:54:11,430
ამიტომ ბლოკი მეხსიერება.

647
00:54:19,490 --> 00:54:22,380
ნიშანდობლივია 6 bytes რადგან თქვენ ყოველთვის გვჭირდება null terminator.

648
00:54:22,380 --> 00:54:28,620
და char * s აპირებს აღვნიშნო, რომ დასაწყისში მასივი.

649
00:54:28,620 --> 00:54:32,830
რათა მიუთითებს იქ.

650
00:54:32,830 --> 00:54:36,710
ახლა, ეს არის ძირითადად, თუ როგორ ნებისმიერი მასივი მუშაობს,

651
00:54:36,710 --> 00:54:40,780
მიუხედავად იმისა, რომ ეს იყო დაბრუნებას malloc თუ ის შესახებ Stack.

652
00:54:40,780 --> 00:54:47,110
ნებისმიერი მასივი ძირითადად მომცეთ დაწყების მასივი,

653
00:54:47,110 --> 00:54:53,640
და მაშინ ნებისმიერი ოპერაციის მასივი, ნებისმიერი ინდექსირებას, მხოლოდ მიდის, რომ მასივი გარკვეული წანაცვლება.

654
00:54:53,640 --> 00:55:05,360
>> ამიტომ როდესაც ვამბობ, რომ მსგავსი რამ s [3]; ამ აპირებს და დათვლის 3 chars სისტემაში

655
00:55:05,360 --> 00:55:12,490
ასე s [3], ჩვენ გვაქვს 0, 1, 2, 3, ასე s [3] აპირებს მიმართოს ამ ლ.

656
00:55:12,490 --> 00:55:20,460
[სტუდენტი] და ჩვენ შეგვიძლია მივაღწიოთ იმავე ღირებულების ამით s + 3 და შემდეგ ფრჩხილებში ვარსკვლავი?

657
00:55:20,460 --> 00:55:22,570
დიახ.

658
00:55:22,570 --> 00:55:26,010
ეს არის ექვივალენტური * (s + 3);

659
00:55:26,010 --> 00:55:31,240
და ეს სამუდამოდ და ყოველთვის ექვივალენტი არ აქვს მნიშვნელობა, თუ რას აკეთებთ.

660
00:55:31,240 --> 00:55:34,070
თქვენ არასოდეს უნდა გამოვიყენოთ bracket სინტაქსი.

661
00:55:34,070 --> 00:55:37,770
თქვენ ყოველთვის შეგიძლიათ გამოიყენოთ * (s + 3) სინტაქსი.

662
00:55:37,770 --> 00:55:40,180
ხალხი ტენდენცია მინდა bracket სინტაქსი, თუმცა.

663
00:55:40,180 --> 00:55:43,860
[სტუდენტი] ასე ყველა კოლექტორები რეალურად მხოლოდ პოინტერები.

664
00:55:43,860 --> 00:55:53,630
არსებობს უმნიშვნელო განსხვავება როდესაც ვამბობ, რომ int x [4]; >> [სტუდენტი] აქვს თუ არა, რომ შევქმნათ მეხსიერება?

665
00:55:53,630 --> 00:56:03,320
[Bowden], რომ აპირებს შექმნას 4 ints on დასტის, ასე 16 ბაიტი საერთო.

666
00:56:03,320 --> 00:56:05,700
ის აპირებს შექმნას 16 ბაიტი on Stack.

667
00:56:05,700 --> 00:56:09,190
x არ ინახება არსად.

668
00:56:09,190 --> 00:56:13,420
უბრალოდ სიმბოლო გულისხმობდა დაწყების რამ.

669
00:56:13,420 --> 00:56:17,680
იმიტომ, რომ თქვენ განაცხადა მასივი შიგნით ამ ფუნქციას,

670
00:56:17,680 --> 00:56:22,340
რა შემდგენელი აპირებს მხოლოდ ჩაანაცვლოს ყველა ინსტანციის ცვლადი x

671
00:56:22,340 --> 00:56:26,400
ერთად სადაც ეს მოხდა, აირჩიოს, რომ ეს 16 ბაიტი.

672
00:56:26,400 --> 00:56:30,040
მას არ შეუძლია გააკეთოს, რომ char * s რადგან s არის ფაქტობრივი მაჩვენებელი.

673
00:56:30,040 --> 00:56:32,380
იგი თავისუფალია მაშინ აღვნიშნო, რომ სხვა რამ.

674
00:56:32,380 --> 00:56:36,140
x არის მუდმივი. შეგიძლიათ არ აქვს ის წერტილი სხვადასხვა მასივი. >> [სტუდენტი] Okay.

675
00:56:36,140 --> 00:56:43,420
მაგრამ ამ იდეას, ამ ინდექსირებას, იგივეა მიუხედავად იმისა, რომ ეს ტრადიციული მასივი

676
00:56:43,420 --> 00:56:48,230
ან თუ ეს მაჩვენებელი რაიმე ან თუ მომცეთ malloced მასივი.

677
00:56:48,230 --> 00:56:59,770
და რეალურად, ეს ასე ექვივალენტს, რომ ასევე იგივე.

678
00:56:59,770 --> 00:57:05,440
ეს ფაქტიურად მხოლოდ ითარგმნება რა შიგნით ფრჩხილებში და რაც დარჩა ფრჩხილები,

679
00:57:05,440 --> 00:57:07,970
დასძენს მათი ერთად, და dereferences.

680
00:57:07,970 --> 00:57:14,710
ასე რომ, ეს უბრალოდ, როგორც მოქმედი, როგორც * (s + 3) ან s [3].

681
00:57:16,210 --> 00:57:22,090
[სტუდენტი] შეგიძლიათ აქვს პოინტერები მიუთითებს 2 განზომილებიანი მასივები?

682
00:57:22,090 --> 00:57:27,380
>> ეს უფრო რთული. ტრადიციულად, არ.

683
00:57:27,380 --> 00:57:34,720
2 განზომილებიანი მასივი მხოლოდ 1 განზომილებიანი მასივი რამდენიმე მოსახერხებელი სინტაქსი

684
00:57:34,720 --> 00:57:54,110
რადგან როდესაც ვამბობ, რომ int x [3] [3], ეს მართლაც მხოლოდ 1 მასივში 9 ღირებულებებს.

685
00:57:55,500 --> 00:58:03,000
და ა.შ. როცა ინდექსი, შემდგენელი იცის რას ვგულისხმობ.

686
00:58:03,000 --> 00:58:13,090
თუ მე ვიტყვი, x [1] [2], იგი დარწმუნებულია, მინდა წასვლა მეორე რიგის, ამიტომ აპირებს გამოტოვოთ პირველი 3,

687
00:58:13,090 --> 00:58:17,460
და შემდეგ მას სურს მეორე რამ, რომ, ამიტომ აპირებს ამ ერთ.

688
00:58:17,460 --> 00:58:20,480
მაგრამ ეს ჯერ კიდევ მხოლოდ ერთი განზომილებიანი მასივი.

689
00:58:20,480 --> 00:58:23,660
და თუ მინდოდა დაავალოს მომცეთ, რომ მასივი,

690
00:58:23,660 --> 00:58:29,770
მე ვიტყოდი, int * p = x;

691
00:58:29,770 --> 00:58:33,220
გაცნობის x უბრალოდ -

692
00:58:33,220 --> 00:58:38,280
ეს უხეში ამბობდა გაცნობის x რადგან ეს მხოლოდ სიმბოლოა და ეს არ ფაქტობრივი ცვლადი,

693
00:58:38,280 --> 00:58:40,140
მაგრამ ეს მხოლოდ int *.

694
00:58:40,140 --> 00:58:44,840
x არის მხოლოდ მომცეთ დაწყება ამ. >> [სტუდენტი] Okay.

695
00:58:44,840 --> 00:58:52,560
და მე ვერ შეძლებს წვდომისათვის [1] [2].

696
00:58:52,560 --> 00:58:58,370
ვფიქრობ, რომ არსებობს სპეციალური სინტაქსი გამოცხადების მაჩვენებელი,

697
00:58:58,370 --> 00:59:12,480
რაღაც სასაცილოა მოსწონს int (* P [- რაღაც აბსოლუტურად სასაცილოა. ისიც კი არ იციან.

698
00:59:12,480 --> 00:59:17,090
მაგრამ არის სინტაქსი გამოცხადების პოინტერები მოსწონს ერთად ფრჩხილებში და რამ.

699
00:59:17,090 --> 00:59:22,960
ეს შეიძლება არც კი მოგცემთ, რომ.

700
00:59:22,960 --> 00:59:26,640
მე ვერ ვიხსენებთ რაღაც რომ მითხრათ სიმართლე.

701
00:59:26,640 --> 00:59:34,160
მე ვეძებოთ იგი მოგვიანებით, თუ არსებობს სინტაქსი წერტილი. მაგრამ თქვენ არასოდეს ჩანს.

702
00:59:34,160 --> 00:59:39,670
და მაშინაც კი, სინტაქსის იმდენად არქაული, რომ თუ თქვენ გამოიყენოს იგი, ხალხი იქნება baffled.

703
00:59:39,670 --> 00:59:43,540
მრავალგანზომილებიანი მასივები საკმაოდ იშვიათი არ არის.

704
00:59:43,540 --> 00:59:44,630
თქვენ საკმაოდ ბევრი -

705
00:59:44,630 --> 00:59:48,490
ისე, თუ თქვენ აკეთებთ matrix რამ ეს არ იქნება იშვიათი,

706
00:59:48,490 --> 00:59:56,730
მაგრამ C თქვენ იშვიათად იქნება გამოყენებით მრავალგანზომილებიანი მასივები.

707
00:59:57,630 --> 01:00:00,470
Yeah. >> [სტუდენტი] ვთქვათ თქვენ გაქვთ მართლაც ხანგრძლივი მასივი.

708
01:00:00,470 --> 01:00:03,900
>> ასე რომ ვირტუალური მეხსიერების იქნებოდა, როგორც ჩანს, ყველა ზედიზედ,

709
01:00:03,900 --> 01:00:05,640
მოსწონს ელემენტების უფლება მომდევნო ერთმანეთს,

710
01:00:05,640 --> 01:00:08,770
მაგრამ ფიზიკური მეხსიერება, რომ შესაძლებელი რომ რომ გაიყოფა up? >> დიახ.

711
01:00:08,770 --> 01:00:16,860
როგორ ვირტუალური მეხსიერება სამუშაოების უბრალოდ ჰყოფს -

712
01:00:19,220 --> 01:00:24,860
ერთეულის გამოყოფის არის გვერდი, რომელიც tends უნდა იყოს 4 kilobytes,

713
01:00:24,860 --> 01:00:29,680
და ამრიგად, როდესაც პროცესში ამბობს, hey, მინდა გამოვიყენო ეს მეხსიერება,

714
01:00:29,680 --> 01:00:35,970
ოპერაციული სისტემა აპირებს გამოყოს ის 4 kilobytes რომ პატარა ბლოკი მეხსიერება.

715
01:00:35,970 --> 01:00:39,100
მაშინაც კი, თუ თქვენ მხოლოდ ერთი პატარა byte მთელ ბლოკი მეხსიერება,

716
01:00:39,100 --> 01:00:42,850
ოპერაციული სისტემა აპირებს მისცეს მას სრული 4 kilobytes.

717
01:00:42,850 --> 01:00:49,410
მერე რა ეს ნიშნავს, მე შეიძლება - ვთქვათ ეს არის ჩემი Stack.

718
01:00:49,410 --> 01:00:53,180
ეს დასტის შეიძლება გამოყოფილი. ჩემი დასტის შეიძლება მეგაბაიტები და მეგაბაიტები.

719
01:00:53,180 --> 01:00:55,020
ჩემი დასტის შეიძლება იყოს უზარმაზარი.

720
01:00:55,020 --> 01:01:00,220
მაგრამ დასტის თავად უნდა გაიყო ინდივიდუალური გვერდებზე,

721
01:01:00,220 --> 01:01:09,010
რომელიც, თუ დავაკვირდებით აქ ვთქვათ ეს არის ჩვენი RAM,

722
01:01:09,010 --> 01:01:16,600
თუ მაქვს 2 გბ ოპერატიული მეხსიერება, ეს არის ფაქტობრივი მისამართი 0 მოსწონს zeroth byte ჩემი RAM,

723
01:01:16,600 --> 01:01:22,210
და ეს არის 2 გიგაბაიტი ყველა გზა ქვემოთ აქ.

724
01:01:22,210 --> 01:01:27,230
ასე რომ, ეს გვერდი შესაძლოა შეესაბამება ამ ბლოკის მეტი აქ.

725
01:01:27,230 --> 01:01:29,400
ეს გვერდი შესაძლოა შეესაბამება ამ ბლოკის მეტი აქ.

726
01:01:29,400 --> 01:01:31,560
ეს შეიძლება შეესაბამება ამ ერთი მეტი აქ.

727
01:01:31,560 --> 01:01:35,540
ამიტომ ოპერაციული სისტემის უფასო დაავალოს ფიზიკური მეხსიერება

728
01:01:35,540 --> 01:01:39,320
ნებისმიერი ინდივიდუალური გვერდზე თვითნებურად.

729
01:01:39,320 --> 01:01:46,180
და ეს ნიშნავს, რომ თუ ამ საზღვრის ხდება straddle მასივი,

730
01:01:46,180 --> 01:01:50,070
array ხდება უნდა დაუტოვებიათ ამ და უფლება ამ ბრძანებით გვერდზე,

731
01:01:50,070 --> 01:01:54,460
მაშინ ეს მასივი იქნება გაყოფილი, ფიზიკური მეხსიერება.

732
01:01:54,460 --> 01:01:59,280
და მაშინ, როდესაც თავი დაანებონ პროგრამა, როდესაც პროცესი დამთავრდა,

733
01:01:59,280 --> 01:02:05,690
ამ mappings კიდევ წაშლილია და შემდეგ ეს უფასო გამოიყენოს ამ პატარა ბლოკები სხვა რამ.

734
01:02:14,730 --> 01:02:17,410
სხვა კითხვები?

735
01:02:17,410 --> 01:02:19,960
[სტუდენტი] მაჩვენებელი არითმეტიკული. >> Oh Yeah.

736
01:02:19,960 --> 01:02:28,410
სიმები იყო ადვილი, მაგრამ ეძებს რაღაც ints,

737
01:02:28,410 --> 01:02:35,000
ასე დაბრუნდა int x [4];

738
01:02:35,000 --> 01:02:41,810
თუ არა ეს არის array თუ ის მომცეთ malloced მასივი 4 რიცხვებით,

739
01:02:41,810 --> 01:02:47,060
ეს იქნება დამუშავებული იგივე გზით.

740
01:02:50,590 --> 01:02:53,340
[სტუდენტი] ასე კოლექტორები არიან ბევრი?

741
01:03:01,400 --> 01:03:05,270
[Bowden] მასივები არ არიან ბევრი. >> [სტუდენტი] Oh.

742
01:03:05,270 --> 01:03:08,320
>> [Bowden] ამ ტიპის მასივი tends იყოს დასტის

743
01:03:08,320 --> 01:03:12,220
თუ თქვენ გამოაცხადა at - იგნორირება გლობალური ცვლადები. არ გამოიყენოთ გლობალური ცვლადები.

744
01:03:12,220 --> 01:03:16,280
შიგნით ფუნქციის ვამბობ int x [4];

745
01:03:16,280 --> 01:03:22,520
ის აპირებს შექმნას 4-მთელი რიცხვი ბლოკი დასტის ამ მასივი.

746
01:03:22,520 --> 01:03:26,960
მაგრამ ეს malloc (4 * sizeof (int)); აპირებს გაგრძელდება ბევრი.

747
01:03:26,960 --> 01:03:31,870
მაგრამ მას შემდეგ, რაც ამ ეტაპზე მე შემიძლია გამოვიყენო X და P ში საკმაოდ ბევრი იგივე გზები,

748
01:03:31,870 --> 01:03:36,140
გარდა გამონაკლისი ვთქვი შესახებ შეგიძლიათ reassign გვ.

749
01:03:36,140 --> 01:03:40,960
ტექნიკურად, მათი ზომის არიან განსხვავებული, მაგრამ ეს სრულიად შეუსაბამო.

750
01:03:40,960 --> 01:03:43,310
თქვენ არასოდეს რეალურად გამოიყენონ თავიანთი ზომის.

751
01:03:48,020 --> 01:03:56,810
P მე შეიძლება ითქვას, P [3] = 2; x ან [3] = 2;

752
01:03:56,810 --> 01:03:59,680
თქვენ შეგიძლიათ გამოიყენოთ ისინი ზუსტად იგივე გზა არსებობს.

753
01:03:59,680 --> 01:04:01,570
ამიტომ კურსორი არითმეტიკული არის - დიახ.

754
01:04:01,570 --> 01:04:07,390
[სტუდენტი] მიგაჩნიათ თუ არა არ უნდა გავაკეთოთ P * თუ თქვენ გაქვთ ფრჩხილები?

755
01:04:07,390 --> 01:04:11,720
ფრჩხილებში არიან დაფარული dereference. >> Okay.

756
01:04:11,720 --> 01:04:20,200
სინამდვილეში, ასევე თუ რას ამბობდა ერთად შეგიძლიათ მიიღოთ მრავალგანზომილებიანი მასივები

757
01:04:20,200 --> 01:05:02,650
ერთად პოინტერები, თუ რა შეგიძლიათ გააკეთოთ მსგავსი რამ, ასე ვთქვათ, int ** PP = malloc (sizeof (int *) * 5);

758
01:05:02,650 --> 01:05:06,900
მე უბრალოდ დავწერ აქ ყველა პირველ.

759
01:05:37,880 --> 01:05:41,020
მე არ მინდოდა, რომ ერთი.

760
01:05:41,020 --> 01:05:42,550
Okay.

761
01:05:42,550 --> 01:05:48,910
რა გავაკეთე აქ არის - ეს უნდა იყოს PP [i].

762
01:05:48,910 --> 01:05:53,680
ამიტომ PP არის მომცეთ მაჩვენებელი.

763
01:05:53,680 --> 01:06:02,420
თქვენ mallocing PP აღვნიშნო, რომ მასივი 5 int ვარსკვლავს.

764
01:06:02,420 --> 01:06:10,950
ასე რომ მეხსიერება გაქვთ on დასტის გვ

765
01:06:10,950 --> 01:06:20,150
იგი აპირებს აღვნიშნო, რომ მასივი 5 ბლოკები რომლებიც ყველა თავად პოინტერები.

766
01:06:20,150 --> 01:06:28,210
და მაშინ როდესაც მე malloc ქვემოთ აქ, მე malloc რომ თითოეული იმ მცირე პოინტერები

767
01:06:28,210 --> 01:06:32,080
უნდა აღვნიშნო, რომ ცალკე ბლოკი 4 ბაიტი on ბევრი.

768
01:06:32,080 --> 01:06:35,870
ასე რომ, ეს მიუთითებს 4 ბაიტი.

769
01:06:37,940 --> 01:06:40,660
და ეს ერთი ქულა სხვადასხვა 4 ბაიტი.

770
01:06:40,660 --> 01:06:43,200
>> და ყველა მათგანი აღვნიშნო, რომ საკუთარი 4 ბაიტი.

771
01:06:43,200 --> 01:06:49,080
ეს მაძლევს გზას აკეთებს მრავალგანზომილებიანი რამ.

772
01:06:49,080 --> 01:06:58,030
მე შეიძლება ითქვას, PP [3] [4], მაგრამ ახლა ეს არ არის იგივე როგორც მრავალგანზომილებიანი მასივები

773
01:06:58,030 --> 01:07:05,390
რადგან მრავალგანზომილებიანი მასივები ეს ნათარგმნი [3] [4] ერთ ოფსეტური შევიდა x მასივი.

774
01:07:05,390 --> 01:07:14,790
ეს dereferences P, ხელმისაწვდომი მესამე ინდექსი, შემდეგ dereferences რომ

775
01:07:14,790 --> 01:07:20,790
და ხელმისაწვდომი - 4 იქნებოდა არასწორი - მეორე ინდექსი.

776
01:07:24,770 --> 01:07:31,430
ვინაიდან, როდესაც ჩვენ გვქონდა int x [3] [4] ადრე როგორც მრავალგანზომილებიანი მასივი

777
01:07:31,430 --> 01:07:35,740
და როდესაც თქვენ გაორმაგება bracket ეს მართლაც მხოლოდ ერთი dereference,

778
01:07:35,740 --> 01:07:40,490
თქვენ შემდეგ ერთი მაჩვენებელი და შემდეგ წანაცვლება,

779
01:07:40,490 --> 01:07:42,850
ეს მართლაც 2D დამოწმება.

780
01:07:42,850 --> 01:07:45,840
თქვენ დაიცვას 2 ცალკე პოინტერები.

781
01:07:45,840 --> 01:07:50,420
ასე რომ, ეს ასევე ტექნიკურად საშუალებას გაძლევთ მრავალგანზომილებიანი მასივები

782
01:07:50,420 --> 01:07:53,550
სადაც თითოეულ ინდივიდუალური მასივი სხვადასხვა ზომის.

783
01:07:53,550 --> 01:07:58,000
ამიტომ ვფიქრობ Jagged მრავალგანზომილებიანი მასივები არის რასაც ის მოუწოდა

784
01:07:58,000 --> 01:08:01,870
რადგან მართლაც პირველი, რაც შეიძლება აღვნიშნო, რომ ის, რაც აქვს 10 ელემენტები,

785
01:08:01,870 --> 01:08:05,540
მეორე რამ შეიძლება აღვნიშნო, რომ ის, რაც აერთიანებს 100 ელემენტებს.

786
01:08:05,540 --> 01:08:10,790
[სტუდენტი] არსებობს თუ არა ლიმიტი რაოდენობის პოინტერები თქვენ შეგიძლიათ

787
01:08:10,790 --> 01:08:14,290
მიუთითებს სხვა პოინტერები? >> პოსტები

788
01:08:14,290 --> 01:08:17,010
თქვენ შეგიძლიათ int ***** გვ.

789
01:08:18,050 --> 01:08:23,760
თავში მაჩვენებელი არითმეტიკა - >> [სტუდენტი] Oh. >> Yeah.

790
01:08:23,760 --> 01:08:35,649
[სტუდენტი] თუ მაქვს int *** P და მერე გავაკეთო dereferencing და ვამბობ P * უდრის ამ მნიშვნელობის,

791
01:08:35,649 --> 01:08:39,560
იგი მხოლოდ აპირებს 1 დონე dereferencing? >> დიახ.

792
01:08:39,560 --> 01:08:43,340
ასე რომ, თუ მინდა წვდომისათვის, რაც ბოლო მაჩვენებელი არის მიუთითებს -

793
01:08:43,340 --> 01:08:46,210
მერე შენ *** გვ. >> Okay.

794
01:08:46,210 --> 01:08:54,080
ასე რომ, ეს არის P ქულა 1 კვარტალი, რაოდენობა მეორეში ბლოკი, რაოდენობა სხვა ბლოკი.

795
01:08:54,080 --> 01:09:02,010
მაშინ თუ * p = რაღაც, მაშინ იცვლება ამ

796
01:09:02,010 --> 01:09:13,640
აქამდე აღვნიშნო, რომ სხვადასხვა ბლოკში. >> Okay.

797
01:09:13,640 --> 01:09:17,649
>> [Bowden] და თუ ეს იყო malloced, მაშინ არ არის გაჟონა მეხსიერება

798
01:09:17,649 --> 01:09:20,430
თუ თქვენ მოხდეს განსხვავებული მითითება ამ

799
01:09:20,430 --> 01:09:25,270
რადგან ვერ დაიბრუნებს იმ განსხვავებით, რომ თქვენ მხოლოდ დაუშინეს დაშორებით.

800
01:09:25,270 --> 01:09:29,550
Pointer არითმეტიკული.

801
01:09:29,550 --> 01:09:36,310
int x [4]; აპირებს გამოყოს მასივი 4 რიცხვებით

802
01:09:36,310 --> 01:09:40,670
სადაც x აპირებს აღვნიშნო, რომ დასაწყისში მასივი.

803
01:09:40,670 --> 01:09:50,420
ამიტომ როდესაც ვამბობ, რომ მსგავსი რამ x [1]; მინდა ეს ნიშნავს წასვლა მეორე რიცხვი მასივში,

804
01:09:50,420 --> 01:09:53,319
რაც იქნება ეს ერთი.

805
01:09:53,319 --> 01:10:04,190
მაგრამ რეალურად, რომ 4 ბაიტი შევიდა მასივი რადგან ეს რიცხვი იკავებს 4 ბაიტს.

806
01:10:04,190 --> 01:10:08,470
ამიტომ ოფსეტური of 1 ნამდვილად ნიშნავს ურთიერთჩათვლის of 1

807
01:10:08,470 --> 01:10:12,030
ჯერ ზომა ნებისმიერი ტიპის მასივი.

808
01:10:12,030 --> 01:10:17,170
ეს არის მასივი რიცხვებით, ასე რომ იცის გავაკეთოთ 1 ჯერ ზომა int როდესაც მას სურს წანაცვლება.

809
01:10:17,170 --> 01:10:25,260
სხვა სინტაქსი. გახსოვდეთ, რომ ეს არის ექვივალენტური * (x + 1);

810
01:10:25,260 --> 01:10:35,250
როდესაც ვამბობ კურსორი + 1, რა, რომ ანაზღაურება არის მისამართი, რომ მომცეთ არის შენახვის

811
01:10:35,250 --> 01:10:40,360
პლუს 1 ჯერ ზომა ტიპის მაჩვენებელი.

812
01:10:40,360 --> 01:10:59,510
ასე რომ, თუ x = ox100, მაშინ x + 1 = ox104.

813
01:10:59,510 --> 01:11:19,750
და შეგიძლიათ ბოროტად გამოიყენოს ეს და ვთქვათ რაღაც char * გ = (char *) x;

814
01:11:19,750 --> 01:11:23,050
და ახლა გ იქნება ერთსა და იმავე მისამართზე, როგორც x.

815
01:11:23,050 --> 01:11:26,040
გ იქნება ტოლი ox100,

816
01:11:26,040 --> 01:11:31,490
მაგრამ გ + 1 იქნება ტოლი ox101

817
01:11:31,490 --> 01:11:38,030
რადგან კურსორი არითმეტიკული დამოკიდებულია ტიპის მაჩვენებელი, რომ თქვენ შეავსოთ.

818
01:11:38,030 --> 01:11:45,390
ასე რომ გ + 1, ის უყურებს გ, ეს char მაჩვენებელი, ამიტომ აპირებს დაამატოთ 1 ჯერ ზომა char,

819
01:11:45,390 --> 01:11:48,110
რომელიც ყოველთვის იქნება 1, ასე რომ თქვენ მიიღოთ 101,

820
01:11:48,110 --> 01:11:54,890
ხოლო თუ x, რომელიც არის ასევე დღემდე 100, x + 1 იქნება 104.

821
01:11:56,660 --> 01:12:06,340
[სტუდენტი] შეგიძლიათ გამოიყენოთ C + + დახვეწის მიზნით თქვენი კურსორი მიერ 1?

822
01:12:06,340 --> 01:12:09,810
დიახ, შეგიძლიათ.

823
01:12:09,810 --> 01:12:16,180
თქვენ ვერ, რომ x რადგან x არის მხოლოდ სიმბოლო, ეს არის მუდმივი, თქვენ ვერ შეცვლის x.

824
01:12:16,180 --> 01:12:22,610
>> მაგრამ გ ხდება მხოლოდ კურსორი, ისე C + + სრულიად სწორი და ის ნამატი მიერ 1.

825
01:12:22,610 --> 01:12:32,440
თუ C იყო int *, მაშინ C + + იქნებოდა 104.

826
01:12:32,440 --> 01:12:41,250
+ + არ მომცეთ არითმეტიკული ისევე როგორც C + 1 ექნება გაკეთდეს მაჩვენებელი არითმეტიკული.

827
01:12:43,000 --> 01:12:48,870
ეს არის რეალურად რამდენად ბევრი რამ, როგორიცაა შერწყმა დალაგება -

828
01:12:49,670 --> 01:12:55,710
იმის ნაცვლად, რომ შექმნას ასლები რამ, შეგიძლიათ ნაცვლად გაივლის -

829
01:12:55,710 --> 01:13:02,400
Like თუ მინდოდა გაივლის ამ ნახევარში მასივი - მოდით წაშლას ზოგიერთი ამ.

830
01:13:04,770 --> 01:13:10,520
ვთქვათ მინდოდა გაივლის ამ მხარეს მასივი შევიდა ფუნქცია.

831
01:13:10,520 --> 01:13:12,700
რა მე გადავიდეთ რომ ფუნქცია?

832
01:13:12,700 --> 01:13:17,050
თუ მე გაივლის x, მე გავლით ამ მისამართზე.

833
01:13:17,050 --> 01:13:23,780
მაგრამ მინდა გაივლის ამ კონკრეტულ მისამართზე. ასე რა უნდა გაიაროს?

834
01:13:23,780 --> 01:13:26,590
[სტუდენტი] Pointer + 2?

835
01:13:26,590 --> 01:13:29,350
[Bowden] So x + 2. დიახ.

836
01:13:29,350 --> 01:13:31,620
რომ იქნება ამ მისამართზე.

837
01:13:31,620 --> 01:13:42,810
თქვენ ასევე ძალიან ხშირად ვხედავ მას, როგორც x [2] და შემდეგ მისამართს რომ.

838
01:13:42,810 --> 01:13:47,850
ასე, რომ თქვენ უნდა მიიღოს მისამართი რადგან bracket არის დაფარული dereference.

839
01:13:47,850 --> 01:13:53,250
x [2] ეხება ღირებულება, რომელიც არის ამ ყუთში, შემდეგ კი გსურთ მისამართი რომ ყუთი,

840
01:13:53,250 --> 01:13:56,850
ასე რომ თქვენ ამბობენ & x [2].

841
01:13:56,850 --> 01:14:02,880
ასე რომ, თუ როგორ რაღაც შერწყმა დალაგების სადაც გსურთ გაიაროს ნახევარ სიაში რაიმე

842
01:14:02,880 --> 01:14:08,790
ნამდვილად უბრალოდ გაივლის და X [2] და ახლა რამდენადაც რეკურსიული ზარის ეხება,

843
01:14:08,790 --> 01:14:12,510
ჩემი ახალი მასივი იწყება იქ.

844
01:14:12,510 --> 01:14:15,130
ბოლო წუთი კითხვები.

845
01:14:15,130 --> 01:14:20,050
[სტუდენტი] თუ ჩვენ არ დააყენა ampersand ან - რა რომ ქვია? >> Star?

846
01:14:20,050 --> 01:14:23,200
[სტუდენტი] Star. >> ტექნიკურად, dereference ოპერატორი, მაგრამ - >> [სტუდენტი] Dereference.

847
01:14:23,200 --> 01:14:29,310
>> თუ ჩვენ არ დააყენა ვარსკვლავი ან ampersand, რა მოხდება თუ მე უბრალოდ ამბობენ Y = X და X-ის მაჩვენებელი?

848
01:14:29,310 --> 01:14:34,620
რა არის გაცნობის Y? >> [სტუდენტი] მე უბრალოდ, ვამბობთ ეს მაჩვენებელი 2.

849
01:14:34,620 --> 01:14:38,270
ასე რომ, თუ თქვენ უბრალოდ ამბობენ Y = x, ახლა x და y წერტილი იგივე. >> [სტუდენტი] ქულა, რათა იგივე.

850
01:14:38,270 --> 01:14:45,180
და თუ x არის int მაჩვენებელი? >> იქნებოდა უჩივიან, რადგან ვერ დაავალოს პოინტერები.

851
01:14:45,180 --> 01:14:46,540
[სტუდენტი] Okay.

852
01:14:46,540 --> 01:14:51,860
გახსოვდეთ, რომ გჭირდებათ, მიუხედავად იმისა, რომ ჩვენ დავხატოთ მათ ისრები,

853
01:14:51,860 --> 01:15:02,010
მართლაც ყველა მათ მაღაზიაში - int * x - მართლაც ყველა X-ის შენახვის არის რაღაც ox100,

854
01:15:02,010 --> 01:15:06,490
რაც ჩვენ არ უნდა წარმოადგენდეს, როგორც მიუთითებს ბლოკი ინახება 100.

855
01:15:06,490 --> 01:15:19,660
ამიტომ როდესაც ვამბობ, რომ int * y = x; მე უბრალოდ კოპირება ox100 შევიდა Y,

856
01:15:19,660 --> 01:15:24,630
რაც ჩვენ უბრალოდ აპირებს წარმოადგინოს როგორც Y, ასევე მიუთითებს ox100.

857
01:15:24,630 --> 01:15:39,810
და თუ ვიტყვი int i = (int) x, მერე აპირებს შესანახად რასაც ღირებულება ox100 არის

858
01:15:39,810 --> 01:15:45,100
შიგნით, მაგრამ ახლა ეს იქნება გაგებული, როგორც მთელი რიცხვი ნაცვლად მაჩვენებელი.

859
01:15:45,100 --> 01:15:49,310
მაგრამ არ არის საჭირო მსახიობი ანდა იქნება უჩივიან.

860
01:15:49,310 --> 01:15:53,300
[სტუდენტი] ასე რომ თქვენ საშუალება მისცეს -

861
01:15:53,300 --> 01:16:00,290
ხომ უნდა ისროდნენ int of x ან ჩამოსხმის int of Y?

862
01:16:00,290 --> 01:16:03,700
[Bowden] რა?

863
01:16:03,700 --> 01:16:07,690
[სტუდენტი] Okay. ამის შემდეგ ფრჩხილებში არის იქ იქნება x ან ay იქ?

864
01:16:07,690 --> 01:16:11,500
>> [Bowden] ან. x და y არიან ექვივალენტი. >> [სტუდენტი] Okay.

865
01:16:11,500 --> 01:16:14,390
რადგან ისინი ორივე პოინტერები. >> Yeah.

866
01:16:14,390 --> 01:16:21,050
[სტუდენტი] ასე რომ ის შესანახად თექვსმეტობითი 100 წელს მთელი ფორმით? >> [Bowden] Yeah.

867
01:16:21,050 --> 01:16:23,620
მაგრამ არ ღირებულება რაც არ მიუთითებს.

868
01:16:23,620 --> 01:16:29,940
[Bowden] Yeah. >> [სტუდენტი] ასე რომ მხოლოდ მისამართი რიცხვი ფორმით. Okay.

869
01:16:29,940 --> 01:16:34,720
[Bowden] თუ უნდოდა რაღაც უცნაური მიზეზი,

870
01:16:34,720 --> 01:16:38,900
თქვენ შეიძლება მხოლოდ გაუმკლავდეთ პოინტერები და არასდროს გაუმკლავდეთ რიცხვებით

871
01:16:38,900 --> 01:16:49,240
და უბრალოდ იყოს int * x = 0.

872
01:16:49,240 --> 01:16:53,000
მაშინ თქვენ აპირებს მისაღებად ნამდვილად დაბნეული ერთხელ მაჩვენებელი არითმეტიკული იწყება ხდება.

873
01:16:53,000 --> 01:16:56,570
ასე რომ ციფრები, რომ მათ შესანახად არის უაზრო.

874
01:16:56,570 --> 01:16:58,940
უბრალოდ, თუ როგორ დასრულდება მდე წერით მათ.

875
01:16:58,940 --> 01:17:02,920
ასე რომ, მე ვარ თავისუფალი კოპირება ox100 საწყისი int * to int,

876
01:17:02,920 --> 01:17:07,790
და მე თავისუფალი დაავალოს - you're ალბათ აპირებს მისაღებად yelled დროს არ აძლევენ -

877
01:17:07,790 --> 01:17:18,160
მე უფასო დაავალოს რაღაც (int *) ox1234 ამ თვითნებური int *.

878
01:17:18,160 --> 01:17:25,480
ამიტომ ox123 ისეთივე მოქმედებს მეხსიერების მისამართი როგორც არის & Y.

879
01:17:25,480 --> 01:17:32,060
& Y ხდება დაბრუნდეს რაღაც რომ არის საკმაოდ ბევრი ox123.

880
01:17:32,060 --> 01:17:35,430
[სტუდენტი] რა, რომ იყოს მართლა მაგარი გზა გადასვლა თექვსმეტობითი to ათობითი ფორმა,

881
01:17:35,430 --> 01:17:39,230
მინდა თუ გაქვთ მომცეთ და მიიღო ის როგორც int?

882
01:17:39,230 --> 01:17:44,860
[Bowden] შეგიძლიათ ნამდვილად უბრალოდ ბეჭდვა გამოყენებით, როგორიცაა printf.

883
01:17:44,860 --> 01:17:50,300
ვთქვათ მაქვს int y = 100.

884
01:17:50,300 --> 01:18:02,700
ამიტომ printf (% d \ n - როგორც თქვენ უნდა უკვე ვიცით - ბეჭდვა, რომ როგორც მთელი რიცხვი,% x.

885
01:18:02,700 --> 01:18:05,190
ჩვენ მხოლოდ ბეჭდვა, როგორც თექვსმეტობითი.

886
01:18:05,190 --> 01:18:10,760
ასე რომ კურსორი არ ინახება როგორც თექვსმეტობითი,

887
01:18:10,760 --> 01:18:12,960
და რიცხვი არ არის ინახება როგორც ათობითი.

888
01:18:12,960 --> 01:18:14,700
ყველაფერი ინახება როგორც ორობითი.

889
01:18:14,700 --> 01:18:17,950
უბრალოდ, ჩვენ გვსურს წავახალისოთ ნახოთ პოინტერები როგორც თექვსმეტობითი

890
01:18:17,950 --> 01:18:23,260
რადგან მიგვაჩნია, რომ რამ ამ 4-byte ბლოკები,

891
01:18:23,260 --> 01:18:25,390
და მეხსიერების მისამართები ტენდენცია იყოს ნაცნობი.

892
01:18:25,390 --> 01:18:28,890
ჩვენ მსგავსად, თუ იგი იწყება BF, მაშინ ეს ხდება იქნება Stack.

893
01:18:28,890 --> 01:18:35,560
ასე რომ ეს მხოლოდ ჩვენი ინტერპრეტაცია პოინტერები როგორც თექვსმეტობითი.

894
01:18:35,560 --> 01:18:39,200
Okay. ნებისმიერი ბოლო კითხვები?

895
01:18:39,200 --> 01:18:41,700
>> მე აქ ცოტა შემდეგ თუ არაფერი.

896
01:18:41,700 --> 01:18:46,070
და ეს ბოლომდე რომ.

897
01:18:46,070 --> 01:18:48,360
>> [სტუდენტი] YAY! [ტაში]

898
01:18:51,440 --> 01:18:53,000
>> [CS50.TV]