1
00:00:00,000 --> 00:00:02,520
[Powered by Google Translate] [धारा 4 - और अधिक आरामदायक]

2
00:00:02,520 --> 00:00:04,850
[रोब Bowden - हार्वर्ड विश्वविद्यालय]

3
00:00:04,850 --> 00:00:07,370
[यह CS50 है. - CS50.TV]

4
00:00:08,920 --> 00:00:13,350
हम एक प्रश्नोत्तरी कल है, मामले में आप लोगों को पता नहीं था.

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
लेकिन आम तौर पर आप उस के बारे में चिंता नहीं है और आप बस कहना है कि एक्स + 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. >> हाँ. तो int * p.

23
00:01:33,530 --> 00:01:38,030
और मैं कैसे कर सकता हूँ यह एक्स के लिए बात? >> [छात्र] एम्परसेंड.

24
00:01:40,540 --> 00:01:45,300
[Bowden] तो सचमुच एम्परसेंड ऑपरेटर का पता कहा जाता है.

25
00:01:45,300 --> 00:01:50,460
तो जब मैं कहता हूँ और एक्स चर x की स्मृति पता हो रही है.

26
00:01:50,460 --> 00:01:56,790
तो अब मैं सूचक पी है, और कहीं भी अपने कोड में मैं * पी का उपयोग कर सकते हैं

27
00:01:56,790 --> 00:02:02,960
या मैं एक्स का उपयोग करें और यह सटीक एक ही बात हो जाएगा सकता है.

28
00:02:02,960 --> 00:02:09,520
(पी *). यह क्या कर रही है? उस स्टार का क्या मतलब है?

29
00:02:09,520 --> 00:02:13,120
[छात्र] यह उस बिंदु पर एक मूल्य का मतलब है. >> हाँ.

30
00:02:13,120 --> 00:02:17,590
तो अगर हम इसे देखो, यह बहुत उपयोगी हो सकता है बाहर चित्र आकर्षित कर सकते हैं

31
00:02:17,590 --> 00:02:22,230
जहां इस एक्स के लिए एक स्मृति के छोटे से बॉक्स है, जो 4 मूल्य होता है,

32
00:02:22,230 --> 00:02:25,980
तो हम पी के लिए एक स्मृति के एक छोटे से बॉक्स है,

33
00:02:25,980 --> 00:02:31,590
और तो एक्स के लिए पी अंक, तो हम एक्स पी से एक तीर आकर्षित.

34
00:02:31,590 --> 00:02:40,270
तो जब हम कहते हैं * पी हम कह रहे हैं बॉक्स है कि पी है.

35
00:02:40,270 --> 00:02:46,480
स्टार तीर का पालन करने के लिए है और फिर भी आप सही है कि बॉक्स के साथ वहाँ चाहते हैं.

36
00:02:46,480 --> 00:03:01,090
इसलिए मैं कह सकता हूँ * = 7 पी, और कि बॉक्स कि एक्स और कि 7 से परिवर्तन करने के लिए जाना जाएगा.

37
00:03:01,090 --> 00:03:13,540
या मैं कह सकता int z = * 2; p यह भ्रामक है, क्योंकि यह सितारा सितारा,.

38
00:03:13,540 --> 00:03:19,230
एक सितारा पी dereferencing है, अन्य सितारा 2 से गुणा है.

39
00:03:19,230 --> 00:03:26,780
सूचना है मैं बस के रूप में अच्छी तरह से एक्स के साथ * पी की जगह हो सकता है.

40
00:03:26,780 --> 00:03:29,430
आप उन्हें उसी तरह का उपयोग कर सकते हैं.

41
00:03:29,430 --> 00:03:38,000
और फिर मैं बाद में एक पूरी तरह से नई बात पी बिंदु हो सकता है.

42
00:03:38,000 --> 00:03:42,190
मैं सिर्फ कह सकते हैं p = &z;

43
00:03:42,190 --> 00:03:44,940
तो अब एक्स के लिए अब अंक पी, यह Z करने के लिए कहते हैं.

44
00:03:44,940 --> 00:03:50,510
और यह किसी भी समय मैं * पी 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
जैसे हम पहले स्वैप के साथ देखा था, आप एक प्रभावी स्वैप और एक अलग समारोह नहीं कर सकते

52
00:04:39,990 --> 00:04:45,180
बस integers गुजर क्योंकि सी में सब कुछ हमेशा मूल्य से गुजर रहा है.

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 (पी), मैं function foo में सूचक गुजर रहा हूँ

56
00:05:00,770 --> 00:05:03,910
और फिर foo * = 6 पी कर रही है;

57
00:05:03,910 --> 00:05:08,600
तो अंदर है कि समारोह के * पी अभी भी एक्स के लिए बराबर है,

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? >> [छात्र] हाँ.

63
00:05:44,270 --> 00:05:48,480
[Bowden] ठीक है. आप यह कभी नहीं करना चाहिए. यह बुरा है.

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 32 या 2 है.

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
>> हाँ. ढेर के शीर्ष पर है, यह नहीं है? >> [छात्र] खैर, वह शीर्ष पर 0 डाल दिया.

71
00:06:27,760 --> 00:06:30,320
[छात्र] ओह, वह शीर्ष पर 0 डाल दिया. >> [छात्र] ओह, ठीक है.

72
00:06:30,320 --> 00:06:36,060
अस्वीकरण: CS50 साथ कहीं भी आप इसे इस तरह से देखने के लिए जा रहे हैं. >> [छात्र] ठीक है.

73
00:06:36,060 --> 00:06:40,290
यह सिर्फ है कि जब आप पहली बार के ढेर देख रहे हैं,

74
00:06:40,290 --> 00:06:45,000
जैसे जब आप एक ढेर आप एक दूसरे के ऊपर पर बातें stacking के बारे में सोच के बारे में सोचो.

75
00:06:45,000 --> 00:06:50,810
तो हम इस के आसपास फ्लिप इतना ढेर एक ढेर सामान्य तरह से बढ़ रहा है करते हैं

76
00:06:50,810 --> 00:06:55,940
बजाय ढेर के नीचे लटक. >> [छात्र] नहीं ढेर तकनीकी भी बढ़ता है, हालांकि?

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 - >> हाँ.

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
हाँ. मैं एक दूसरे में मिल जाएगा.

94
00:08:06,180 --> 00:08:12,220
सबसे पहले, क्यों y और लौटने के लिए वापस जा रहा है एक बुरी बात है,

95
00:08:12,220 --> 00:08:18,470
ढेर पर आप ढेर फ्रेम का एक गुच्छा है जो कार्यों के सभी का प्रतिनिधित्व है

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
और इतनी है कि 2 बार के लिए कॉल करने के लिए अपने स्वयं के ढेर फ्रेम पाने के लिए जा रहा है.

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] हाँ.

111
00:09:36,900 --> 00:09:45,010
स्मृति के इस छोटे से वर्ग में कहीं न कहीं एक के रूप में बड़ा वर्ग है कि उस में y है.

112
00:09:45,010 --> 00:09:53,370
जब मैं वापस और y, मैं स्मृति के इस छोटे से ब्लॉक करने के लिए एक सूचक लौट रहा हूँ.

113
00:09:53,370 --> 00:09:58,400
लेकिन तब जब एक समारोह रिटर्न, अपने स्टैक फ्रेम ढेर popped हो जाता है.

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
या यहां तक ​​कि ट्रे के एक ढेर की तरह हमेशा उदाहरण है,

117
00:10:11,580 --> 00:10:16,060
मुख्य तल पर जाने के लिए जा रहा है, तो आप 1 समारोह कॉल करने के लिए उस के शीर्ष पर जा रहा है,

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 - >> [छात्र] यह ओवरराइट हो सकती है. >> हाँ.

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
क्योंकि कि सूचक बुरा स्मृति अंक. >> [छात्र] ठीक है.

127
00:10:51,770 --> 00:11:01,250
तो क्या हुआ अगर, उदाहरण के लिए, आप घोषित int * y = malloc ((int) sizeof)?

128
00:11:01,250 --> 00:11:03,740
यह बेहतर है. हां.

129
00:11:03,740 --> 00:11:07,730
[छात्र] हम कैसे के बारे में बात की थी जब हम हमारे रीसायकल बिन बातें खींचें

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
बाज यहाँ पर अपने स्वयं के ढेर फ्रेम मिल जा रहा है.

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
लेकिन आप उस पर भरोसा नहीं कर सकते. सी बस अपरिभाषित व्यवहार कहते हैं.

142
00:11:49,670 --> 00:11:51,920
>> [छात्र] ओह, यह करता है. ठीक है.

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
हमेशा ढेर पर जाना.

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
ठीक है, तो यह वहाँ होना जब तक कार्यक्रम सभी तरह से चल रहा है किया जा रहा है. हाँ. >>

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 एक सूचक बनाता है? >> हाँ.

155
00:13:04,190 --> 00:13:13,030
Malloc - >> [छात्र] मुझे लगता है कि malloc स्मृति है कि एक सूचक का उपयोग कर सकते हैं की एक ब्लॉक designates.

156
00:13:15,400 --> 00:13:19,610
[Bowden] मुझे लगता है कि आरेख फिर से करना चाहते हैं. >> [छात्र] तो इस समारोह में काम करता है, हालांकि?

157
00:13:19,610 --> 00:13:26,430
[छात्र] हाँ malloc स्मृति का एक ब्लॉक है कि आप उपयोग कर सकते हैं designates,

158
00:13:26,430 --> 00:13:30,470
और तो यह है कि स्मृति के 1 ब्लॉक का पता देता है.

159
00:13:30,470 --> 00:13:36,750
>> [Bowden] हाँ. तो जब आप malloc, आप स्मृति के कुछ ब्लॉक हथियाने रहे हैं

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 कॉल करने के लिए है कि आप पहले से मुक्त कर दिया था कि स्मृति पुन: उपयोग कर सकते हैं.

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
जैसे ही आप एक घुंघराले ब्रेस अतीत जाना, स्थानीय चर मर चुके हैं.

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 है.

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
[छात्र] आप घुंघराले ब्रेसिज़ का उपयोग करके सिर्फ एक ब्लॉक को परिभाषित कर सकते हैं

186
00:15:17,230 --> 00:15:21,220
लेकिन नहीं करने के लिए एक बयान या एक समय या उस तरह बयान कुछ भी अगर?

187
00:15:21,220 --> 00:15:29,130
आप के रूप में एक समारोह में एक ब्लॉक को परिभाषित कर सकते हैं, लेकिन है कि घुंघराले ब्रेसिज़ भी है.

188
00:15:29,130 --> 00:15:32,100
तो [छात्र] क्या आप सिर्फ अपने कोड में घुंघराले ब्रेसिज़ के एक यादृच्छिक जोड़ी की तरह नहीं हो सकता है

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
कि 2 घुंघराले ब्रेस के बाद, 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
कि हम में आदेश सिर्फ चीजों को आसान बनाने के लिए दे एक झूठ / ग़लतफ़हमी 1/2 की तरह है.

197
00:16:18,760 --> 00:16:24,410
हम आपको बताना है कि जब आप स्मृति आवंटित करने के

198
00:16:24,410 --> 00:16:29,860
आप उस चर के लिए राम का कुछ हिस्सा आवंटित कर रहे हैं.

199
00:16:29,860 --> 00:16:34,190
लेकिन तुम सच में सीधे नहीं रैम रहे हैं कभी छू अपने कार्यक्रमों में.

200
00:16:34,190 --> 00:16:37,490
यदि आप यह सोच है, मैं कैसे आकर्षित किया है -

201
00:16:37,490 --> 00:16:44,330
और वास्तव में, अगर आप 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 रैम पर माना जाता है के कुछ मनमाना पदनाम

208
00:17:27,650 --> 00:17:31,320
कि वास्तव में जब समारोह में बुलाया गया था पर निर्भर करता है अलग स्थानों में हो सकता है.

209
00:17:31,320 --> 00:17:35,920
हाँ. अवधि आभासी स्मृति है.

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
और यह इस कार्यक्रम के लिए भिन्नता के लिए असंभव एक सूचक

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
राम पर वास्तविक बातें.

220
00:18:20,470 --> 00:18:22,940
तो यह आपके ऑपरेटिंग सिस्टम पर निर्भर करता है कि पता है,

221
00:18:22,940 --> 00:18:28,080
अरे, जब इस आदमी को dereferences सूचक oxbfff, कि वास्तव में इसका मतलब है

222
00:18:28,080 --> 00:18:31,040
कि वह रैम 1000 बाइट चाहता है,

223
00:18:31,040 --> 00:18:38,150
है जबकि इस कार्यक्रम dereferences oxbfff अगर, वह वास्तव में रैम 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
Analogies कड़ी मेहनत कर रहे हैं.

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
और कि अपसंदर्भन स्मृति पते 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
जैसे कि यह ढेर या कुछ और पर है, तो यह है कि स्मृति पते के मूल्य वापसी करेंगे

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 से बैल 8 f's - ffffffff.

258
00:21:46,330 --> 00:21:49,180
[छात्र] क्या तुमने नहीं कहा वे 4 बाइट्स कर रहे हैं? >> हाँ.

259
00:21:49,180 --> 00:21:52,730
[छात्र] तो प्रत्येक बाइट होगा - >> [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
तो वहाँ 4 बाइट्स के लिए 8 हेक्साडेसिमल अंक होने जा रहा है.

264
00:22:09,600 --> 00:22:14,190
तो एक 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
जिसका अर्थ है कि जहाँ तक यह पता है, यह स्मृति के 32 बाइट्स के लिए एक पूरे 2 का पता कर सकते हैं.

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
और ऑपरेटिंग सिस्टम काफी चालाक है कि यह केवल आवंटित क्या आप वास्तव में जरूरत है.

271
00:22:44,930 --> 00:22:49,630
यह बस नहीं जाना है, ओह, एक नई प्रक्रिया: 4 gigs.

272
00:22:49,630 --> 00:22:51,930
>> हाँ. >> [छात्र] बैल क्या मतलब है? आप यह क्यों लिख सकता हूँ?

273
00:22:51,930 --> 00:22:54,980
यह सिर्फ हेक्सादशमलव के लिए प्रतीक है.

274
00:22:54,980 --> 00:22:59,590
जब आप बैल के साथ एक नंबर शुरू देखते हैं, लगातार बातें षोडश आधारी हैं.

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
बस मैपिंग कि यह इन पतों के लिए है, और वह यह है erases.

278
00:23:13,600 --> 00:23:17,770
ऑपरेटिंग सिस्टम अब सिर्फ कि स्मृति उपयोग करने के लिए एक कार्यक्रम के लिए दे सकते हैं.

279
00:23:17,770 --> 00:23:19,490
[छात्र] ठीक है.

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
[छात्र] हालांकि वहाँ शायद अभी भी मूल्यों में लिखा? >> हाँ.

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
लेकिन मुख्य स्मृति, रैम, आप एक बहुत तेजी से चक्र के माध्यम से,

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
[छात्र] मैं एक अलग विषय के बारे में प्रश्न हैं. ठीक है. >>

294
00:24:16,130 --> 00:24:19,060
क्या किसी को इस पर सवाल है?

295
00:24:20,170 --> 00:24:23,120
>> ठीक है. अलग विषय है. >> [छात्र] ठीक है.

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
सी मानक -

303
00:24:52,960 --> 00:24:54,950
मैं शायद गड़बड़ करने के लिए जा रहा हूँ.

304
00:24:54,950 --> 00:24:58,800
सी मानक बस की तरह है सी क्या है, सी. के सरकारी दस्तावेज

305
00:24:58,800 --> 00:25:00,340
यह है कि यह क्या कहते हैं.

306
00:25:00,340 --> 00:25:08,650
सी मानक तो बस का कहना है कि एक चार और हमेशा हमेशा 1 बाइट होगा.

307
00:25:10,470 --> 00:25:19,040
उस के बाद सब कुछ - हमेशा एक छोटी बस से अधिक या एक चार के बराबर किया जा रहा है के रूप में परिभाषित किया है.

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
इतनी ही बात सी मानक को परिभाषित करता है सब कुछ के रिश्तेदार आदेश है.

313
00:25:46,610 --> 00:25:54,880
स्मृति की वास्तविक राशि है कि चीजों को लेने के आम तौर पर लागू करने के लिए है,

314
00:25:54,880 --> 00:25:57,640
लेकिन यह बहुत अच्छी तरह से इस बिंदु पर परिभाषित किया गया है. >> [छात्र] ठीक है.

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
लांग चाहता लगभग हमेशा 8 बाइट्स होने जा रहे हैं.

318
00:26:17,990 --> 00:26:23,160
और चाहता है, यह है कि क्या आप एक 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
लांग चाहता लगभग हमेशा 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 पर निर्भर करता है. >> [छात्र] ठीक है.

330
00:27:15,800 --> 00:27:24,600
मंगाई, कैसे बिट्स के मामले में नामित दशमलव बिंदु है?

331
00:27:24,600 --> 00:27:27,160
द्विआधारी के रूप में की तरह? >> हाँ.

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
मैं सही बिट आवंटन भूल जाते हैं.

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
[छात्र] और एक डबल? कि एक अतिरिक्त लंबी नाव की तरह है? >> हाँ.

350
00:29:01,100 --> 00:29:07,940
यह अब 4 बाइट्स की बजाय 8 बाइट का उपयोग कर रहे हैं के अलावा एक नाव के रूप में एक ही बात है.

351
00:29:07,940 --> 00:29:11,960
अब आप 9 अंक या 10 अंक का उपयोग करने में सक्षम हो जाएगा,

352
00:29:11,960 --> 00:29:16,630
और यह 300 के बजाय 100 करने के लिए जाने के लिए सक्षम हो जाएगा. >> [छात्र] ठीक है.

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
[छात्र] ठीक है. और वहाँ डबल डबल्स रहे हैं? >> नहीं कर रहे हैं.

358
00:29:38,380 --> 00:29:43,660
मुझे लगता है कि - >> लंबी चाहता है की तरह [छात्र]? >> हाँ. मुझे नहीं लगता. हां.

359
00:29:43,660 --> 00:29:45,950
पिछले साल के परीक्षण पर [छात्र] वहाँ मुख्य समारोह के बारे में एक सवाल था

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
क्या आप समस्या है? >> [छात्र] हाँ, मैं निश्चित रूप से इसे खींच कर सकते हैं.

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
यह सही है या गलत तरह था: एक वैध - >> ओह, एक ग फ़ाइल.?

368
00:30:16,220 --> 00:30:18,790
छात्र किसी भी सी फ़ाइल होना चाहिए - [दोनों को एक साथ बोल - unintelligible]

369
00:30:18,790 --> 00:30:21,120
ठीक है. तो यह है कि अलग है.

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 कार्य करता है, लेकिन कोई मुख्य लिख सकते हैं

375
00:30:45,460 --> 00:30:48,800
और तो द्विआधारी कि नीचे संकलन,

376
00:30:48,800 --> 00:30:54,460
तो आप किसी अन्य फ़ाइल है कि केवल मुख्य है लिखने लेकिन यह इन कार्यों में से एक गुच्छा कॉल

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
यह कहा जाता है एक संकलक है. सही है या गलत?

385
00:31:36,710 --> 00:31:42,030
और जवाब झूठा था, और मैं समझ क्यों यह बजना की तरह नहीं है.

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
मैं इस ऊपर खींचने के लिए कर सकते हैं. हाँ.

391
00:32:10,110 --> 00:32:13,180
ओह, हाँ. यह भी है कि नहीं करता है.

392
00:32:13,180 --> 00:32:17,170
यह कहते हैं बनाने उपयोगिता के उद्देश्य के लिए स्वचालित रूप से निर्धारित है

393
00:32:17,170 --> 00:32:19,610
जो एक बड़े कार्यक्रम के टुकड़े को कंपाइल किया जाना चाहिए

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
आप अलग - अलग फ़ाइलों संकलन नीचे कर सकते हैं, और यह नहीं है जब तक आप linker को मिल

398
00:32:36,930 --> 00:32:39,270
कि वे एक साथ एक निष्पादन में डाल रहे हैं.

399
00:32:39,270 --> 00:32:43,810
तो अगर आप 10 अलग अलग फ़ाइलों है और आप उनमें से एक के लिए एक बदलाव बनाने,

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
आप लिख सकते हैं एक फ़ाइल इतना करना है कि जब आप यह सिर्फ सीडी एक निर्देशिका बनाने के लिए लिखें.

407
00:33:09,150 --> 00:33:15,560
मैं निराश हो गया था क्योंकि मैं कील सब कुछ मेरे उपकरण के अंदर

408
00:33:15,560 --> 00:33:21,740
और फिर मैं मैक से पीडीएफ देखने.

409
00:33:21,740 --> 00:33:30,720
>> तो मैं खोजक के लिए जाना है और मैं जाना कर सकते हैं, सर्वर से कनेक्ट करने के लिए,

410
00:33:30,720 --> 00:33:36,950
और सर्वर मैं कनेक्ट मेरी उपकरण है, और फिर मैं ऊपर पीडीएफ खोलने

411
00:33:36,950 --> 00:33:40,190
कि लेटेक्स द्वारा संकलित किया जाता है.

412
00:33:40,190 --> 00:33:49,320
लेकिन मैं निराश हो रही थी क्योंकि हर बार मैं करने के लिए पीडीएफ ताज़ा करने की जरूरत है,

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
तुम कैसे बनाने के लिए यह पीडीएफ लेटेक्स है.

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
यदि आप एक सी फ़ाइल संकलन कर रहे हैं, बजना का उपयोग करें.

420
00:34:16,679 --> 00:34:20,960
और यहाँ तो मेरे बनाने फ़ाइल में है कि मैं मैं कहता हूँ,

421
00:34:20,960 --> 00:34:25,020
इस फाइल करने के लिए पीडीएफ लेटेक्स के साथ संकलन करना चाहता हूँ जा रहे हैं.

422
00:34:25,020 --> 00:34:27,889
और इसलिए यह पीडीएफ लेटेक्स कि संकलन कर रहा है.

423
00:34:27,889 --> 00:34:31,880
बनाने के लिए नहीं संकलन है. यह सिर्फ मैं निर्दिष्ट अनुक्रम में इन आदेशों का चल रहा है.

424
00:34:31,880 --> 00:34:36,110
तो यह पीडीएफ लेटेक्स चलाता है, यह प्रतियां निर्देशिका मैं इसे नकल करना चाहते हैं,

425
00:34:36,110 --> 00:34:38,270
यह सीडी निर्देशिका और अन्य बातें करता है,

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
जब फ़ाइल में परिवर्तन. >> [छात्र] ठीक है.

429
00:34:50,510 --> 00:34:54,420
मैं नहीं जानता कि जहां वैश्विक बनाने फ़ाइलें हैं मेरे लिए यह जांच करने के लिए बाहर.

430
00:34:57,210 --> 00:35:04,290
अन्य प्रश्न? अतीत से कुछ भी quizzes? कोई सूचक बातें?

431
00:35:06,200 --> 00:35:08,730
जैसे संकेत के साथ सूक्ष्म बातें कर रहे हैं -

432
00:35:08,730 --> 00:35:10,220
मैं उस पर एक प्रश्नोत्तरी सवाल खोजने के लिए सक्षम होने के लिए नहीं जा रहा हूँ -

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 चर ढेर पर हैं.

437
00:35:32,140 --> 00:35:37,220
जब मैं कहता हूँ x = malloc (sizeof (int)), एक्स अभी भी ढेर पर एक चर है,

438
00:35:37,220 --> 00:35:41,180
malloc ढेर में अधिक कुछ ब्लॉक है, और हम ढेर करने के लिए एक्स बात कर रहे हैं.

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 ही ढेर पर है, जो भी कारण के लिए जब तक आप एक्स एक वैश्विक चर हो गए हैं,

445
00:36:08,540 --> 00:36:11,960
जो मामले में यह स्मृति का एक और क्षेत्र में होना होता है.

446
00:36:13,450 --> 00:36:20,820
तो ट्रैक रखने, इन बॉक्स और तीर चित्र प्रश्नोत्तरी के लिए बहुत आम हैं.

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
तुम लोग इसे अपने आप लागू कर सकता है. हाँ.

457
00:37:38,410 --> 00:37:43,410
[छात्र] लो क्या आप अपने में इस तरह से शामिल है और यह और फिर प्रतियां भी परिभाषित करता है.

458
00:37:43,410 --> 00:37:49,250
यह # शामिल की तरह बातों के लिए लग रहा है और परिभाषित #

459
00:37:49,250 --> 00:37:53,800
और यह सिर्फ प्रतियां और चिपकाता है जो वास्तव में क्या मतलब है.

460
00:37:53,800 --> 00:37:59,240
तो जब आप कहते # cs50.h शामिल पूर्वप्रक्रमक को कॉपी करने और चिपकाने cs50.h

461
00:37:59,240 --> 00:38:01,030
उस लाइन में.

462
00:38:01,030 --> 00:38:06,640
जब आप कहते हैं # x को परिभाषित करने के लिए 4 हो, पूर्वप्रक्रमक पूरे कार्यक्रम के माध्यम से चला जाता है

463
00:38:06,640 --> 00:38:10,400
और 4 के साथ एक्स के सभी उदाहरणों की जगह है.

464
00:38:10,400 --> 00:38:17,530
तो पूर्वप्रक्रमक एक वैध सी फ़ाइल लेता है और एक वैध सी फ़ाइल outputs

465
00:38:17,530 --> 00:38:20,300
बातें है, जहां नकल किया गया है और चिपकाया.

466
00:38:20,300 --> 00:38:24,230
तो अब संकलन. क्या करता है?

467
00:38:25,940 --> 00:38:28,210
[छात्र] यह सी से द्विआधारी के लिए चला जाता है.

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
यह विधान सभा के लिए हो जाता है इससे पहले कि यह सी कोड के लिए सभी का रास्ता जाता है,

472
00:38:38,890 --> 00:38:45,010
और सबसे अधिक भाषाओं कुछ इस तरह करते हैं.

473
00:38:47,740 --> 00:38:50,590
किसी भी उच्च स्तर की भाषा उठाओ, और यदि आप यह संकलन करने के लिए जा रहे हैं,

474
00:38:50,590 --> 00:38:52,390
यह चरणों में संकलन करने की संभावना है.

475
00:38:52,390 --> 00:38:58,140
पहले यह सी पायथन संकलन करने के लिए जा रहा है, तो यह विधान सभा के लिए सी संकलन करने के लिए जा रहा है,

476
00:38:58,140 --> 00:39:01,600
और फिर विधानसभा द्विआधारी करने के लिए अनुवाद करने के लिए जा रहा है.

477
00:39:01,600 --> 00:39:07,800
तो संकलन सी से विधानसभा के लिए लाने के लिए जा रहा है.

478
00:39:07,800 --> 00:39:12,130
संकलन शब्द आम तौर पर यह एक उच्च स्तर से लाने का मतलब

479
00:39:12,130 --> 00:39:14,340
एक निचले स्तर के प्रोग्रामिंग भाषा के लिए.

480
00:39:14,340 --> 00:39:19,190
तो इस संकलन में ही एक कदम है जहां आप एक उच्च स्तर की भाषा के साथ शुरू

481
00:39:19,190 --> 00:39:23,270
और एक कम स्तर भाषा में खत्म होता है, और यही कारण है कि कदम संकलन कहा जाता है.

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 विधानसभा में बहुत ज्यादा खत्म हो जाएगा ऊपर कभी नहीं.

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
[छात्र] विधानसभा द्विआधारी करने के लिए? >> हाँ.

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
यह सिर्फ एक तालिका में देख तरह है, ओह, हम यह निर्देश है;

501
00:41:03,180 --> 00:41:06,290
01110 द्विआधारी से मेल खाती है.

502
00:41:10,200 --> 00:41:15,230
और इसलिए फाइल है कि आम तौर पर कोडांतरण outputs ओ फ़ाइलें.

503
00:41:15,230 --> 00:41:19,020
और ओ. फाइल कर रहे हैं कि हम पहले कह रहे थे,

504
00:41:19,020 --> 00:41:21,570
एक फाइल करने के लिए एक मुख्य समारोह के लिए जरूरत नहीं है.

505
00:41:21,570 --> 00:41:27,640
कोई फ़ाइल ओ. फ़ाइल के लिए नीचे हो सकता है लंबे समय के रूप में यह एक वैध सी फ़ाइल के रूप में संकलित है.

506
00:41:27,640 --> 00:41:30,300
यह ओ. नीचे संकलित कर सकते हैं.

507
00:41:30,300 --> 00:41:43,030
अब, जोड़ने है क्या वास्तव में का एक गुच्छा लाता ओ फ़ाइलों और उन्हें एक निष्पादन योग्य के लिए लाता है.

508
00:41:43,030 --> 00:41:51,110
और इसलिए जोड़ने क्या करता है आप CS50 पुस्तकालय के ओ. फ़ाइल के रूप में सोच सकता है.

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 वास्तव में एक हे फ़ाइल नहीं है, लेकिन यह काफी करीब है कि वहाँ कोई बुनियादी फर्क है.

517
00:42:32,620 --> 00:42:36,880
तो बस जोड़ने के लिए फ़ाइलों का एक गुच्छा एक साथ लाता है

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 ग फ़ाइलों कर सकते हैं., आप उन सब संकलन ओ फ़ाइलों.

522
00:42:55,970 --> 00:43:00,040
जो शायद एक समय लग जाएगा, तो आप 1 ग फ़ाइल को बदलने के लिए.

523
00:43:00,040 --> 00:43:05,480
आप केवल कि 1. ग फ़ाइल और फिर relink और सब कुछ recompile की जरूरत है,

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
हाँ, तो 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
तुम बड़ा ओएस के सभी पता होना चाहिए कि हम पर चला गया है,

531
00:43:58,820 --> 00:44:02,670
और आप करने में सक्षम हो सकता है, अगर हम आप एक समारोह में दिया जाना चाहिए,

532
00:44:02,670 --> 00:44:09,410
आप कहते हैं कि यह बड़ा हे है, मोटे तौर पर करने में सक्षम होना चाहिए. या अच्छी तरह से, बड़ा हे मोटा है.

533
00:44:09,410 --> 00:44:15,300
तो अगर आप चीजों की एक ही नंबर पर पाशन loops के लिए नेस्टेड देख सकते हैं,

534
00:44:15,300 --> 00:44:22,260
>> चुकता [छात्र] n - int j, जम्मू <n, int i, मैं <n की तरह. >> यह n चुकता करने के लिए जाता है.

535
00:44:22,260 --> 00:44:25,280
यदि आप ट्रिपल नीडिंत है, यह होना n cubed जाता है.

536
00:44:25,280 --> 00:44:29,330
तो उस चीज़ की तरह आप तुरंत बाहर बात करने में सक्षम होना चाहिए.

537
00:44:29,330 --> 00:44:33,890
आप प्रविष्टि तरह और बुलबुला तरह जानते हैं और तरह और उन सभी मर्ज की जरूरत है.

538
00:44:33,890 --> 00:44:41,420
यह आसान है समझने के लिए क्यों वे उन n चुकता और n लॉग एन और वह सब कर रहे हैं

539
00:44:41,420 --> 00:44:47,810
क्योंकि मुझे लगता है कि वहाँ एक प्रश्नोत्तरी पर एक वर्ष जहाँ हम मूल रूप से तुम्हें दे दिया था

540
00:44:47,810 --> 00:44:55,050
बुलबुला तरह के एक कार्यान्वयन और कहा, "इस समारोह का समय चल रहा है क्या है?"

541
00:44:55,050 --> 00:45:01,020
तो अगर आप यह बुलबुला तरह के रूप में पहचान है, तो आप तुरंत पता चुकता कह सकते हैं.

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
बाहर figuring के एक समान विचार की तरह?

546
00:45:20,370 --> 00:45:24,450
>> मुझे नहीं लगता कि हम आप किसी भी कठिन उदाहरण देना होगा.

547
00:45:24,450 --> 00:45:30,180
बुलबुला तरह बात के बारे में के रूप में मुश्किल के रूप में हम चलते हैं,

548
00:45:30,180 --> 00:45:36,280
और भी है कि, के रूप में लंबे समय के रूप में आप समझते हैं कि आप सरणी पर iterating कर रहे हैं

549
00:45:36,280 --> 00:45:41,670
सरणी में प्रत्येक तत्व के लिए, जो कुछ है कि चुकता एन होने जा रहा है.

550
00:45:45,370 --> 00:45:49,940
यहाँ की तरह सामान्य सवाल है, हम कर रहे हैं - ओह.

551
00:45:55,290 --> 00:45:58,530
बस दूसरे दिन डौग दावा किया, "मैं एक एल्गोरिथ्म है कि एक सरणी सॉर्ट कर सकते हैं आविष्कार किया है

552
00:45:58,530 --> 00:46:01,780
"हे (लॉग एन) समय! में n संख्या"

553
00:46:01,780 --> 00:46:04,900
तो कैसे हम जानते हैं कि असंभव है?

554
00:46:04,900 --> 00:46:08,850
[अश्राव्य छात्र प्रतिक्रिया] >> हाँ.

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
यदि सब कुछ unsorted क्रम में है, तो आप सरणी में सब कुछ छू हो जा रहे हैं,

558
00:46:20,850 --> 00:46:25,320
तो यह असंभव है यह पता हे से कम समय में करना.

559
00:46:27,430 --> 00:46:30,340
[छात्र] आप हमें n हे में ऐसा करने में सक्षम होने की है कि उदाहरण दिखाया

560
00:46:30,340 --> 00:46:33,920
अगर आप स्मृति का एक बहुत का उपयोग करें. >> हाँ.

561
00:46:33,920 --> 00:46:37,970
और - मैं क्या भूल that's that's यह तरह गिनती है?

562
00:46:47,360 --> 00:46:51,330
हम्म. कि एक पूर्णांक छँटाई एल्गोरिथ्म है.

563
00:46:59,850 --> 00:47:05,100
मैं इस बात के लिए विशेष नाम के लिए देख रहा था कि मैं पिछले हफ्ते याद नहीं कर सकता.

564
00:47:05,100 --> 00:47:13,000
हाँ. इन प्रकार के प्रकार है कि n का बड़ा हे में चीजें हासिल कर सकते हैं.

565
00:47:13,000 --> 00:47:18,430
लेकिन वहाँ सीमाएं हैं, आप की तरह केवल पूर्णांकों एक निश्चित संख्या के लिए उपयोग कर सकते हैं ऊपर.

566
00:47:20,870 --> 00:47:24,560
इसके अलावा अगर आप कुछ 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
और इतनी है कि क्रम के दौरान और अधिक स्मृति का उपयोग नहीं होगा

573
00:48:07,360 --> 00:48:12,550
या कम से कम तुलनीय स्मृति का उपयोग के रूप में एक समाधान चलने का होगा?

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
यह एक आदर्श पुनरावर्ती समारोह नहीं है, लेकिन वापसी बार (एक्स - 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
कि अपने तर्क एक्स से मेल खाती है.

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
क्योंकि स्मृति टकराने शुरू होता है.

592
00:49:51,590 --> 00:49:54,830
>> तो अपने खुद के ढेर फ्रेम बनाने के बजाय, यह महसूस कर सकते हैं,

593
00:49:54,830 --> 00:49:59,080
अरे, मैं इस ढेर फ्रेम करने के लिए वापस आने के वास्तव में कभी नहीं की जरूरत है,

594
00:49:59,080 --> 00:50:08,040
इसलिए बजाय मैं सिर्फ 99 के साथ इस तर्क की जगह और फिर बार शुरू सब कुछ खत्म.

595
00:50:08,040 --> 00:50:11,810
और फिर इसे फिर से करना होगा और यह वापसी बार (एक्स - 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 मूल्य की जगह और शुरू करने के लिए वापस कूद,

599
00:50:30,430 --> 00:50:32,430
बहुत कुशल हैं.

600
00:50:32,430 --> 00:50:41,500
इतना ही नहीं, यह एक अलग समारोह के रूप में एक ही स्मृति उपयोग है जो चलने का है

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
और कटाव और यह सब सामान.

605
00:50:52,470 --> 00:50:58,160
तो यह पूंछ recursion अच्छा है.

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 +). >> हाँ.

622
00:52:07,530 --> 00:52:11,770
>> इसलिए यदि आप इसे हालत में डाल दिया है, तो आप वापसी मान के साथ कुछ कर रहे हैं.

623
00:52:11,770 --> 00:52:16,260
या यहाँ तक कि अगर आप सिर्फ 2 वापसी * ​​बार (एक्स - 1).

624
00:52:16,260 --> 00:52:23,560
तो अब पट्टी (एक्स - 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
[छात्र] मैं एक पूंछ recursion के लिए लक्ष्य एक recursion लाने की कोशिश करेगा -

629
00:52:37,590 --> 00:52:41,450
[] एक आदर्श दुनिया में Bowden, लेकिन CS50 में आप नहीं है.

630
00:52:43,780 --> 00:52:49,280
आदेश में पूंछ recursion प्राप्त करने के लिए, आम तौर पर, आप एक अतिरिक्त तर्क सेट

631
00:52:49,280 --> 00:52:53,550
जहां बार y में int x ले जाएगा

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
सूचक गणित.

642
00:53:43,610 --> 00:53:48,440
जब तार का उपयोग यह आसान है क्योंकि तार चार तारे हैं,

643
00:53:48,440 --> 00:53:51,860
घर का काम हमेशा के लिए और हमेशा एक बाइट,

644
00:53:51,860 --> 00:53:57,540
और तो सूचक गणित नियमित गणित जब आप तार के साथ काम कर रहे हैं के लिए बराबर है.

645
00:53:57,540 --> 00:54:08,790
चलो बस चार * s = "नमस्ते" कहते हैं.

646
00:54:08,790 --> 00:54:11,430
तो हम स्मृति में एक ब्लॉक है.

647
00:54:19,490 --> 00:54:22,380
यह 6 बाइट्स की जरूरत है क्योंकि आप हमेशा अशक्त टर्मिनेटर की जरूरत है.

648
00:54:22,380 --> 00:54:28,620
और चार * इस सरणी की शुरुआत करने के लिए बात करने के लिए जा रहा है.

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 या यह ढेर पर है कि क्या एक वापसी की परवाह किए बिना.

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
>> तो जब मैं [3] एस की तरह कुछ का कहना है, यह एस के लिए जा रहा है और अंदर 3 चार्स गिनती

655
00:55:05,360 --> 00:55:12,490
तो [3] हम 0, 1, 2, 3, इतना [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
यह * (+ 3) के बराबर है,

659
00:55:26,010 --> 00:55:31,240
और कहा कि हमेशा के लिए और हमेशा बराबर कोई फर्क नहीं पड़ता कि तुम क्या करना है.

660
00:55:31,240 --> 00:55:34,070
आप की जरूरत कभी नहीं ब्रैकेट सिंटैक्स का उपयोग.

661
00:55:34,070 --> 00:55:37,770
तुम हमेशा * वाक्यविन्यास (3 + ओं) का उपयोग कर सकते हैं.

662
00:55:37,770 --> 00:55:40,180
लोगों ब्रैकेट वाक्यविन्यास की तरह करते हैं, हालांकि.

663
00:55:40,180 --> 00:55:43,860
[छात्र] तो सभी arrays वास्तव में सिर्फ संकेत हैं.

664
00:55:43,860 --> 00:55:53,630
वहाँ एक मामूली अंतर है जब मैं कहता हूँ int x [4]; >> [छात्र] करता है कि स्मृति बना?

665
00:55:53,630 --> 00:56:03,320
[Bowden] यह ढेर पर 4 ints बनाने के लिए है, तो 16 बाइट्स समग्र जा रहा है.

666
00:56:03,320 --> 00:56:05,700
यह ढेर पर 16 बाइट्स बनाने जा रहा है.

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
ऐसा लगता है कि चार * के साथ नहीं कर सकते हैं क्योंकि यह एक वास्तविक सूचक है.

673
00:56:30,040 --> 00:56:32,380
यह तो अन्य बातों के लिए बात करने के लिए स्वतंत्र है.

674
00:56:32,380 --> 00:56:36,140
x एक स्थिर है. आप इसे एक अलग सरणी बिंदु नहीं हो सकता. >> [छात्र] ठीक है.

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
तो यह बस के रूप में रूप में मान्य है * (+ 3) या एस [3].

681
00:57:16,210 --> 00:57:22,090
[छात्र] आप 2 - आयामी arrays की ओर इशारा करते हुए संकेत मिल सकता है?

682
00:57:22,090 --> 00:57:27,380
>> यह कठिन है. परंपरागत रूप से, नहीं.

683
00:57:27,380 --> 00:57:34,720
एक 2 आयामी सरणी सिर्फ कुछ सुविधाजनक वाक्यविन्यास के साथ एक एक आयामी सरणी है

684
00:57:34,720 --> 00:57:54,110
क्योंकि जब मैं कहता हूँ int x [3] [3], यह वास्तव में सिर्फ 9 मूल्यों के साथ 1 सरणी है.

685
00:57:55,500 --> 00:58:03,000
और इसलिए जब मैं सूचकांक, संकलक जानता है कि मैं क्या मतलब है.

686
00:58:03,000 --> 00:58:13,090
अगर मैं कहूँ कि एक्स [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
सिर्फ एक्स के प्रकार है -

692
00:58:33,220 --> 00:58:38,280
यह एक्स के किसी न किसी प्रकार कह रही है क्योंकि यह सिर्फ एक प्रतीक है और यह एक वास्तविक चर नहीं है,

693
00:58:38,280 --> 00:58:40,140
लेकिन यह सिर्फ एक int * है.

694
00:58:40,140 --> 00:58:44,840
x सिर्फ इस के शुरू करने के लिए एक सूचक है. >> [छात्र] ठीक है.

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 तरह हास्यास्पद कुछ (* [पी - मैं बिल्कुल हास्यास्पद कुछ भी पता नहीं है.

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
और भी वाक्यविन्यास तो पुरातन है कि अगर आप इसे उपयोग करते हैं, लोगों को चकित किया जाएगा.

703
00:59:39,670 --> 00:59:43,540
बहुआयामी arrays बहुत दुर्लभ हैं के रूप में यह है.

704
00:59:43,540 --> 00:59:44,630
तुम बहुत सुंदर -

705
00:59:44,630 --> 00:59:48,490
वैसे, अगर आप मैट्रिक्स बातें कर रहे हैं के लिए दुर्लभ हो नहीं जा रहा है,

706
00:59:48,490 --> 00:59:56,730
लेकिन सी में आप शायद ही कभी बहुआयामी arrays का उपयोग करने जा रहे हैं.

707
00:59:57,630 --> 01:00:00,470
हाँ. >> [छात्र] चलो कहते हैं कि आप एक बहुत लंबे समय सरणी है.

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
लेकिन भौतिक स्मृति में, यह संभव है कि के लिए विभाजित करने के लिए होगा? हाँ. >>

711
01:00:08,770 --> 01:00:16,860
कैसे आभासी स्मृति काम करता है, यह सिर्फ अलग -

712
01:00:19,220 --> 01:00:24,860
आवंटन की इकाई एक पृष्ठ है, जो 4 किलोबाइट हो जाता है,

713
01:00:24,860 --> 01:00:29,680
और इसलिए जब एक प्रक्रिया कहते हैं, अरे, मैं इस स्मृति का उपयोग करना चाहते हैं,

714
01:00:29,680 --> 01:00:35,970
ऑपरेटिंग सिस्टम के लिए यह स्मृति के उस छोटे से ब्लॉक के लिए 4 किलोबाइट का आवंटन करने के लिए जा रहा है.

715
01:00:35,970 --> 01:00:39,100
यहां तक ​​कि अगर आप केवल स्मृति के पूरे ब्लॉक में एक छोटे से बाइट का उपयोग करते हैं,

716
01:00:39,100 --> 01:00:42,850
ऑपरेटिंग सिस्टम के लिए यह पूरा 4 किलोबाइट दे रहा है.

717
01:00:42,850 --> 01:00:49,410
तो क्या इसका मतलब यह है कि मैं हो सकता है - चलो कहना है कि यह मेरे चुकी है.

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
जो अगर हम यहाँ पर दिखेगा का कहना है कि यह हमारे रैम है,

722
01:01:09,010 --> 01:01:16,600
अगर मैं राम का 2 गीगाबाइट है, यह मेरे राम के 0 बाइट की तरह वास्तविक पते 0 है,

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
और इसका मतलब है कि अगर इस सीमा के लिए एक सरणी पैर फैलाकर बैठना होता है,

730
01:01:46,180 --> 01:01:50,070
एक सरणी के लिए इस बात का नहीं छोड़ा जा सकता होता है और एक पृष्ठ के इस आदेश की सही,

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
इन मैपिंग मिटा मिलता है और फिर इसे करने के लिए अन्य बातों के लिए इन छोटे ब्लॉकों का उपयोग करने के लिए स्वतंत्र है.

734
01:02:14,730 --> 01:02:17,410
और सवाल?

735
01:02:17,410 --> 01:02:19,960
[छात्र] सूचक गणित. >> ओह, हाँ.

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
क्या यह एक सरणी है या क्या यह 4 integers के malloced सरणी के लिए एक सूचक है,

739
01:02:41,810 --> 01:02:47,060
यह उसी तरह का इलाज किया जा रहा है.

740
01:02:50,590 --> 01:02:53,340
[छात्र] तो arrays ढेर पर कर रहे हैं?

741
01:03:01,400 --> 01:03:05,270
[Bowden] Arrays ढेर पर नहीं कर रहे हैं. >> [छात्र] ओह.

742
01:03:05,270 --> 01:03:08,320
>> [Bowden] सरणी के इस प्रकार के ढेर पर हो जाता है

743
01:03:08,320 --> 01:03:12,220
जब तक आप में घोषित वैश्विक चर की अनदेखी. वैश्विक चर का उपयोग नहीं.

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 * (int) sizeof), ढेर पर जा रहा है.

747
01:03:26,960 --> 01:03:31,870
लेकिन इस बिंदु के बाद मैं बहुत ज्यादा एक ही तरीके में और एक्स पी का उपयोग कर सकते हैं,

748
01:03:31,870 --> 01:03:36,140
मैं अपवाद के बारे में इससे पहले कि आप पी फिरसेआबंटितकरें कर सकते हैं के अलावा अन्य.

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 [3] = 2, या एक्स [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
[छात्र] क्या आप पी * अगर आप कोष्ठक नहीं?

755
01:04:07,390 --> 01:04:11,720
कोष्ठक एक अंतर्निहित भिन्नता हैं. ठीक है. >>

756
01:04:11,720 --> 01:04:20,200
असल में, यह भी आप के साथ कह रहे हैं क्या आप बहुआयामी arrays प्राप्त कर सकते हैं

757
01:04:20,200 --> 01:05:02,650
संकेत के साथ, आप क्या कर सकते हैं की तरह कुछ है, हम कहते हैं, int ** पीपी = 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
ठीक है.

761
01:05:42,550 --> 01:05:48,910
क्या मैं यहाँ किया है - यह होना चाहिए पीपी [i].

762
01:05:48,910 --> 01:05:53,680
तो पीपी एक संकेतक के लिए एक सूचक है.

763
01:05:53,680 --> 01:06:02,420
आप पीपी mallocing 5 int सितारों में से एक सरणी को इंगित कर रहे हैं.

764
01:06:02,420 --> 01:06:10,950
तो स्मृति में आप ढेर पीपी पर

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 बाइट्स की एक अलग ब्लॉक करने के लिए बात करनी चाहिए.

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
मैं पीपी [3] [4], लेकिन अब यह एक ही बात नहीं है, के रूप में बहुआयामी arrays कह सकते हैं

773
01:06:58,030 --> 01:07:05,390
क्योंकि बहुआयामी arrays [3] [4] में एक एकल x सरणी में ऑफसेट. अनुवाद

774
01:07:05,390 --> 01:07:14,790
इस dereferences पी, 3 सूचकांक accesses, तो dereferences कि

775
01:07:14,790 --> 01:07:20,790
और accesses - 4 अवैध होगा - 2 सूचकांक.

776
01:07:24,770 --> 01:07:31,430
जबकि जब हम int x [3] [4] के रूप में एक बहुआयामी सरणी पहले

777
01:07:31,430 --> 01:07:35,740
और जब आप ब्रैकेट डबल वास्तव में केवल एक ही भिन्नता है,

778
01:07:35,740 --> 01:07:40,490
आप एक ही सूचक का पालन कर रहे हैं और फिर एक ऑफसेट,

779
01:07:40,490 --> 01:07:42,850
यह वास्तव में 2 डी संदर्भ है.

780
01:07:42,850 --> 01:07:45,840
आप 2 अलग - अलग संकेत का पालन करें.

781
01:07:45,840 --> 01:07:50,420
तो यह भी तकनीकी रूप से अनुमति देता है कि आप बहुआयामी arrays

782
01:07:50,420 --> 01:07:53,550
जहां प्रत्येक व्यक्ति सरणी विभिन्न आकारों है.

783
01:07:53,550 --> 01:07:58,000
तो मुझे लगता है दांतेदार बहुआयामी arrays क्या यह कहा जाता है

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
वापस सूचक गणित - >> [छात्र] ओह. >> हाँ.

790
01:08:23,760 --> 01:08:35,649
[छात्र] अगर मैं int *** पी है और फिर मैं एक dereferencing करते हैं और मैं कहना है कि पी * इस मूल्य के बराबर है,

791
01:08:35,649 --> 01:08:39,560
यह केवल dereferencing के स्तर 1 करने के लिए जा रहा है? हाँ. >>

792
01:08:39,560 --> 01:08:43,340
तो अगर मैं बात यह है कि पिछले सूचक पर इशारा कर रहा है का उपयोग करना चाहते हैं -

793
01:08:43,340 --> 01:08:46,210
तो फिर आप *** पी. ठीक है. >>

794
01:08:46,210 --> 01:08:54,080
तो यह 1 ब्लॉक, एक और ब्लॉक करने के लिए कहते हैं, एक और ब्लॉक करने के लिए अंक पी अंक है.

795
01:08:54,080 --> 01:09:02,010
तो अगर आप * p = कुछ और है, तो आप इस बदल रहे हैं

796
01:09:02,010 --> 01:09:13,640
अब एक अलग खंड करने के लिए बात. ठीक है. >>

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
सूचक गणित.

801
01:09:29,550 --> 01:09:36,310
int x [4]; 4 integers के एक सरणी आवंटित जा रहा है

802
01:09:36,310 --> 01:09:40,670
जहाँ x सरणी की शुरुआत करने के लिए बात करने के लिए जा रहा है.

803
01:09:40,670 --> 01:09:50,420
तो जब मैं एक्स [1] की तरह कुछ का कहना है कि, मैं यह सरणी में 2 पूर्णांक के लिए जाने के लिए इसका मतलब के लिए चाहते हैं,

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
1 की भरपाई तो वास्तव में इसका मतलब है एक 1 की भरपाई

807
01:10:08,470 --> 01:10:12,030
बार जो भी सरणी के प्रकार के आकार.

808
01:10:12,030 --> 01:10:17,170
यह पूर्णांकों की सरणी है, तो यह int की 1 बार आकार जानता है कि जब यह करने के लिए ऑफसेट चाहता.

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
तो अगर एक्स = ox100, तो एक्स 1 + ox104 =.

813
01:10:59,510 --> 01:11:19,750
और आप इस दुरुपयोग और कुछ कह सकते हैं चार तरह ग * = (चार *) x;

814
01:11:19,750 --> 01:11:23,050
और अब सी एक्स के रूप में एक ही पते होने जा रहा है.

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 + यह ग में दिखता है, यह एक चार सूचक है, तो यह चार की 1 बार आकार जोड़ने के लिए जा रहा है,

819
01:11:45,390 --> 01:11:48,110
जो हमेशा के लिए एक हो जा रहा है, तो आप 101 मिलता है,

820
01:11:48,110 --> 01:11:54,890
जबकि अगर मैं एक्स, जो भी अभी भी 100 x + 1 104 होने जा रहा है.

821
01:11:56,660 --> 01:12:06,340
[छात्र] आप सी + + क्रम में 1 से अपने सूचक अग्रिम का उपयोग कर सकते हैं?

822
01:12:06,340 --> 01:12:09,810
हाँ, आप यह कर सकते हैं.

823
01:12:09,810 --> 01:12:16,180
आपको लगता है कि एक्स के साथ नहीं है क्योंकि एक्स सिर्फ एक प्रतीक है, यह एक निरंतर है, आप एक्स नहीं बदल सकते हैं.

824
01:12:16,180 --> 01:12:22,610
>> लेकिन ग के लिए सिर्फ एक सूचक होता है, तो सी + + पूरी तरह से वैध है और यह 1 से वेतन वृद्धि होगी.

825
01:12:22,610 --> 01:12:32,440
यदि आप ग सिर्फ एक int * थे, तो सी + + 104 किया जाएगा.

826
01:12:32,440 --> 01:12:41,250
+ + सूचक अंकगणित करता है बस के रूप में ग 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
जैसे कि अगर मैं सरणी के इस आधे पारित करना चाहता था - चलो इस में से कुछ मिटा.

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
अगर मैं एक्स के पास, मैं इस पते गुजर रहा हूँ.

833
01:13:17,050 --> 01:13:23,780
लेकिन मैं इस विशेष पते पास करना चाहते हैं. तो मैं क्या पारित करना चाहिए?

834
01:13:23,780 --> 01:13:26,590
[छात्र] सूचक 2 +?

835
01:13:26,590 --> 01:13:29,350
[Bowden] तो 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
तो तुम यह के पते ले क्योंकि ब्रैकेट एक अंतर्निहित भिन्नता है की जरूरत है.

839
01:13:47,850 --> 01:13:53,250
x [2] मूल्य है कि इस बॉक्स में है करने के लिए संदर्भित करता है, और तो आप कि बॉक्स का पता करना चाहते हैं,

840
01:13:53,250 --> 01:13:56,850
तो आप कह और एक्स [2].

841
01:13:56,850 --> 01:14:02,880
तो यह है कि मर्ज प्रकार में कुछ जहाँ आप कुछ करने के लिए 1/2 सूची पारित करना चाहते हैं

842
01:14:02,880 --> 01:14:08,790
तुम सच में सिर्फ पारित करने के लिए और एक्स [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 नहीं डाल या एक - कि क्या कहा जाता है? >> स्टार?

846
01:14:20,050 --> 01:14:23,200
[छात्र] स्टार. >> तकनीकी तौर पर, भिन्नता ऑपरेटर, लेकिन - >> [छात्र] भिन्नता.

847
01:14:23,200 --> 01:14:29,310
>> यदि हम एक सितारा या एक एम्परसेंड डाल नहीं है, क्या होता है अगर मैं सिर्फ y का कहना है = एक्स और एक्स एक सूचक है?

848
01:14:29,310 --> 01:14:34,620
Y के प्रकार क्या है? >> [छात्र] मैं सिर्फ यह 2 सूचक कहूँगा.

849
01:14:34,620 --> 01:14:38,270
तो अगर तुम सिर्फ का कहना है कि y = x, अब एक्स और वाई बिंदु एक ही बात करने के लिए. >> एक ही बात करने के लिए [छात्र] प्वाइंट.

850
01:14:38,270 --> 01:14:45,180
और यदि x एक int सूचक है? >> यह है क्योंकि आप संकेत नहीं असाइन कर सकते हैं शिकायत करेंगे.

851
01:14:45,180 --> 01:14:46,540
[छात्र] ठीक है.

852
01:14:46,540 --> 01:14:51,860
याद रखें कि संकेत है, भले ही हम उन्हें तीर के रूप में आकर्षित,

853
01:14:51,860 --> 01:15:02,010
वास्तव में वे दुकान - int * x वास्तव में सभी एक्स भंडारण है ox100 की तरह कुछ है,

854
01:15:02,010 --> 01:15:06,490
जो हम 100 ब्लॉक में संग्रहीत की ओर इशारा करते के रूप में प्रतिनिधित्व करने के लिए होता है.

855
01:15:06,490 --> 01:15:19,660
तो जब मैं कहता हूँ int * y = x; मैं सिर्फ y में हूँ ox100 नकल,

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
क्या यह एक्स या y के कास्टिंग int int कास्टिंग किया जा रहा है?

862
01:16:00,290 --> 01:16:03,700
[Bowden] क्या?

863
01:16:03,700 --> 01:16:07,690
[छात्र] ठीक है. इन कोष्ठकों के बाद वहाँ एक एक्स या वहाँ प्र होने जा रहा है?

864
01:16:07,690 --> 01:16:11,500
>> [Bowden] या तो. एक्स और वाई के बराबर हैं. >> [छात्र] ठीक है.

865
01:16:11,500 --> 01:16:14,390
क्योंकि वे दोनों संकेत कर रहे हैं. >> हाँ.

866
01:16:14,390 --> 01:16:21,050
[छात्र] तो यह पूर्णांक के रूप में हेक्साडेसिमल 100 स्टोर होगा? >> [Bowden] हाँ.

867
01:16:21,050 --> 01:16:23,620
लेकिन जो कुछ भी यह करने के लिए अंक का मूल्य नहीं है.

868
01:16:23,620 --> 01:16:29,940
[Bowden] हाँ. >> [छात्र] तो बस पूर्णांक के रूप में पता है. ठीक है.

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
तो मैं एक int * से ox100 एक int कॉपी करने के लिए स्वतंत्र हूँ,

876
01:17:02,920 --> 01:17:07,790
शायद नहीं ढलाई के लिए पर चिल्लाया जा you're - और मैं असाइन करने के लिए नि: शुल्क कर रहा हूँ -

877
01:17:07,790 --> 01:17:18,160
मैं (int *) इस मनमाना int * में ox1234 तरह कुछ असाइन करने के लिए करने के लिए स्वतंत्र हूँ.

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
[छात्र] कि एक बहुत अच्छा षोडश आधारी दशमलव रूप से करने के लिए जाने के लिए रास्ता होगा,

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 - जैसा कि आप पहले से ही पता होना चाहिए - मुद्रित रूप में एक पूर्णांक% एक्स.

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 बाइट ब्लॉकों में चीजों के बारे में सोचना,

891
01:18:23,260 --> 01:18:25,390
और स्मृति पते के लिए परिचित हो जाते हैं.

892
01:18:25,390 --> 01:18:28,890
हम कर रहे हैं की तरह, अगर यह bf के साथ शुरू होता है, तो यह ढेर पर होना होता है.

893
01:18:28,890 --> 01:18:35,560
तो यह सिर्फ हेक्सादशमलव के रूप में संकेत की हमारी व्याख्या है.

894
01:18:35,560 --> 01:18:39,200
ठीक है. कोई अंतिम सवाल?

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
>> [छात्र] हाँ! [वाहवाही]

898
01:18:51,440 --> 01:18:53,000
>> [CS50.TV]