1
00:00:00,000 --> 00:00:02,500
[Powered by Google Translate] [5 વિભાગ - વધુ અનુકૂળ]

2
00:00:02,500 --> 00:00:04,690
[રોબ બોડેન - હાર્વર્ડ યુનિવર્સિટી]

3
00:00:04,690 --> 00:00:07,250
[આ CS50 છે. - CS50.TV]

4
00:00:08,990 --> 00:00:14,250
>> જેમ હું મારા ઇમેઇલમાં જણાવ્યું હતું કે, ત્યાં વસ્તુઓ તમે ઉપયોગ કરી શકો છો ઘણો છે

5
00:00:14,250 --> 00:00:17,060
જે વાસ્તવમાં સમસ્યા સેટ કરવા સાધન કરતાં અન્ય.

6
00:00:17,060 --> 00:00:19,910
અમે ભલામણ કરીએ છીએ તમે તે સાધન શું માત્ર કારણ કે તે પછી અમે વધુ સરળતાથી તમે મદદ કરી શકો છો

7
00:00:19,910 --> 00:00:22,070
અને અમે જાણીએ છીએ કે કેવી રીતે બધું કામ થઈ રહ્યું છે.

8
00:00:22,070 --> 00:00:26,950
પરંતુ જ્યાં તમે વસ્તુઓ, જો કહી શકીએ એક ઉદાહરણ તરીકે, તમે ઍક્સેસ નથી

9
00:00:26,950 --> 00:00:31,570
ઓજાર અથવા તમે સાયન્સ સેન્ટર ભોંયરામાં કામ કરવા માંગો છો -

10
00:00:31,570 --> 00:00:33,090
જે વાસ્તવમાં તેઓ સાધન પણ છે -

11
00:00:33,090 --> 00:00:35,150
જો તમે ગમે ત્યાં કામ કરવા માંગો છો.

12
00:00:35,150 --> 00:00:42,370
એક ઉદાહરણ તમારી પાસે જોવા મળે છે / SSH સાંભળ્યું?

13
00:00:44,380 --> 00:00:47,780
SSH કંઈક સાથે જોડાવા માટે જેમ જ મૂળભૂત છે.

14
00:00:47,780 --> 00:00:51,340
ખરેખર, હમણાં હું ઉપકરણ માં SSHed છું.

15
00:00:51,340 --> 00:00:54,290
આ ઉપકરણ માં હું સીધી ક્યારેય કામ કરે છે.

16
00:00:55,930 --> 00:01:01,060
અહીં સાધન છે, અને જો તમે અહીં જુઓ તમે આ IP સરનામું જુઓ.

17
00:01:01,060 --> 00:01:03,650
આ સાધન એ પોતે હું ક્યારેય કામ;

18
00:01:03,650 --> 00:01:08,840
હું હંમેશા iTerm2 વિન્ડો / વિન્ડો ટર્મિનલ પર આવે છે.

19
00:01:08,840 --> 00:01:15,910
કે જે તમને IP સરનામું, jharvard@192.168.129.128 ssh માટે SSH કરી શકો છો.

20
00:01:15,910 --> 00:01:20,390
હું કે જે નંબર ખૂબ સરળતાથી યાદ નથી કારણ કે તે આવા સરસ પેટર્ન છે.

21
00:01:20,390 --> 00:01:24,920
પરંતુ મને મારા પાસવર્ડ માટે પૂછો, અને હવે હું સાધન છું.

22
00:01:24,920 --> 00:01:33,060
મૂળભૂત રીતે, આ બિંદુએ, જો તમે ઉપકરણ પોતાની અંદર ટર્મિનલ ખોલવામાં,

23
00:01:33,060 --> 00:01:36,350
આ ઈન્ટરફેસ જોકે તમે તેનો ઉપયોગ કરશે, બરાબર એ જ

24
00:01:36,350 --> 00:01:40,010
ઈન્ટરફેસ તરીકે હું ઉપર ઉપયોગ કરું છું, અહીં પરંતુ હવે તમે SSHed કરી રહ્યાં છો.

25
00:01:42,240 --> 00:01:44,920
તમે ઉપકરણ માટે SSH માટે નથી.

26
00:01:44,920 --> 00:01:52,360
બીજા સ્થાને તમે કરી શકે SSH એક ઉદાહરણ છે હું ખૂબ ખાતરી કરો કે તમે મૂળભૂત રીતે હોય છે છું -

27
00:01:52,360 --> 00:01:55,020
ઓહ. ઘણી મોટી છે.

28
00:01:55,020 --> 00:02:01,130
તમે બધા મૂળભૂત FAS સર્વર્સ પર FAS એકાઉન્ટ્સ દ્વારા હોવી જોઈએ.

29
00:02:01,130 --> 00:02:06,840
મારા માટે, હું SSH છો rbowden@nice.fas.harvard.edu છે.

30
00:02:06,840 --> 00:02:11,610
તે છે કે જે તમને પ્રથમ વખત પૂછી રહ્યું છે, અને તમે હા કહી.

31
00:02:11,610 --> 00:02:15,840
મારા પાસવર્ડ માત્ર મારા FAS પાસવર્ડ પ્રયત્ન રહ્યું છે.

32
00:02:15,840 --> 00:02:22,650
અને તેથી હવે, હું સરસ સર્વરો માટે SSHed છું, અને મેં કંઈપણ હું અહીં પર માંગો છો કરી શકો છો.

33
00:02:22,650 --> 00:02:28,560
વર્ગો તમે, 124 જેવી લાગી શકે છે ઘણાં, હોય તમે અહીં સામગ્રી અપલોડ જવું છે

34
00:02:28,560 --> 00:02:30,950
ખરેખર તમારી સમસ્યા સેટ સબમિટ કરો.

35
00:02:30,950 --> 00:02:34,100
પરંતુ કહે છે કે તમે તમારા ઉપકરણ માટે ઍક્સેસ નથી.

36
00:02:34,100 --> 00:02:37,910
પછી તમે વસ્તુઓ નથી, તો તે અંહિ પર જેમ કહેવું હશે -

37
00:02:37,910 --> 00:02:42,160
આ માત્ર પ્રશ્નો અમારા વિભાગ છે.

38
00:02:42,160 --> 00:02:45,070
તે તમને ઉપકરણ માં આવું કરશે.

39
00:02:45,070 --> 00:02:47,790
તેના બદલે હું હમણાં જ તે સર્વર પર કરી શકશો.

40
00:02:47,790 --> 00:02:50,560
હું અનઝિપ કરી જાઉં છું.

41
00:02:50,560 --> 00:02:55,670
આ સમસ્યા માટે પ્રયત્ન કરે છે કે તમે gedit કંઈક મદદથી ઉપયોગ કરી રહ્યા છો રહ્યું છે

42
00:02:55,670 --> 00:02:58,160
અથવા સાધન ની અંદર ગમે.

43
00:02:58,160 --> 00:03:01,830
તમે FAS સર્વર પર નથી જઈ રહ્યાં છો.

44
00:03:01,830 --> 00:03:04,110
તે બધા માત્ર છે આ શાબ્દિક ઈન્ટરફેસ હશે.

45
00:03:04,110 --> 00:03:09,180
તેથી તમે એક ક્યાં, એક લખાણ સંપાદક છે કે તેઓ પાસે જાણવા પ્રયાસ કરી શકે છે.

46
00:03:09,180 --> 00:03:12,130
તેઓ નેનો છે.

47
00:03:12,130 --> 00:03:14,990
નેનો સામાન્ય રીતે ખૂબ વાપરવા માટે સરળ.

48
00:03:14,990 --> 00:03:19,470
તમે તમારા તીરો વાપરો અને સામાન્ય રીતે લખી શકો છો.

49
00:03:19,470 --> 00:03:21,250
તેથી તે હાર્ડ નથી.

50
00:03:21,250 --> 00:03:24,720
જો તમે ખરેખર ફેન્સી મેળવવા માંગો છો તો તમે Emacs ઉપયોગ કરી શકો છો,

51
00:03:24,720 --> 00:03:29,850
જે હું કદાચ કારણ કે હું પણ કેવી રીતે Emacs બંધ ખબર નથી ન ખોલી કરીશું.

52
00:03:29,850 --> 00:03:32,760
નિયંત્રણ એક્સ, નિયંત્રણ સી? યાહ.

53
00:03:32,760 --> 00:03:35,310
અથવા તમે આવેશ, કે જે હું શું ઉપયોગ કરવા માટે કરી શકો છો.

54
00:03:35,310 --> 00:03:37,800
અને તેથી તે તમારા વિકલ્પો છે.

55
00:03:37,800 --> 00:03:43,830
જો તમે તે નથી માંગતા, તો તમે પણ કરી શકાય છે જો તમે જોવા manual.cs50.net -

56
00:03:43,830 --> 00:03:45,410
ઓહ.

57
00:03:45,410 --> 00:03:49,920
એક પીસી પર, તમે SSH PuTTY મદદથી કરી શકો છો,

58
00:03:49,920 --> 00:03:51,940
જે તમે અલગ અલગ ડાઉનલોડ કરી રહ્યા છીએ.

59
00:03:51,940 --> 00:03:55,460
મેક પર, તમે મૂળભૂત ઉપયોગ ટર્મિનલ દ્વારા માત્ર અથવા તમે iTerm2 કરી શકો છો ડાઉનલોડ કરી શકો છો,

60
00:03:55,460 --> 00:03:58,490
જે સરસ, ફેન્સી ટર્મિનલ જેવી છે.

61
00:03:58,490 --> 00:04:03,780
જો તમે manual.cs50.net જાઓ તમે નોટપેડ પર એક લિંક જોશો + +,

62
00:04:03,780 --> 00:04:07,120
જે તમે શું PC પર ઉપયોગ કરી શકો છો.

63
00:04:07,120 --> 00:04:13,340
તે તમને નોટપેડ થી SFTP દે + +, કે જે મૂળભૂત રીતે SSH છે.

64
00:04:13,340 --> 00:04:17,750
આ તમને માહિતી આપશે શું છે તમારી ફાઇલોને સ્થાનિક રીતે ફેરફાર કરવા માટે,

65
00:04:17,750 --> 00:04:20,670
અને પછી જ્યારે પણ તમે તેમને સાચવવા માંગો છો, તે nice.fas સાચવવા માટે કરશે,

66
00:04:20,670 --> 00:04:23,670
જ્યાં તમે પછી તેમને ચલાવી શકો છો.

67
00:04:23,670 --> 00:04:26,880
અને મેક પર સમકક્ષ TextWrangler પ્રયત્ન રહ્યું છે.

68
00:04:26,880 --> 00:04:28,760
તેથી તે તમને આ જ બાબત નથી.

69
00:04:28,760 --> 00:04:32,800
તે તમને ફાઈલો સ્થાનિક રીતે ફેરફાર કરવા અને તેમને nice.fas સાચવવા માટે,

70
00:04:32,800 --> 00:04:35,730
જ્યાં તમે પછી તેમને ચલાવી શકો છો.

71
00:04:35,730 --> 00:04:40,400
તેથી જો તમે ક્યારેય ઓજાર વગર અટકી કરી રહ્યાં છો, તમે આ વિકલ્પો છે

72
00:04:40,400 --> 00:04:44,230
તમારી સમસ્યા સેટ હજી પણ.

73
00:04:44,230 --> 00:04:48,250
આ એક સમસ્યા કે તમે CS50 પુસ્તકાલય નથી જઈ રહ્યાં છો રહ્યું છે

74
00:04:48,250 --> 00:04:51,580
કારણ કે nice.fas મૂળભૂત દ્વારા કે નથી.

75
00:04:51,580 --> 00:04:55,970
તમે ક્યાં તો CS50 પુસ્તકાલય ડાઉનલોડ કરી શકો છો -

76
00:04:55,970 --> 00:04:58,470
મને નથી લાગતું કે હું આ બિંદુએ કે જરૂર છે.

77
00:04:58,470 --> 00:05:03,270
તમે ક્યાં તો CS50 પુસ્તકાલય ડાઉનલોડ કરી શકો છો અને તે nice.fas પર નકલ કરો,

78
00:05:03,270 --> 00:05:07,450
અથવા મને લાગે છે કે આ સમયે અમે તેને હવે ઉપયોગ નથી કરતા તો પણ.

79
00:05:07,450 --> 00:05:12,720
અથવા જો અમે હોય, તો તમે સમય સાથે તે કરી શકો છો બદલો કરવામાં આવી રહી છે

80
00:05:12,720 --> 00:05:18,480
આ CS50 પુસ્તકાલય માં વિધેયોને રીતે અમલીકરણ.

81
00:05:18,480 --> 00:05:21,370
જેથી પ્રતિબંધ છે કે બહુ પ્રયત્ન કરીશું.

82
00:05:21,370 --> 00:05:23,710
અને તે કે.

83
00:05:26,460 --> 00:05:29,820
>> હું પાછા સાધન હવે જઈશ; અમે સાધન બધું કરવું પડશે.

84
00:05:29,820 --> 00:05:37,510
પ્રશ્નો અમારા વિભાગમાં છીએ, તો શરૂઆતમાં, જેમ કે હું મારા ઇમેઇલમાં જણાવ્યું હતું કે,

85
00:05:37,510 --> 00:05:43,620
અમે ટૂંકા એક તમે જોવાનું માનવામાં આવ્યા હતા વિશે વાત છે.

86
00:05:43,620 --> 00:05:51,980
અમે પુનઃદિશામાન કરી અને પાઇપ્સ અને આ ત્રણ પ્રશ્નો હોય છે.

87
00:05:51,980 --> 00:05:56,070
>> માટે જે સ્ટ્રીમ જેવા કાર્યો printf નથી મૂળભૂત રીતે લખી?

88
00:05:56,070 --> 00:05:59,130
સ્ટ્રીમ તેથી. સ્ટ્રીમ શું છે?

89
00:06:06,520 --> 00:06:15,100
એક સ્ટ્રીમ મૂળભૂત જેમ તે માત્ર કેટલાક -

90
00:06:15,100 --> 00:06:21,450
તે પણ નથી અને 1 સે 0s એક સ્ત્રોત છે.

91
00:06:21,450 --> 00:06:24,920
સ્ટ્રીમ તેને અહીં પૂછી છે પ્રમાણભૂત બહાર છે.

92
00:06:24,920 --> 00:06:27,250
અને તેથી પ્રમાણભૂત એક પ્રવાહ કે છે જ્યારે તમે તેને લખી,

93
00:06:27,250 --> 00:06:30,940
તે સ્ક્રીન પર દેખાય છે.

94
00:06:30,940 --> 00:06:36,860
સ્ટાન્ડર્ડ આઉટ, સ્ટ્રીમ દ્વારા, તો એનો અર્થ તમે માત્ર 1 સે અને તે 0s લખો,

95
00:06:36,860 --> 00:06:40,220
અને પ્રમાણભૂત બહાર બીજા છેડે માત્ર તે સ્ટ્રીમ માંથી વાંચે છે.

96
00:06:40,220 --> 00:06:43,540
તે માત્ર 1 સે અને 0s એક શબ્દમાળા છે.

97
00:06:43,540 --> 00:06:45,570
તમે સ્ટ્રીમ્સ લખવા માટે અથવા તમે સ્ટ્રીમ્સ માંથી વાંચી શકે છે

98
00:06:45,570 --> 00:06:47,950
સ્ટ્રીમ ખરેખર શું છે તેના પર આધાર રાખીને.

99
00:06:47,950 --> 00:06:52,800
અન્ય બે મૂળભૂત સ્ટ્રીમ્સ અને પ્રમાણભૂત ભૂલ પ્રમાણભૂત છે.

100
00:06:52,800 --> 00:06:57,540
માં ધોરણ જ્યારે તમે GetString હો, તો તે તમારા માટે ઇનપુટ સામગ્રી માટે રાહ જોઈ રહ્યું છે.

101
00:06:57,540 --> 00:07:01,570
તેથી તે તમારા માટે રાહ જોઈ રહ્યું છે, તે ખરેખર પ્રમાણભૂત પર રાહ જોઈ છે,

102
00:07:01,570 --> 00:07:04,880
જે ખરેખર છે તમે શું વિચાર છે જ્યારે તમે કીબોર્ડ લખો.

103
00:07:04,880 --> 00:07:07,530
આપ લોગઇન ધોરણ માં ટાઇપ કરી રહ્યા

104
00:07:07,530 --> 00:07:10,050
સ્ટાન્ડર્ડ ભૂલ મૂળભૂત પ્રમાણભૂત બહાર જેવું જ છે,

105
00:07:10,050 --> 00:07:13,280
પરંતુ તે છે કે જે વિશિષ્ટ છે જ્યારે તમે પ્રમાણભૂત ભૂલ માટે છાપો,

106
00:07:13,280 --> 00:07:16,770
તમે માત્ર તે ભૂલ સંદેશાઓ છાપી માનવામાં કરી રહ્યાં છો

107
00:07:16,770 --> 00:07:20,200
જેથી તમે નિયમિત સ્ક્રીન પર છપાતા સંદેશાઓ વચ્ચે તફાવત કરી શકો છો

108
00:07:20,200 --> 00:07:24,560
ભૂલ કે શું તેઓ પ્રમાણભૂત બહાર અથવા પ્રમાણભૂત ભૂલ ગયા પર આધાર રાખીને સંદેશાઓ વિરુદ્ધ.

109
00:07:24,560 --> 00:07:28,660
પણ ફાઇલ્સ.

110
00:07:28,660 --> 00:07:32,440
સ્ટાન્ડર્ડ બહાર માં ધોરણ, અને પ્રમાણભૂત ભૂલ માત્ર ખાસ સ્ટ્રીમ્સ હોય છે,

111
00:07:32,440 --> 00:07:36,810
પરંતુ ખરેખર કોઈપણ ફાઈલ, જ્યારે તમે એક ફાઈલ ખોલવા માટે, તેને બાઇટ્સ એક પ્રવાહ બને છે

112
00:07:36,810 --> 00:07:40,740
તમે હમણાં જ્યાં તે સ્ટ્રીમ માંથી વાંચી શકે છે.

113
00:07:40,740 --> 00:07:47,770
તમે, સૌથી ભાગ માટે, ફક્ત બાઇટ્સ એક પ્રવાહ તરીકે ફાઇલ વિચાર કરી શકો છો.

114
00:07:47,770 --> 00:07:51,190
તેથી શું સ્ટ્રીમ્સ તેઓ મૂળભૂત રીતે નથી લખી? સ્ટાન્ડર્ડ આઉટ.

115
00:07:51,190 --> 00:07:56,980
>> > અને >> વચ્ચે શું તફાવત છે?

116
00:07:58,140 --> 00:08:03,710
શું કોઈને પણ વિડિઓ પહેલાંથી જોઈ? ઠીક છે.

117
00:08:03,710 --> 00:08:10,960
> હોય કે તમે કેવી રીતે ફાઇલોમાં પુનઃદિશામાન થઈ રહ્યું છે,

118
00:08:10,960 --> 00:08:15,240
અને >> પણ ફાઇલોમાં આઉટપુટ પુનઃદિશામાન થઈ રહ્યું છે,

119
00:08:15,240 --> 00:08:17,820
પરંતુ તેના બદલે ફાઈલ સાથે ઉમેરી રહ્યું છે.

120
00:08:17,820 --> 00:08:23,430
ઉદાહરણ તરીકે, આપણે કહેવું કે હું dict અહીં હોય થાય છે,

121
00:08:23,430 --> 00:08:27,020
અને dict ની અંદર એક માત્ર સામગ્રી બિલાડી, બિલાડી, કૂતરો, માછલી કૂતરો છે.

122
00:08:27,020 --> 00:08:31,530
એક આદેશ કે તમે આદેશ વાક્ય પર હોય બિલાડી છે,

123
00:08:31,530 --> 00:08:34,539
જે માત્ર છાપો શું ફાઈલમાં છે રહ્યું છે.

124
00:08:34,539 --> 00:08:40,679
તેથી જ્યારે હું બિલાડી dict કહે, તે બિલાડી, બિલાડી, કૂતરો, માછલી કૂતરો, પ્રિન્ટ બનશે. કે તમામ બિલાડી કરે છે.

125
00:08:40,679 --> 00:08:46,280
તેનો અર્થ એ છે કે તે બિલાડી, બિલાડી, કૂતરો, માછલી કૂતરો, બહાર પ્રમાણભૂત પર છપાતા.

126
00:08:46,280 --> 00:08:53,240
જો હું તેના બદલે એક ફાઈલ કે પુનઃદિશામાન કરવા માંગો છો, હું> વાપરો અને તેને ગમે તે ફાઈલ છે પુનઃદિશામાન કરી શકો છો.

127
00:08:53,240 --> 00:08:56,460
હું ફાઈલ ફાઈલ કહી શકશો.

128
00:08:56,460 --> 00:09:00,320
તેથી હવે હું ls જો, હું જોશો હું એક નવી ફાઇલ તરીકે ઓળખાતી ફાઈલ હોય છે.

129
00:09:00,320 --> 00:09:05,700
અને જો હું તેને ખોલવા ઉપર, તે છે બરાબર શું બિલાડી આદેશ વાક્ય પર મૂકી રહ્યું છે.

130
00:09:05,700 --> 00:09:11,040
તેથી હવે જો હું કે ફરીથી કરવા માટે, પછી તે ફાઈલમાં આઉટપુટ પુનઃદિશામાન ચાલી રહ્યું છે,

131
00:09:11,040 --> 00:09:13,930
અને હું જ ચોક્કસ વસ્તુ હોય જાઉં છું.

132
00:09:13,930 --> 00:09:17,910
તેથી ટેકનિકલી, તે સંપૂર્ણપણે overrode આપણે શું હતા.

133
00:09:17,910 --> 00:09:22,970
અને અમે જો હું dict બદલી જોશો, હું બહાર કૂતરો લીધો હતો.

134
00:09:22,970 --> 00:09:29,980
હવે જો ફાઇલમાં અમે બિલાડી ફરીથી dict, અમે કૂતરો દૂર સાથે નવા આવૃત્તિ હોય રહ્યા છીએ.

135
00:09:29,980 --> 00:09:32,400
તેથી તે સંપૂર્ણપણે તેને ફરીથી લખે છે.

136
00:09:32,400 --> 00:09:36,640
તેની જગ્યાએ, જો આપણે >> વાપરવા માટે, તે ફાઈલ ઉમેરી રહ્યું છે.

137
00:09:36,640 --> 00:09:40,860
હવે, ફાઈલ ખોલવા માટે, અમે જુઓ અમે માત્ર એ જ બે વાર મુદ્રણ વસ્તુ છે

138
00:09:40,860 --> 00:09:44,920
કારણ કે તે ત્યાં એક વખત આવી હતી, તે પછી અમે મૂળ ઉમેરાવું જોઈએ.

139
00:09:44,920 --> 00:09:48,130
તેથી કે શું> >> અને નથી.

140
00:09:48,130 --> 00:09:50,580
શું આગામી એક પૂછો તે - તે વિશે પૂછશે નહિં.

141
00:09:50,580 --> 00:09:59,050
>> અન્ય એક કે અમે હોય <છે, કે જે જો> ધોરણ બહાર અન્યત્ર છે,

142
00:09:59,050 --> 00:10:01,970
<પ્રમાણભૂત પુનઃદિશામાન કરી સાઇન રહ્યું છે

143
00:10:01,970 --> 00:10:12,050
ચાલો જોવા જો આપણે એક ઉદાહરણ છે.

144
00:10:14,750 --> 00:10:16,930
હું એક વાસ્તવિક ઝડપી લખી શકો છો.

145
00:10:17,870 --> 00:10:25,700
ચાલો કોઈપણ ફાઈલ, hello.c લો.

146
00:10:56,060 --> 00:10:59,070
પ્રમાણમાં સરળ ફાઇલ.

147
00:10:59,070 --> 00:11:03,570
હું માત્ર એક શબ્દમાળા મેળવવામાં છું અને પછી "હેલો" ગમે તે શબ્દમાળા હું હમણાં જ દાખલ કરેલ હતી છાપવા.

148
00:11:03,570 --> 00:11:07,990
તેથી હેલ્લો અને પછી બનાવવા / હેલો..

149
00:11:07,990 --> 00:11:10,720
હવે તે મને પૂછવાની છે કંઈક દાખલ કરો,

150
00:11:10,720 --> 00:11:15,070
જેનો અર્થ છે કે તે વસ્તુઓ પર રાહ જોઈ છે સાઇન ધોરણ દાખલ કરવામાં

151
00:11:15,070 --> 00:11:20,450
તેથી દાખલ ગમે હું ધોરણ કરવા માંગો છો સાઇન અમે માત્ર હેલો, રોબ કહે જઈ રહ્યાં છો!

152
00:11:20,450 --> 00:11:23,310
પછી તેને હેલો બહાર પ્રમાણભૂત પર છાપવા છે, રોબ!

153
00:11:23,310 --> 00:11:28,860
જો હું /. હેલ્લો અને પછી પુનઃદિશામાન કરવા માટે,

154
00:11:30,740 --> 00:11:34,310
હવે તમે માત્ર એક ફાઇલ માંથી પુનઃદિશામાન કરી શકો છો.

155
00:11:34,310 --> 00:11:41,720
તેથી જો હું અમુક ફાઈલ, txt મૂકવા, અને હું રોબ મૂકી,

156
00:11:41,720 --> 00:11:52,300
જો હું હેલ્લો ચલાવો અને પછી માં ફાઈલ txt પુનઃદિશામાન કરે છે. / હેલ્લો, તે હેલો કહો, રોબ ચાલી રહ્યું છે! તરત જ.

157
00:11:52,300 --> 00:11:57,160
જ્યારે તે પ્રથમ GetString મળે છે અને તે પ્રમાણભૂત પર રાહ જોઈ છે,

158
00:11:57,160 --> 00:12:01,730
પ્રમાણભૂત લાંબા સમય સુધી દાખલ કરેલ મળશે માહિતી માટે કિબોર્ડ પર પ્રતીક્ષામાં છે.

159
00:12:01,730 --> 00:12:05,980
તેના બદલે, અમે ધોરણ માટે ફાઈલ txt માંથી વાંચી માં પુનઃદિશામાન છે.

160
00:12:05,980 --> 00:12:10,290
અને તેથી તે ફાઈલ txt, કે જે માત્ર રેખા રોબ છે વાંચી રહ્યું છે,

161
00:12:10,290 --> 00:12:13,380
અને પછી તેને હેલો, રોબ છાપી રહ્યું છે!

162
00:12:13,380 --> 00:12:18,180
અને જો હું ઇચ્છતો હતો, હું પણ નથી. / હેલ્લો txt <શકે

163
00:12:18,180 --> 00:12:21,500
અને પછી તે પ્રમાણભૂત તે છાપકામ, કે જે હેલો છે રોબ!

164
00:12:21,500 --> 00:12:24,700
હું તેની પોતાની ફાઇલમાં કે પુનઃદિશામાન કરી શકો છો.

165
00:12:24,700 --> 00:12:29,790
હું માત્ર ફાઈલ કૉલ હેલ્લો કરીશું - ના, હું નથી, કારણ કે એ એક્ઝેક્યુટેબલ છે - txt2.

166
00:12:29,790 --> 00:12:40,150
હવે, txt2 માટે /. હેલ્લો <txt, જે હેલો પ્રયત્ન રહ્યું છે રોબ નું આઉટપુટ હોય રહ્યું છે!

167
00:12:41,370 --> 00:12:43,520
>> પ્રશ્નો?

168
00:12:45,900 --> 00:12:49,090
>> ઠીક છે. તેથી તે પછી અહીં અમે પાઇપલાઇન છે.

169
00:12:49,090 --> 00:12:53,510
પાઇપ્સ પુનર્નિર્દેશન ના છેલ્લા એકમ છે.

170
00:12:53,510 --> 00:12:58,750
>> ઓહ. હું માનું એક પુનર્નિર્દેશન વધુ એકમ બદલે જો> તમે 2 કરવું>

171
00:12:58,750 --> 00:13:01,070
કે પ્રમાણભૂત ભૂલ પુનઃદિશામાન છે.

172
00:13:01,070 --> 00:13:06,280
તેથી જો કશુંક પ્રમાણભૂત ભૂલ ગયા, તે txt2 માં મળશે મૂકી શકે છે.

173
00:13:06,280 --> 00:13:12,480
પરંતુ નોટિસ જો હું 2> નહિં, તો તે હજી પણ હેલો છાપવા છે, રોબ! આદેશ વાક્ય

174
00:13:12,480 --> 00:13:18,600
કારણ કે હું માત્ર ધોરણ ભૂલ પુનઃદિશામાન છું, હું માનક નથી પુનઃદિશામાન બહાર છું.

175
00:13:18,600 --> 00:13:22,210
સ્ટાન્ડર્ડ ભૂલ અને પ્રમાણભૂત બહાર અલગ અલગ છે.

176
00:13:24,210 --> 00:13:27,080
જો તમે ખરેખર પ્રમાણભૂત ભૂલ લખવા માગતા હતા,

177
00:13:27,080 --> 00:13:35,080
પછી હું આ બદલવા માટે stderr માટે fprintf હોઈ શકે છે.

178
00:13:35,080 --> 00:13:37,850
તેથી printf, મૂળભૂત રીતે, પ્રમાણભૂત આઉટ છાપે છે.

179
00:13:37,850 --> 00:13:41,720
જો હું પ્રમાણભૂત ભૂલ જાતે છાપો કરવા માંગો છો, તો પછી હું fprintf ઉપયોગ કરે છે

180
00:13:41,720 --> 00:13:45,010
સ્પષ્ટ અને હું શું છાપવાનો કરવા માંગો છો.

181
00:13:45,010 --> 00:13:49,720
જો બદલે હું fprintf stdout પર હતી, પછી તે મૂળભૂત રીતે printf માટે સમકક્ષ છે.

182
00:13:49,720 --> 00:13:55,530
પરંતુ fprintf પ્રમાણભૂત ભૂલ છે.

183
00:13:57,790 --> 00:14:03,650
તેથી હવે જો હું txt2 આ પુનઃદિશામાન થયેલ છે, હેલો, રોબ! હજુ પણ આદેશ વાક્ય પર મુદ્રિત રહ્યું

184
00:14:03,650 --> 00:14:08,270
કારણ કે તે પ્રમાણભૂત ભૂલ રહ્યું મુદ્રિત છે અને હું માત્ર ધોરણ પુનઃદિશામાન છું બહાર.

185
00:14:08,270 --> 00:14:16,420
જો હું હવે પ્રમાણભૂત ભૂલ પુનઃદિશામાન થયેલ છે, હવે તે મળશે છપાતા નહોતી અને txt2 માટે હેલો પ્રયત્ન, રોબ રહ્યું છે!

186
00:14:16,420 --> 00:14:21,910
તેથી હવે તમે તમારી વાસ્તવિક ભૂલો પ્રમાણભૂત ભૂલ છાપી શકો છો

187
00:14:21,910 --> 00:14:24,720
અને પ્રમાણભૂત બહાર તમારી નિયમિત સંદેશાઓ છાપો.

188
00:14:24,720 --> 00:14:31,420
અને તેથી જ્યારે તમે તમારા કાર્યક્રમ ચલાવો, તો તમે તેને તરીકે ચલાવવા / શકે છે. હેલ્લો 2 સાથે આ પ્રકારની>

189
00:14:31,420 --> 00:14:33,800
જેથી તમારા કાર્યક્રમ સામાન્ય રીતે ચલાવવા રહ્યું છે,

190
00:14:33,800 --> 00:14:38,400
પરંતુ કોઈ પણ ભૂલ સંદેશાઓ કે જે તમને વિચાર પછીથી તમારી ભૂલ લોગ ચેક કરી શકો છો,

191
00:14:38,400 --> 00:14:44,500
ભૂલો છે, અને તેથી તે પછી પાછળથી દેખાય અને તમારી ભૂલો ફાઈલ કોઈપણ ભૂલો થયું હશે.

192
00:14:45,200 --> 00:14:47,540
>> પ્રશ્નો?

193
00:14:47,540 --> 00:14:58,070
>> છેલ્લા એક પાઇપ, કે જે તમે પ્રમાણભૂત એક આદેશ બહાર લઈ તરીકે લાગે શકે છે

194
00:14:58,070 --> 00:15:01,210
અને તે આગામી આદેશ માં પ્રમાણભૂત બનાવે છે.

195
00:15:01,210 --> 00:15:05,570
અહીં એક ઉદાહરણ પડઘો આદેશ વાક્ય વસ્તુ છે

196
00:15:05,570 --> 00:15:11,840
કે માત્ર પડઘો ગમે હું તેની દલીલ તરીકે મૂકવામાં રહ્યું છે. હું અવતરણ મૂકી નથી શકતા.

197
00:15:11,840 --> 00:15:16,150
ઇકો મૂર્ખામી ભરેલી વાહિયાત વાત, મૂર્ખામી ભરેલી વાહિયાત વાત, મૂર્ખામી ભરેલી વાહિયાત વાત મૂર્ખામી ભરેલી વાહિયાત વાત માત્ર, મૂર્ખામી ભરેલી વાહિયાત વાત, મૂર્ખામી ભરેલી વાહિયાત વાત છાપી રહ્યું છે.

198
00:15:16,150 --> 00:15:20,600
પહેલાં, જ્યારે હું જણાવ્યું હતું કે હું એક txt ફાઇલમાં રોબ મૂકી હતી

199
00:15:20,600 --> 00:15:28,830
કારણ કે હું માત્ર txt ફાઈલો પુનઃદિશામાન કરી શકો છો, તેના બદલે, I / રોબ પડઘો જો

200
00:15:28,830 --> 00:15:35,520
અને પછી પાઇપ તેને ધ્યાનમાં / હેલ્લો, કે જે પણ વસ્તુ એક જ પ્રકારનો કરશે..

201
00:15:35,520 --> 00:15:39,160
આ આદેશનું આઉટપુટ, ઇકો રોબ લઈ રહ્યું છે,

202
00:15:39,160 --> 00:15:43,610
અને તે માટે ઇનપુટ તરીકે ઉપયોગ કરીને /. હેલો.

203
00:15:44,790 --> 00:15:49,560
તમે તેને લાગે તરીકે પ્રથમ ફાઇલમાં પડઘો રોબ પુનઃદિશામાન કરી શકો છો

204
00:15:49,560 --> 00:15:54,160
અને પછી /. હેલ્લો કે ફાઇલમાં ઇનપુટ કે જે હમણાં જ outputted હતી.

205
00:15:54,160 --> 00:15:57,850
પરંતુ તે ચિત્ર ના કામચલાઉ ફાઈલ બહાર લઈ જશે.

206
00:16:01,890 --> 00:16:04,460
>> પર પ્રશ્નો?

207
00:16:04,460 --> 00:16:07,150
>> આગામી પ્રશ્ન આ સમાવેશ થાય રહ્યું છે.

208
00:16:07,150 --> 00:16:15,310
પાઇપલાઇન શું તમે names.txt કહેવાય ફાઈલમાં અનન્ય નામો સંખ્યા શોધવા ઉપયોગ કરી શકે છે?

209
00:16:15,310 --> 00:16:24,160
આદેશો અમે અહીં ઉપયોગ કરવા માંગો છો જઈ રહ્યાં છો અનન્ય છે, તેથી uniq અને પછી WC છે.

210
00:16:24,160 --> 00:16:28,840
તમે માણસ uniq કરવું ખરેખર છે કે શું કરે જોવા કરી શકો છો,

211
00:16:28,840 --> 00:16:34,840
અને તે માત્ર ઈનપુટમાંથી અડીને બંધબેસતા લીટીઓ ફિલ્ટર બનશે.

212
00:16:34,840 --> 00:16:40,690
અને માણસ WC માટે NEWLINE, શબ્દ, અને દરેક ફાઈલ માટે બાઈટ ગણતરી છાપી રહ્યું છે.

213
00:16:40,690 --> 00:16:43,760
અને છેલ્લા એક અમે ઉપયોગ કરવા માંગો છો જઈ રહ્યાં છો જેવું છે,

214
00:16:43,760 --> 00:16:47,410
જે માત્ર txt ફાઈલ રેખાઓ સૉર્ટ રહ્યું છે.

215
00:16:47,410 --> 00:16:58,080
જો હું કેટલાક txt ફાઇલ, names.txt બનાવવા અને તેને રોબ, ટોમી, જોસેફ, ટોમી, જોસેફ, આરજે, રોબ છે,

216
00:16:58,080 --> 00:17:03,910
હું અહીં શું કરવા માંગો છો છે અને આ ફાઈલમાં અનન્ય નામો સંખ્યા શોધો.

217
00:17:03,910 --> 00:17:08,750
તેથી જવાબ શું હોવું જોઈએ? >> [વિદ્યાર્થી] 4. >> યાહ.

218
00:17:08,750 --> 00:17:13,780
તે 4, રોબ ટોમી, જોસેફ થી હોવુ જોઇએ, આરજે આ ફાઇલ એક માત્ર અનન્ય નામો છે.

219
00:17:13,780 --> 00:17:20,180
પ્રથમ પગલું, જો હું માત્ર names.txt પર શબ્દ ગણતરી કરવા માટે,

220
00:17:20,180 --> 00:17:24,290
આ ખરેખર મને બધું કહેવાની છે.

221
00:17:24,290 --> 00:17:32,560
આ વાસ્તવમાં છે પ્રિન્ટીંગ - દો છે, જુઓ માણસ WC - newlines, શબ્દો, અને બાઈટ ગણતરી.

222
00:17:32,560 --> 00:17:38,270
જો હું માત્ર લીટીઓ વિશે ચિંતિત હોય, તો પછી હું ફક્ત WC-l names.txt કરી શકો છો.

223
00:17:41,730 --> 00:17:44,300
જેથી પગલાં 1 છે.

224
00:17:44,300 --> 00:17:50,510
પરંતુ હું WC-l names.txt ન માંગતા કારણ કે names.txt ફક્ત તમામ નામો સમાવે નહિં,

225
00:17:50,510 --> 00:17:54,170
અને હું બહાર કોઈપણ બિન અનન્ય મુદ્દાઓ ફિલ્ટર કરવા માંગો છો.

226
00:17:54,170 --> 00:18:01,200
તેથી જો હું uniq names.txt કરવા માટે, કે તે તદ્દન મને આપતું નથી હું શું કરવા માંગો છો

227
00:18:01,200 --> 00:18:03,760
કારણ કે ડુપ્લિકેટ નામો હજુ પણ ત્યાં હોય છે.

228
00:18:03,760 --> 00:18:07,690
કે શા માટે છે? Uniq શા માટે કરી રહ્યા છે હું શું કરવા માંગો છો?

229
00:18:07,690 --> 00:18:10,500
[વિદ્યાર્થી] છે આ ડુપ્લિકેટ્સ [અશ્રાવ્ય] >> યાહ.

230
00:18:10,500 --> 00:18:16,370
Uniq માટે મદદ પાનું યાદ રાખો ફિલ્ટર અડીને મેચિંગ રેખાઓ કહે છે.

231
00:18:16,370 --> 00:18:19,680
તેઓ અડીને નથી તેથી તે તેમને ફિલ્ટર કરશે.

232
00:18:19,680 --> 00:18:31,100
જો હું તેમને પ્રથમ, સૉર્ટ સૉર્ટ names.txt બધી નકલી રેખાઓ સાથે મળીને રાખવામાં રહ્યું છે.

233
00:18:31,100 --> 00:18:34,450
તેથી હવે સૉર્ટ names.txt હોય છે.

234
00:18:34,450 --> 00:18:40,550
Uniq | હું uniq છે, જે છે ઇનપુટ તરીકે ઉપયોગ કરવા માંગો છો કે જાઉં છું.

235
00:18:40,550 --> 00:18:43,390
કે મને જોસેફ, આરજે, રોબ, ટોમી આપે છે,

236
00:18:43,390 --> 00:18:49,260
અને હું WC-l માટે ઇનપુટ તરીકે ઉપયોગ કરવા માંગો છો કે,

237
00:18:49,260 --> 00:18:52,740
જેના માટે માટે મારે 4 આપી રહ્યું છે.

238
00:18:52,740 --> 00:18:56,930
જેમ તે અહીં કહે છે, પાઇપલાઇન શું તમે ઉપયોગ કરી શકો?

239
00:18:56,930 --> 00:19:01,390
તમને આદેશો શ્રેણીબદ્ધ મદદથી જેવી વસ્તુઓ ઘણો કરી શકો છો

240
00:19:01,390 --> 00:19:05,130
જ્યાં તમે એક આદેશ ના આગામી આદેશ ઇનપુટ તરીકે આઉટપુટ વાપરો.

241
00:19:05,130 --> 00:19:08,780
તમે વસ્તુઓ, હોંશિયાર વસ્તુઓ કરી શકે છે.

242
00:19:08,780 --> 00:19:11,440
>> પ્રશ્નો?

243
00:19:12,910 --> 00:19:14,600
ઠીક છે.

244
00:19:14,600 --> 00:19:17,880
કે તે પાઇપ અને રીડાયરેક્શન નથી માટે છે.

245
00:19:18,370 --> 00:19:24,090
>> હવે અમે વાસ્તવિક સામગ્રી છે, કોડિંગ સામગ્રી પર જાઓ.

246
00:19:24,090 --> 00:19:29,100
આ PDF ની અંદર, તમે આ આદેશ જોશો,

247
00:19:29,100 --> 00:19:32,950
અને તમે તમારા ઉપકરણ માં આ આદેશ ચલાવવા માંગો પડશે.

248
00:19:36,240 --> 00:19:42,250
માત્ર ઇન્ટરનેટ માંથી કંઈક મેળવવા માટે wget આદેશ છે મૂળભૂત રીતે,

249
00:19:42,250 --> 00:19:45,180
જેથી wget અને આ URL.

250
00:19:45,180 --> 00:19:49,110
જો તમે તમારા બ્રાઉઝરમાં આ URL માટે ગયા, તે ફાઇલ ડાઉનલોડ થશે.

251
00:19:49,110 --> 00:19:52,510
હું માત્ર તેના પર ક્લિક કર્યું છે, તેથી તેને મને માટે ફાઈલ ડાઉનલોડ કરી છે.

252
00:19:52,510 --> 00:19:55,650
પરંતુ ટર્મિનલ ની અંદર કે વસ્તુને wget લેખન

253
00:19:55,650 --> 00:19:58,620
છે ફક્ત તેને તમારા ટર્મિનલ માં ડાઉનલોડ થઈ રહ્યું છે.

254
00:19:58,620 --> 00:20:02,750
હું section5.zip હોય, અને તમે section5.zip ઝિપસાંકળ છોડવી માંગો છો પડશે,

255
00:20:02,750 --> 00:20:06,520
જે તમને section5 કહેવાય ફોલ્ડર આપી રહ્યું છે,

256
00:20:06,520 --> 00:20:11,550
જે ફાઇલો અમે આજે ની અંદર ઉપયોગ કરી રહ્યા છીએ બધી રહ્યું છે.

257
00:20:33,380 --> 00:20:37,710
જેમ આ કાર્યક્રમો ફાઈલ નામોનું સૂચન, તેઓ થોડી બગડેલ કરશો,

258
00:20:37,710 --> 00:20:40,990
તેથી તમારા મિશન માટે બહાર આકૃતિ શા માટે gdb ઉપયોગ કરે છે.

259
00:20:40,990 --> 00:20:44,560
નથી દરેકને તેમને / ડાઉનલોડ કરેલ હોય તો ખબર કેવી રીતે તેમને ડાઉનલોડ

260
00:20:44,560 --> 00:20:47,480
તેમના સાધન માં? ઠીક છે.

261
00:20:47,480 --> 00:20:56,400
>> ./buggy1 ચલાવી રહ્યા હોય, તે વિભાગીય દોષ (કોર ડમ્પ) કહેવું પડશે,

262
00:20:56,400 --> 00:21:00,500
જે કોઇ પણ સમયે segfault વિચાર, તે ખરાબ બાબત છે.

263
00:21:00,500 --> 00:21:03,810
સંજોગો શું હેઠળ તમે segfault વિચાર છે?

264
00:21:03,810 --> 00:21:08,210
[વિદ્યાર્થી] એક નલ નિર્દેશક Dereferencing. >> યાહ. જેથી એક ઉદાહરણ છે.

265
00:21:08,210 --> 00:21:11,580
એક નલ નિર્દેશક તમે segfault વિચાર જઈ રહ્યાં છો Dereferencing.

266
00:21:11,580 --> 00:21:16,720
એક શું અર્થ segfault છે તમે મેમરી સ્પર્શ કરી રહ્યાં છો તમે સ્પર્શ નથી.

267
00:21:16,720 --> 00:21:21,350
તેથી નલ નિર્દેશક dereferencing 0 સરનામા સ્પર્શ છે,

268
00:21:21,350 --> 00:21:28,060
અને મૂળભૂત, બધા કમ્પ્યુટર્સ હવે કહે છે કે સરનામા 0 મેમરી તમે સ્પર્શ જોઇએ નહિં છે.

269
00:21:28,060 --> 00:21:31,920
તેથી કે કેમ segfault માં નલ નિર્દેશક પરિણામો dereferencing.

270
00:21:31,920 --> 00:21:37,210
જ્યારે તમે એક નિર્દેશક પ્રારંભ ન થાય, તો પછી તે કચરો કિંમત ધરાવે છે,

271
00:21:37,210 --> 00:21:41,520
અને તેથી જ્યારે તમે ડિરેફરન્સ પ્રયત્ન તે તમામ શક્યતા તમે મેમરી સ્પર્શ કરી રહ્યાં છો

272
00:21:41,520 --> 00:21:43,540
કે ક્યાંય મધ્યમાં છે.

273
00:21:43,540 --> 00:21:45,650
જો તમે નસીબદાર અને કચરો કિંમત વિચાર થાય છે

274
00:21:45,650 --> 00:21:48,440
માટે સ્ટેક અથવા કંઈક પર બીજે નિર્દેશ થયો,

275
00:21:48,440 --> 00:21:50,820
પછી તમે ડિરેફરન્સ કે નિર્દેશક જે તમે નથી આરંભ કરે છે,

276
00:21:50,820 --> 00:21:52,730
કશું ખોટું જશે.

277
00:21:52,730 --> 00:21:55,480
પરંતુ જો તે પોઇન્ટ છે, કહે છે, સ્ટેક અને ઢગલો વચ્ચે ક્યાંક,

278
00:21:55,480 --> 00:21:59,850
અથવા તે માત્ર ક્યાંક છે કે જે તમારા કાર્યક્રમ દ્વારા આવી નથી ઉપયોગ કરવામાં હજુ સુધી પોઇન્ટ છે,

279
00:21:59,850 --> 00:22:02,240
પછી તમે મેમરી સ્પર્શ કરી રહ્યાં છો તમે સ્પર્શ જોઇએ નહિં અને તમે segfault.

280
00:22:02,240 --> 00:22:06,370
જ્યારે તમે ફરી યાદ આવવું કાર્ય લખી અને તેને ઘણી વાર recurses

281
00:22:06,370 --> 00:22:08,720
અને તમારા સ્ટેક વસ્તુઓ માં ખૂબ મોટી અને સ્ટેક અથડામણ ઊગે

282
00:22:08,720 --> 00:22:12,270
કે તે સાથે અથડાઈ જોઈએ, તમે મેમરી સ્પર્શ કરી રહ્યાં છો તમે સ્પર્શ જોઇએ નહિં,

283
00:22:12,270 --> 00:22:14,810
જેથી તમે segfault.

284
00:22:14,810 --> 00:22:17,010
એટલે કે segfault એક શું છે.

285
00:22:17,010 --> 00:22:21,810
>> તે પણ આ જ કારણ છે કે તમે જેવા શબ્દમાળા હોય તો -

286
00:22:21,810 --> 00:22:23,930
ચાલો અગાઉના કાર્યક્રમ પર પાછા જાઓ.

287
00:22:23,930 --> 00:22:28,530
માં hello.c-I'm માત્ર કંઈક બીજું બનાવવા જઈ રહી છે.

288
00:22:28,530 --> 00:22:33,770
ઘરનાં પરચૂરણ કામો * ઓ = "વિશ્વ હેલો!";

289
00:22:33,770 --> 00:22:42,310
; જો હું * ઓ = કંઈક અથવા ઓ [0] = 'એક્સ' 'નો ઉપયોગ

290
00:22:42,310 --> 00:22:47,290
જેથી બનાવવા હેલ્લો /. હેલ્લો, કેમ કે segfault હતી?

291
00:22:48,410 --> 00:22:51,250
આ કેમ segfault હતી?

292
00:22:55,660 --> 00:22:57,890
તમે શું અપેક્શા શું થશે?

293
00:22:57,890 --> 00:23:06,640
જો હું printf હતી ("% s \ n" ઓ); તમે શું છપાશે અપેક્ષા છે?

294
00:23:06,640 --> 00:23:09,930
[વિદ્યાર્થી] અને એક્સ હેલો. >> યાહ.

295
00:23:09,930 --> 00:23:15,140
સમસ્યા એ છે કે જ્યારે તમે આ જેવી શબ્દમાળા જાહેર,

296
00:23:15,140 --> 00:23:18,190
ઓ એક નિર્દેશક કે જે સ્ટેક પર જાઓ રહ્યું છે છે,

297
00:23:18,190 --> 00:23:25,880
અને ઓ માટે પોઇન્ટ છે શું આ શબ્દમાળાને જે રીડ ઓન્લી મેમરી માં સમાયેલ છે.

298
00:23:25,880 --> 00:23:30,560
તેથી જ, નામ, મેમરી માત્ર વાંચી દ્વારા, તમે વિચાર વિચાર કરીશું

299
00:23:30,560 --> 00:23:33,010
કે જો તમે બદલવા શું રીડ ઓન્લી મેમરી માં છે પ્રયાસ કરો,

300
00:23:33,010 --> 00:23:36,670
તમે કંઈક તમે મેમરી સાથે ન કરી કરીશું કરી રહ્યા છીએ અને તમે segfault.

301
00:23:36,670 --> 00:23:45,360
આ વાસ્તવમાં ઘરનાં પરચૂરણ કામો * ઓ અને કોલસો બનાવો] [ઓ વચ્ચે મોટો તફાવત છે.

302
00:23:45,360 --> 00:23:48,790
તેથી ઓ ઘરનાં પરચૂરણ કામો] [, હવે આ શબ્દમાળાને સ્ટેક પર મૂકી શકાય રહ્યું છે,

303
00:23:48,790 --> 00:23:53,960
અને સ્ટેક ફક્ત વાંચવા માટે નથી, કે જેનો અર્થ એ છે કે આ સંપૂર્ણપણે દંડ કામ કરીશું.

304
00:23:55,500 --> 00:23:57,370
અને તે કરે છે.

305
00:23:57,370 --> 00:24:06,250
યાદ રાખો કે જ્યારે હું ઘરનાં પરચૂરણ કામો કરવા * ઓ = "હેલ્લો! વર્લ્ડ", પોતાને ઓ સ્ટેક પર છે

306
00:24:06,250 --> 00:24:10,390
પરંતુ બીજે ક્યાંક ને પોઇન્ટ, અને તે બીજે ક્યાંય માટે ફક્ત વાંચવા માટે બને છે.

307
00:24:10,390 --> 00:24:15,640
પરંતુ ઘરનાં પરચૂરણ કામો] [ઓ માત્ર સ્ટેક પર કંઈક છે.

308
00:24:17,560 --> 00:24:21,760
જેથી segfault થઈ રહ્યું અન્ય ઉદાહરણ છે.

309
00:24:21,760 --> 00:24:27,820
>> અમે જોયું છે કે ./buggy1 એક segfault માં પરિણમેલ છે.

310
00:24:27,820 --> 00:24:31,810
સિદ્ધાંત, તમે buggy1.c અંતે તુરંત જ નથી હવો જોઈએ.

311
00:24:31,810 --> 00:24:35,170
તેના બદલે, અમે તેના પર gdb મારફતે જોવા મળશે.

312
00:24:35,170 --> 00:24:37,750
કે નોટિસ જ્યારે તમે સેગ્મેન્ટેશન ક્ષતિમાં (કોર ડમ્પ) વિચાર,

313
00:24:37,750 --> 00:24:40,850
તમે અહીં કહેવાય કોર પર આ ફાઈલ મેળવો.

314
00:24:40,850 --> 00:24:45,200
અમે ls-l જો, અમે જોશો કે કોર સામાન્ય રીતે ખૂબ મોટી ફાઈલ છે.

315
00:24:45,200 --> 00:24:51,580
આ ફાઇલ બાઇટ્સ સંખ્યા છે, તેથી તેને લાગે છે કે તે 250 કંઈક કિલોબાઈટોમાં છે.

316
00:24:51,580 --> 00:24:56,120
આ માટેનું કારણ એ છે કે કોર ડમ્પ ખરેખર શું છે

317
00:24:56,120 --> 00:25:01,410
છે જ્યારે તમારું કાર્યક્રમ અકસ્માત, તમારા કાર્યક્રમ મેમરી સ્થિતિ

318
00:25:01,410 --> 00:25:05,230
માત્ર નકલ અને નહીં આ ફાઇલમાં પેસ્ટ કર્યું.

319
00:25:05,230 --> 00:25:07,270
તે ફાઈલમાં ડમ્પ નહીં.

320
00:25:07,270 --> 00:25:13,060
આ કાર્યક્રમ, જ્યારે તે ચાલી રહ્યું હતું, માટે 250 આસપાસ રહેલ એક મેમરી વપરાશ હોય થયું,

321
00:25:13,060 --> 00:25:17,040
અને જેથી શું આ ફાઈલમાં ડમ્પ મળ્યો છે.

322
00:25:17,040 --> 00:25:23,630
હવે તમે તે ફાઈલ પર નજર જો આપણે gdb buggy1 કોર કરી શકો છો.

323
00:25:23,630 --> 00:25:30,130
અમે હમણાં જ buggy1 gdb કરી શકે છે, અને કે જે હમણાં જ અપ gdb શરૂ કરશે નિયમિત,

324
00:25:30,130 --> 00:25:33,800
તેની ઇનપુટ ફાઇલ તરીકે buggy1 મદદથી.

325
00:25:33,800 --> 00:25:38,260
પરંતુ જો તમે gdb buggy1 કોર કરવું, પછી તે ખાસ કરીને અપ gdb શરૂ થઈ રહ્યું છે તે

326
00:25:38,260 --> 00:25:40,330
કે કોર ફાઈલ જોઈ છે.

327
00:25:40,330 --> 00:25:45,560
અને તમે buggy1 અર્થ gdb કહેતા જાણે કે જે કોર ફાઈલ buggy1 કાર્યક્રમ આવે છે.

328
00:25:45,560 --> 00:25:49,580
તેથી gdb buggy1 કોર તરત જ આપણને લાવી રહ્યું છે

329
00:25:49,580 --> 00:25:52,060
જ્યાં કાર્યક્રમ સમાપ્ત થયું છે.

330
00:25:57,720 --> 00:26:02,340
અમે અહીં જોવા કાર્યક્રમ 11 સિગ્નલ, વિભાગીય ખામી સાથે સમાપ્ત.

331
00:26:02,340 --> 00:26:10,110
અમે એસેમ્બલી, જે સંભવતઃ ખૂબ જ ઉપયોગી નથી એક વાક્ય જુઓ થાય છે.

332
00:26:10,110 --> 00:26:15,360
પરંતુ જો તમે BT અથવા બેકસ્ટ્રેસ લખો કે જે કાર્ય જ હશે

333
00:26:15,360 --> 00:26:19,430
કે અમારા વર્તમાન સ્ટેક ફ્રેમ્સ યાદી આપે છે.

334
00:26:19,430 --> 00:26:23,150
તેથી બેકસ્ટ્રેસ. એવું લાગે છે કે અમે માત્ર બે સ્ટેક ફ્રેમ્સ છે.

335
00:26:23,150 --> 00:26:26,310
પ્રથમ અમારી મુખ્ય સ્ટેક ફ્રેમ હોય છે,

336
00:26:26,310 --> 00:26:29,810
અને બીજા આ કાર્ય કે અમે હોવા થાય માટેના સ્ટેક ફ્રેમ હોય છે,

337
00:26:29,810 --> 00:26:34,440
જે લાગે છે કે અમે માત્ર માટે વિધાનસભા કોડ છે.

338
00:26:34,440 --> 00:26:38,050
તેથી આપણે આપણા મુખ્ય કાર્ય માં પાછા જાઓ,

339
00:26:38,050 --> 00:26:42,300
અને કરવા કે અમે 1 ફ્રેમ કરી શકો છો, અને મને લાગે છે કે અમે પણ નીચે કરી શકો છો,

340
00:26:42,300 --> 00:26:45,160
પરંતુ હું લગભગ આવું ક્યારેય નીચે - અપ અથવા. યાહ.

341
00:26:45,160 --> 00:26:50,710
ઉપર અને નીચે. તમને લાવે એક સ્ટેક ફ્રેમ, નીચે તમે લાવે નીચે સ્ટેક ફ્રેમ.

342
00:26:50,710 --> 00:26:53,240
હું ક્યારેય ઉપયોગ કરે છે.

343
00:26:53,240 --> 00:26:59,120
મેં હમણાં જ ખાસ 1 ફ્રેમ, કે જે 1 લેબલ થયેલ ફ્રેમ પર જવા માટે છે કહો.

344
00:26:59,120 --> 00:27:01,750
1 ફ્રેમ અમને લાવવા મુખ્ય સ્ટેક ફ્રેમ માં રહ્યું છે,

345
00:27:01,750 --> 00:27:05,570
અને તે અહીં કોડ લીટી અમે હોવા થાય છે.

346
00:27:05,570 --> 00:27:07,950
જો આપણે કોડ થોડા વધુ લીટીઓ માગતા હતા, અમે યાદી કહેવું કરી શકો છો,

347
00:27:07,950 --> 00:27:11,280
અને તે અમને તેની આસપાસ તમામ કોડ લીટીઓ આપી રહ્યું છે.

348
00:27:11,280 --> 00:27:13,360
આ વાક્ય આપણે અંતે segfaulted 6 હતું:

349
00:27:13,360 --> 00:27:17,360
જો (strcmp ("CS50 ખડકો", argv [1]) == 0).

350
00:27:17,360 --> 00:27:24,130
જો તે સ્પષ્ટ નથી, તો તમે તેને કોઈ રન નોંધાયો નહીં વિચારી તે શા માટે segfaulted દ્વારા માત્ર કરી શકો છો અહીં છે.

351
00:27:24,130 --> 00:27:28,800
પરંતુ અમે તે એક પગલું આગળ લે છે અને કહે છે શકો છો, "શા માટે argv [1] segfault છો?"

352
00:27:28,800 --> 00:27:38,830
લેટ્સ પ્રિન્ટ argv [1], અને તે તેના 0x0 છે, કે જે નલ નિર્દેશક છે જેવો દેખાય છે.

353
00:27:38,830 --> 00:27:44,750
અમે CS50 ખડકો અને નલ strcmping છીએ, અને તેથી કે જે segfault બનશે.

354
00:27:44,750 --> 00:27:48,280
અને શા માટે છે argv [1] નલ?

355
00:27:48,640 --> 00:27:51,280
[વિદ્યાર્થી] કારણ કે અમે તેને કોઈપણ આદેશ વાક્ય દલીલો આપી ન હતી.

356
00:27:51,280 --> 00:27:53,390
યાહ. અમે તેને કોઈપણ આદેશ વાક્ય દલીલો આપી ન હતી.

357
00:27:53,390 --> 00:27:58,460
તેથી ./buggy1 માત્ર હોય argv [0] ./buggy1 પ્રયત્ન રહ્યું છે.

358
00:27:58,460 --> 00:28:02,100
તે એક argv [1] નથી ચાલી રહ્યું છે, આથી તે માટે segfault બનશે.

359
00:28:02,100 --> 00:28:07,450
પરંતુ જો, તેની બદલે, મેં હમણાં જ CS50 કરવા માટે, તે કહે તમે ડી બનશે

360
00:28:07,450 --> 00:28:09,950
કારણ કે તે શું છે તે કરવા માટે માનવામાં આવે છે.

361
00:28:09,950 --> 00:28:15,240
Buggy1.c અંતે છીએ, તે છાપી તેવું માનવામાં આવે છે "તમે ડી વિચાર" -

362
00:28:15,240 --> 00:28:20,820
જો argv [1] "CS50 ખડકો" નહિં હોય, "તમે ડી વિચાર", બીજું "તમે એક વિચાર!"

363
00:28:20,820 --> 00:28:25,660
તેથી જો અમે એ માંગો છો, અમે આ કરવાની જરૂર સાચું તરીકે સરખાવવા માટે,

364
00:28:25,660 --> 00:28:28,710
જેનો અર્થ છે કે 0 થી તેને સરખાવે છે.

365
00:28:28,710 --> 00:28:31,100
તેથી argv [1] "CS50 ખડકો" જરૂરી છે.

366
00:28:31,100 --> 00:28:35,660
જો તમે આદેશ વાક્ય પર કરવા માંગો છો, તો તમે \ વાપરવા માટે જગ્યા છટકી જરૂર છે.

367
00:28:35,660 --> 00:28:41,690
તેથી CS50 \ ખડકો અને તમે એક એક વિચાર!

368
00:28:41,690 --> 00:28:44,060
જો તમે બેકસ્લેશ નથી, આ શા માટે કામ નથી?

369
00:28:44,060 --> 00:28:47,190
[વિદ્યાર્થી] આ બે અલગ અલગ દલીલો છે. >> યાહ.

370
00:28:47,190 --> 00:28:52,540
Argv [1] CS50 પ્રયત્ન રહ્યું છે, અને argv [2] ખડકો પ્રયત્ન રહ્યું છે. ઠીક છે.

371
00:28:52,540 --> 00:28:56,470
>> હવે ./buggy2 ફરીથી segfault રહ્યું છે.

372
00:28:56,470 --> 00:29:01,880
તેના બદલે તે તેના કોર ફાઈલ સાથે ખોલ્યા છે, અમે હમણાં buggy2 સીધી ખોલવા પડશે,

373
00:29:01,880 --> 00:29:05,000
buggy2 gdb જેથી.

374
00:29:05,000 --> 00:29:09,590
હવે જો આપણે માત્ર અમારા કાર્યક્રમ ચલાવો, તો પછી તે કહેવું કાર્યક્રમ સંકેત SIGSEGV પ્રાપ્ત ચાલી રહ્યું છે,

375
00:29:09,590 --> 00:29:15,530
કે જે સંકેત segfault, અને આ છે જ્યાં તે થાય થયું.

376
00:29:15,530 --> 00:29:21,250
અમારા બેકસ્ટ્રેસ અંતે છીએ, અમે જુઓ કે અમે કાર્ય oh_no હતા,

377
00:29:21,250 --> 00:29:23,900
જે કાર્ય નમણું, કે જે કાર્ય binky દ્વારા બોલાવવામાં આવ્યો દ્વારા બોલાવવામાં આવ્યા,

378
00:29:23,900 --> 00:29:26,460
જે મુખ્ય દ્વારા કહેવામાં આવતું હતું.

379
00:29:26,460 --> 00:29:31,680
અમે પણ આ વિધેયોને માટે દલીલો જોઈ શકો છો.

380
00:29:31,680 --> 00:29:34,680
સુઘડ અને binky માટે દલીલ 1 હતી.

381
00:29:34,680 --> 00:29:44,390
જો અમે કાર્ય oh_no યાદી, અમે જુઓ કે oh_no માત્ર કોલસો બનાવો ** ઓ = NULL કરી છે;

382
00:29:44,390 --> 00:29:47,410
* ઓ = "તેજી";

383
00:29:47,410 --> 00:29:50,330
કે શા માટે નિષ્ફળ જશે?

384
00:29:54,330 --> 00:29:58,380
[વિદ્યાર્થી] તમે NULL નિર્દેશક ખોટો સંદર્ભ નથી કરી શકતાં? >> યાહ.

385
00:29:58,380 --> 00:30:06,090
આ માત્ર કહી રહ્યાં છે ઓ NULL છે, અનુલક્ષીને જો કે ચાર રચે છે ** બને છે,

386
00:30:06,090 --> 00:30:12,070
, જે તમે કેવી રીતે તે અર્થઘટન પર આધાર રાખીને, તે શબ્દમાળા માટે નિર્દેશક માટે નિર્દેશક હોઈ શકે છે

387
00:30:12,070 --> 00:30:15,550
અથવા શબ્દમાળાઓ પણ દર્શાવે છે.

388
00:30:15,550 --> 00:30:21,430
તે ઓ NULL છે, તેથી * ઓ એક નલ નિર્દેશક dereferencing છે,

389
00:30:21,430 --> 00:30:24,800
અને તેથી આ માટે તૂટી રહ્યું છે.

390
00:30:24,800 --> 00:30:27,540
આ એક ઝડપી માર્ગ તમે કદાચ segfault શકે છે.

391
00:30:27,540 --> 00:30:31,300
તે માત્ર એક નલ નિર્દેશક જાહેર કરવામાં આવ્યું છે અને તરત જ segfaulting.

392
00:30:31,300 --> 00:30:34,570
કે oh_no શું કરી છે.

393
00:30:34,570 --> 00:30:43,400
જો આપણે એક ફ્રેમ જાઓ, અને પછી અમે એ વિધેય કે oh_no કહેવાય પ્રવેશ મેળવવા જઈ રહ્યાં છો.

394
00:30:43,400 --> 00:30:44,830
હું નીચે કરવાની જરૂર છે.

395
00:30:44,830 --> 00:30:48,610
જો તમે આદેશ દાખલ કરો અને તમે માત્ર લિમિટેડ ફરીથી દબાવો,

396
00:30:48,610 --> 00:30:52,350
તે માત્ર અગાઉના આદેશ કે જે તમે ચાલી હતી પુનરાવર્તન થશે.

397
00:30:52,350 --> 00:30:56,610
અમે 1 ફ્રેમ હોય છે.

398
00:30:56,610 --> 00:31:04,650
આ ફ્રેમ યાદી, અમે જોવા માટે અહીં અમારી કાર્ય છે.

399
00:31:04,650 --> 00:31:08,520
તમે યાદી ફરીથી ફટકો કરી શકો છો, અથવા તમે 20 યાદી કરી શકો છો અને તેને વધુ યાદી આપશે.

400
00:31:08,520 --> 00:31:13,640
કાર્ય સુઘડ કહે છે જો હું 1 હોય, તો પછી oh_no કાર્ય પર જાઓ,

401
00:31:13,640 --> 00:31:15,960
બીજું એ slinky કાર્ય પર જાઓ.

402
00:31:15,960 --> 00:31:18,700
અને અમે જાણીએ છીએ કે હું 1 છે કારણ કે અમે અહીં જુઓ થવું

403
00:31:18,700 --> 00:31:22,560
કે સુરેખ એ 1 દલીલ સાથે કહેવામાં આવતું હતું.

404
00:31:22,560 --> 00:31:27,560
અથવા તમે માત્ર હું છાપી શકો છો અને તે કહે છે કે હું 1 છે.

405
00:31:27,560 --> 00:31:33,770
અમે સોહામણું વર્તમાનમાં છે, અને જો આપણે બીજા ફ્રેમ જાઓ, અમે જાણીએ છીએ કે અમે અપ binky માં સમાપ્ત કરીશું.

406
00:31:33,770 --> 00:31:36,600
ઉપર. હવે અમે binky છો.

407
00:31:36,600 --> 00:31:41,340
પહેલા અડધા મને કટ ના યાદી - આ કાર્ય યાદી -

408
00:31:41,340 --> 00:31:52,670
આ બોલ પર શરૂ જો હું 0 છે, તો પછી અમે તેને oh_no કૉલ જઈ રહ્યાં છો, તે અન્ય આકર્ષક ફોન કરો.

409
00:31:52,670 --> 00:31:57,000
અમે જાણીએ છીએ હું 1 હતી, તેથી તેને સોહામણું કહેવાય છે.

410
00:31:57,000 --> 00:32:05,030
અને હવે અમે મુખ્ય માં પાછા આવ્યા, અને મુખ્ય માત્ર પૂર્ણાંક હું = રેન્ડ (3)% પ્રયત્ન રહ્યું છે;

411
00:32:05,030 --> 00:32:08,790
કે જે હમણાં જ તમને રેન્ડમ નંબર છે કે જે 0 ક્યાં, 1, અથવા 2 છે આપી રહ્યું છે.

412
00:32:08,790 --> 00:32:12,780
તે જે નંબર સાથે binky કહી રહ્યું છે, અને તે 0 આપશે.

413
00:32:12,780 --> 00:32:16,700
આ અંતે છીએ,

414
00:32:16,700 --> 00:32:19,880
ફક્ત કાર્યક્રમ દ્વારા જાતે વૉકિંગ તે તુરંત જ ચાલુ કર્યા વગર,

415
00:32:19,880 --> 00:32:25,400
તમે મુખ્ય અંતે વિરામ બિંદુ સુયોજિત હો, જેનો અર્થ છે કે જ્યારે અમે કાર્યક્રમ ચલાવો

416
00:32:25,400 --> 00:32:31,020
તમારા કાર્યક્રમ અપ સ્કોર સુધી તે બ્રેક પોઇન્ટ બનાવ્યા.

417
00:32:31,020 --> 00:32:35,450
આ કાર્યક્રમ ચાલી રહ્યો છે, કે જેથી તેને ચલાવવા માટે અને પછી તે મુખ્ય કાર્ય ફટકો અને ચાલી અટકાવવા કરશે.

418
00:32:35,450 --> 00:32:44,700
હવે અમે મુખ્ય અંદર કરશો, અને પગલું અથવા આગામી અમને કોડ આગળના વાક્ય લાવી રહ્યું છે.

419
00:32:44,700 --> 00:32:47,050
તમે પગલું અથવા આગામી કરી શકો છો.

420
00:32:47,050 --> 00:32:51,800
આગામી હિટિંગ, હવે હું રેન્ડ (3)% છે, તેથી અમે i ની કિંમત છાપી શકો છો પર સેટ છે,

421
00:32:51,800 --> 00:32:55,280
અને તે કહે છે કે હું 1 છે.

422
00:32:55,280 --> 00:32:58,110
હવે તે બાબત શું આપણે આગામી અથવા પગલું ઉપયોગ કરે છે.

423
00:32:58,110 --> 00:33:01,000
હું માનું તેને પહેલાંના એક mattered, પણ અમે આગામી ઉપયોગ કરવા માંગો છો કરશે.

424
00:33:01,000 --> 00:33:06,000
જો અમે પગલું વાપરવા માટે, અમે કાર્ય સ્ટેપ ઇનટુ છે, કે જે વાસ્તવિક વસ્તુ અંતે દેખાવ અર્થ થાય છે

425
00:33:06,000 --> 00:33:07,940
કે binky ની અંદર ચાલી રહ્યું છે.

426
00:33:07,940 --> 00:33:10,510
જો અમે આગામી વાપરવા માટે, પછી એનો અર્થ પર કાર્ય જાઓ

427
00:33:10,510 --> 00:33:14,070
અને અમારા મુખ્ય કામગીરીમાં કોડ આગળના વાક્ય પર જાઓ.

428
00:33:14,070 --> 00:33:17,900
અહીં આ વાક્ય પર, હું જ્યાં તે (રેન્ડ) 3% એ જણાવ્યું હતું;

429
00:33:17,900 --> 00:33:21,320
જો હું પગલું હતું ત્યારે તે રેન્ડ અમલીકરણ માં જશે

430
00:33:21,320 --> 00:33:25,110
અને શું ત્યાં ચાલી રહ્યું છે તે જોવા માટે, અને હું રેન્ડ કાર્ય મારફતે પગલું શકે છે.

431
00:33:25,110 --> 00:33:26,920
પરંતુ હું રેન્ડ કાર્ય વિશે કાળજી નથી.

432
00:33:26,920 --> 00:33:30,190
હું માત્ર મુખ્ય માં કોડ આગળના વાક્ય પર જાઓ કરવા માંગો છો, જેથી હું આગામી વાપરો.

433
00:33:30,190 --> 00:33:35,800
પરંતુ હવે હું binky કાર્ય વિશે કાળજી કરવા માટે, જેથી હું સ્ટેપ ઇનટુ કરવા માંગો છો.

434
00:33:35,800 --> 00:33:37,730
હવે હું binky છું.

435
00:33:37,730 --> 00:33:42,040
કોડ પ્રથમ વાક્ય કહી જો (i 0 ==), હું એક પગલું લઈ રહ્યું છે,

436
00:33:42,040 --> 00:33:44,930
અમે જુઓ અમે સોહામણું અંતે અંત.

437
00:33:44,930 --> 00:33:51,620
જો અમે યાદી વસ્તુઓ, અમે જુઓ કે તે ચકાસાયેલ મને છે = 0.

438
00:33:51,620 --> 00:33:55,470
મને 0 સમાન નથી, તેથી તે બીજા શરત ગયા,

439
00:33:55,470 --> 00:33:59,540
જે સુરેખ (i) કૉલ રહ્યું છે.

440
00:33:59,540 --> 00:34:04,030
તમે ગુંચવણ ના થવી શકે છે.

441
00:34:04,030 --> 00:34:07,380
જો તમે માત્ર આ રેખાઓ સીધી જુઓ, તમને લાગે શકે છે જો (i 0 ==),

442
00:34:07,380 --> 00:34:10,800
ઠીક, પછી હું પગલું ભર્યું હતું અને હવે હું સુરેખ (i) ખાતે છું,

443
00:34:10,800 --> 00:34:14,120
તમને લાગે છે કે તેનો અર્થ જ જોઈએ હું = 0 અથવા કંઈક.

444
00:34:14,120 --> 00:34:18,980
નંબર તે માત્ર અર્થ એ થાય કે તે જાણે છે કે તે સીધેસીધું લીટી સુરેખ (i) વળગી શકે છે.

445
00:34:18,980 --> 00:34:23,300
કારણ કે હું 0 નહિં હોય, તો આગળનું પગલું એ બીજું અંતે અંત નથી જઈ રહ્યા છે.

446
00:34:23,300 --> 00:34:26,239
બાકી એક વાક્ય તેને અંતે રોકવા રહ્યું છે નથી.

447
00:34:26,239 --> 00:34:31,570
તે માત્ર આગલા લીટી તે વાસ્તવમાં ચલાવો, કે જે સુઘડ છે (i) કરી શકો છો પર જાઓ બનશે.

448
00:34:31,570 --> 00:34:36,090
સુરેખ (i) માં વેગ, અમે જોવા (i 1 ==).

449
00:34:36,090 --> 00:34:42,670
અમે હું = 1 જાણતા નથી, તેથી અમે જ્યારે પગલું, અમે જાણીએ છીએ કે અમે માટે oh_no માં અંત જઈ રહ્યાં છો

450
00:34:42,670 --> 00:34:46,489
કારણ કે હું = 1 કામગીરી oh_no, કે જે તમને સ્ટેપ ઇનટુ કરી શકો છો કહે છે,

451
00:34:46,489 --> 00:34:52,969
જે સેટ થઈ રહ્યું છે ઘરનાં પરચૂરણ કામો ** ઓ = માટે NULL છે અને તરત જ "બૂમ".

452
00:34:54,270 --> 00:34:59,690
અને પછી ખરેખર buggy2 અમલીકરણ પર looking,

453
00:34:59,690 --> 00:35:04,590
0, 1, અથવા 2 - - કૉલિંગ binky, આ, હું માત્ર એક રેન્ડમ નંબર રહ્યો છે

454
00:35:04,590 --> 00:35:10,610
જે જો હું 0 છે તે oh_no કહે છે, બીજું તે સુઘડ કહે છે, જે અહીં આવે છે.

455
00:35:10,610 --> 00:35:18,100
જો હું એ 1, કોલ oh_no, બીજું slinky કહી છે, કે જે અહીં આવતા,

456
00:35:18,100 --> 00:35:20,460
જો હું 2 છે, oh_no કૉલ કરો.

457
00:35:20,460 --> 00:35:24,720
હું પણ ત્યાં એક માર્ગ છે લાગતું નથી -

458
00:35:24,720 --> 00:35:30,030
શું કોઇને એક કાર્યક્રમ છે કે જે નથી segfault કરશે આ બનાવવા એક માર્ગ જુઓ છો?

459
00:35:30,030 --> 00:35:37,530
કારણ કે જ્યાં સુધી હું કંઈક ખૂટે છું, જો હું 0 છે, તમને તુરંત જ segfault પડશે,

460
00:35:37,530 --> 00:35:41,250
બીજું તમે એક કાર્ય છે, જે જો હું એ 1 તમે segfault પર જાઓ,

461
00:35:41,250 --> 00:35:44,540
બીજું તમે એક કાર્ય જ્યાં જો હું છે 2 તમે segfault પર જાઓ.

462
00:35:44,540 --> 00:35:46,810
તેથી કોઇ વાંધો નથી કે તમે શું કરો છો, તમે segfault.

463
00:35:46,810 --> 00:35:52,380
>> હું સુધારવા તે ચાર રચે છે ** ઓ = NULL કરી બદલે હોય એક માર્ગ, અનુમાન

464
00:35:52,380 --> 00:35:55,610
તમે કે જેઓ શબ્દમાળા માટે જગ્યા malloc શકે છે.

465
00:35:55,610 --> 00:36:04,230
Sizeof શું - અમે (sizeof) malloc કરી શકે?

466
00:36:09,910 --> 00:36:15,190
[વિદ્યાર્થી] (કોલસો) 5 *? >> આ અધિકાર લાગતું નથી?

467
00:36:15,190 --> 00:36:21,060
હું એમ ધારી રહ્યા છીએ છું આ તો હું ખરેખર તે ચાલી હતી કામ કરશે, પરંતુ તે હું શું શોધી રહ્યો છું નથી.

468
00:36:24,400 --> 00:36:32,940
ઓ ના પ્રકાર જુઓ. ચાલો પૂર્ણાંક * ઉમેરો, જેથી પૂર્ણાંક * એક્સ.

469
00:36:32,940 --> 00:36:35,600
હું malloc કરવું (sizeof (પૂર્ણાંક)) કરશે.

470
00:36:35,600 --> 00:36:40,490
અથવા જો હું 5 ઝાકઝમાળ માગતા હતા, હું ((પૂર્ણાંક) sizeof 5 *) કરી શકે છે;

471
00:36:40,490 --> 00:36:44,210
જો હું પૂર્ણાંક ** છે?

472
00:36:46,260 --> 00:36:49,140
હું શું થશે malloc?

473
00:36:49,140 --> 00:36:53,510
[વિદ્યાર્થી] પોઇન્ટર કદ. >> યાહ. (Sizeof (પૂર્ણાંક *));

474
00:36:53,510 --> 00:36:56,960
નીચે અહીં જ વાત.

475
00:36:56,960 --> 00:37:01,280
હું માંગો છો (sizeof (કોલસો) *);

476
00:37:06,170 --> 00:37:12,840
આ નિર્દેશક કે "તેજી" નિર્દેશ માટે જગ્યા ફાળવી રહ્યું છે.

477
00:37:12,840 --> 00:37:15,330
હું "બૂમ" પોતાના માટે જગ્યા ફાળવી જરૂર નથી

478
00:37:15,330 --> 00:37:17,210
કારણ કે આ મૂળભૂત હું શું પહેલાં જણાવ્યું હતું કે સમકક્ષ છે

479
00:37:17,210 --> 00:37:20,870
ઘરનાં પરચૂરણ કામો ઓફ * x = "તેજી".

480
00:37:20,870 --> 00:37:27,950
"બૂમ" પહેલાથી જ અસ્તિત્વમાં છે. તે મેમરી વિસ્તારમાં માત્ર વાંચી અસ્તિત્વ બને છે.

481
00:37:27,950 --> 00:37:35,200
પરંતુ તે પહેલેથી જ અસ્તિત્વમાં છે, કે જે કોડ આ વાક્ય અર્થ થાય છે, જો ઓ ચાર રચે છે ** છે,

482
00:37:35,200 --> 00:37:43,900
પછી * ઓ ચાર રચે છે * છે અને તમે આ ઘરનાં પરચૂરણ કામો * સુયોજિત કરી રહ્યા છીએ "બૂમ" નિર્દેશિત કરવા માટે.

483
00:37:43,900 --> 00:37:50,040
જો હું ઓ માં "બૂમ" નકલ કરવા માગે છે, તો પછી હું ઓ માટે જગ્યા ફાળવી જરૂર છે.

484
00:37:55,170 --> 00:38:03,900
હું કરીશ * ઓ malloc = (sizeof (કોલસો) 5 *);

485
00:38:03,900 --> 00:38:06,210
શા 5?

486
00:38:06,210 --> 00:38:10,860
શા માટે 4 નથી? એવું લાગે છે કે "બૂમ" 4 અક્ષરો છે. >> [વિદ્યાર્થી] આ નલ પાત્ર.

487
00:38:10,860 --> 00:38:14,580
યાહ. તમારા શબ્દમાળાઓ માટે તમામ નલ અક્ષર જરૂર જવું છે.

488
00:38:14,580 --> 00:38:23,590
હવે હું strcat કંઈક કરી શકો છો - એક શબ્દમાળા નકલ માટે કાર્ય શું છે?

489
00:38:23,590 --> 00:38:28,520
[વિદ્યાર્થી] cpy? >> Strcpy.

490
00:38:28,520 --> 00:38:32,700
માણસ strcpy.

491
00:38:36,120 --> 00:38:39,590
તેથી strcpy અથવા strncpy.

492
00:38:39,590 --> 00:38:43,410
strncpy થોડી સુરક્ષિત છે કારણ કે તમે સ્પષ્ટ કરી શકો છો ચોક્કસ કેટલી અક્ષરો,

493
00:38:43,410 --> 00:38:46,190
પરંતુ અહીં તેને કારણે આપણે જાણીએ છીએ તો કોઈ વાંધો નથી.

494
00:38:46,190 --> 00:38:50,340
તેથી strcpy અને દલીલો માં જુઓ.

495
00:38:50,340 --> 00:38:53,100
પ્રથમ દલીલ અમારા સ્થળ છે.

496
00:38:53,100 --> 00:38:56,770
બીજી દલીલ અમારા સ્ત્રોત છે.

497
00:38:56,770 --> 00:39:10,310
અમે અમારી ગંતવ્ય * કૉપિ જઈ રહ્યાં છો તે નિર્દેશક "બૂમ" ઓ.

498
00:39:10,310 --> 00:39:19,820
તમે માત્ર શું આપણે બદલે strcpy સાથે આ પહેલા શા શકો છો

499
00:39:19,820 --> 00:39:22,800
* s ની = "તેજી?"

500
00:39:22,800 --> 00:39:28,630
ત્યાં એક કારણ તમે આ કરવા માંગો છો શકે છે, પરંતુ તે કારણ શું છે?

501
00:39:28,630 --> 00:39:31,940
[વિદ્યાર્થી] જો તમે "તેજી" માં કંઈક ફેરફાર કરવા માંગો છો. >> યાહ.

502
00:39:31,940 --> 00:39:37,950
હવે હું ઓ કંઈક કરી શકે છે [0] = 'એક્સ' ';

503
00:39:37,950 --> 00:39:48,190
કારણ કે ઓ પોઇન્ટ અને ઢગલો પર જગ્યા ઢગલો કે ઓ તરફ ઇશારો છે

504
00:39:48,190 --> 00:39:52,320
આ ઢગલો છે, કે જે "બૂમ" સ્ટોર કરે છે તેના પર વધુ જગ્યા માટે એક નિર્દેશક છે.

505
00:39:52,320 --> 00:39:55,150
તેથી "બૂમ" આ નકલ ઢગલો કરવામાં સંગ્રહાયેલ છે.

506
00:39:55,150 --> 00:39:58,780
ત્યાં તકનિકી છે અમારી પ્રોગ્રામ માં "તેજી" બે નકલો.

507
00:39:58,780 --> 00:40:03,500
ત્યાં પ્રથમ એક કે જે હમણાં જ આ "તેજી" શબ્દમાળા સતત દ્વારા આપવામાં આવ્યું છે તે છે,

508
00:40:03,500 --> 00:40:09,250
અને "તેજી" બીજા નકલ, strcpy "બૂમ" ની નકલ બનાવી.

509
00:40:09,250 --> 00:40:13,100
પરંતુ "તેજી" ના નકલ ઢગલો પર આવી રહી સંગ્રહિત થાય છે, અને ઢગલો તમે બદલવા મુક્ત છો.

510
00:40:13,100 --> 00:40:17,250
આ ઢગલો ફક્ત વાંચવા માટે નથી, કે જેથી અર્થ એ થાય કે ઓ [0]

511
00:40:17,250 --> 00:40:20,500
છે જેનાથી તમે "તેજી" ની કિંમત બદલવા જઈ રહી છે.

512
00:40:20,500 --> 00:40:23,130
તે તમને તે અક્ષરો બદલી રહ્યું છે.

513
00:40:23,130 --> 00:40:26,640
>> પ્રશ્નો?

514
00:40:27,740 --> 00:40:29,290
ઠીક છે.

515
00:40:29,290 --> 00:40:35,500
>> Buggy3 પર ખસેડવું, લેટ્સ gdb buggy3.

516
00:40:35,500 --> 00:40:39,840
અમે હમણાં જ તેને ચલાવવા અને અમે જોઈ અમે segfault મેળવો.

517
00:40:39,840 --> 00:40:46,550
બેકસ્ટ્રેસ અમે જો, ત્યાં માત્ર બે કાર્યો છે.

518
00:40:46,550 --> 00:40:52,970
જો અમે અમારી મુખ્ય કાર્ય માં અપ જાઓ, અમે જુઓ કે જે આપણે આ વાક્ય પર segfaulted.

519
00:40:52,970 --> 00:41:00,180
તેથી ફક્ત આ વાક્ય પર looking, (માટે પૂર્ણાંક રેખા = 0; fgets આ સામગ્રીને સમાન NULL કરે છે;

520
00:41:00,180 --> 00:41:03,770
રેખા + +).

521
00:41:03,770 --> 00:41:08,010
અમારા અગાઉના ફ્રેમ _IO_fgets તરીકે ઓળખાતું હતું.

522
00:41:08,010 --> 00:41:10,720
તમે જોશો કે આંતરિક સી વિધેયો સાથે ઘણો,

523
00:41:10,720 --> 00:41:15,350
કે જ્યારે તમે segfault વિચાર, ત્યાં ખરેખર ભેદી કાર્ય નામો હશે

524
00:41:15,350 --> 00:41:18,090
આ _IO_fgets જેવા હોય છે.

525
00:41:18,090 --> 00:41:21,770
પરંતુ આ fgets કોલ સંબંધિત બનશે.

526
00:41:21,770 --> 00:41:25,850
અહીં અંદર ક્યાંક, અમે segfaulting છે.

527
00:41:25,850 --> 00:41:30,340
જો અમે દલીલો અંતે fgets નજર, અમે બફર છાપી શકો છો.

528
00:41:30,340 --> 00:41:41,180
ચાલો છાપો એક તરીકે - ઓહ, નો.

529
00:41:48,980 --> 00:41:51,900
પ્રિન્ટ માટે બરાબર તરીકે હું તેને કરવા માંગો છો કામ નથી જઈ રહ્યા છે.

530
00:41:55,460 --> 00:41:58,000
ચાલો વાસ્તવિક કાર્યક્રમ જુઓ.

531
00:42:02,200 --> 00:42:09,640
બફર એક અક્ષર એરે છે. તે 128 અક્ષરો, એક અક્ષર એરે છે.

532
00:42:09,640 --> 00:42:14,980
તેથી જ્યારે હું પ્રિન્ટ બફર કહે છે, તે માટે તે 128 અક્ષરો છાપો ચાલી રહ્યું છે,

533
00:42:14,980 --> 00:42:18,300
હું માનું છે કે જે શું અપેક્ષા છે.

534
00:42:18,300 --> 00:42:21,390
હું શોધી હતી શું છે બફર ની સરનામા છાપો,

535
00:42:21,390 --> 00:42:23,680
પરંતુ ખરેખર મને કહી ખૂબ નથી.

536
00:42:23,680 --> 00:42:30,770
તેથી જ્યારે હું અપ એક્સ બફર અહીં કહેવું થાય છે, તે મને 0xbffff090 બતાવે છે,

537
00:42:30,770 --> 00:42:38,690
જે, જો તમે પહેલાં અથવા અમુક બિંદુ પરથી યાદ રાખો કે, Oxbffff એક પ્રદેશ સ્ટેક-જેવું હોય છે.

538
00:42:38,690 --> 00:42:46,020
આ સ્ટેકમાંથી 0xc000 હેઠળ માત્ર ક્યાંક શરૂ કરે છે.

539
00:42:46,020 --> 00:42:51,890
આ સરનામા જોયા દ્વારા જસ્ટ, હું જાણું છું કે બફર સ્ટેક પર ચાલી રહ્યું છે.

540
00:42:51,890 --> 00:43:04,500
મારા કાર્યક્રમ પુનઃશરૂ કરી રહ્યા છીએ, ચલાવો, અપ બફર અમે જોયો હતો અક્ષરો આ ક્રમ

541
00:43:04,500 --> 00:43:06,530
કે ખૂબ ખૂબ અર્થહીન છે.

542
00:43:06,530 --> 00:43:12,270
પછી ફાઈલ છાપવા, ફાઇલ શું લાગતું નથી?

543
00:43:15,120 --> 00:43:17,310
[વિદ્યાર્થી] નલ. >> યાહ.

544
00:43:17,310 --> 00:43:22,610
ફાઇલ પ્રકાર છે FILE * એક છે, તેથી તે નિર્દેશક છે,

545
00:43:22,610 --> 00:43:26,610
અને તે નિર્દેશક મૂલ્ય નલ છે.

546
00:43:26,610 --> 00:43:33,240
તેથી fgets માટે એક પરોક્ષ રીતે કે નિર્દેશક માંથી વાંચી પ્રયાસ રહ્યું છે,

547
00:43:33,240 --> 00:43:37,320
પરંતુ ક્રમમાં કે નિર્દેશક ઍક્સેસ કરવા માટે, તેને ડિરેફરન્સ માટે છે.

548
00:43:37,320 --> 00:43:40,550
અથવા, ક્રમમાં વાપરવા માટે તે શું છે, તે dereferences પોઇન્ટ જોઇએ.

549
00:43:40,550 --> 00:43:43,810
તો તેને એક નલ નિર્દેશક અને તે segfaults dereferencing છે.

550
00:43:46,600 --> 00:43:48,730
હું તે છે ત્યાં પુનઃશરૂ કરી શકે છે.

551
00:43:48,730 --> 00:43:52,170
જો અમે અમારી મુખ્ય બિંદુ પર તોડી અને ચલાવવા માટે,

552
00:43:52,170 --> 00:43:57,320
કોડ પ્રથમ વાક્ય ઘરનાં પરચૂરણ કામો * ફાઈલનામ = "nonexistent.txt" છે;

553
00:43:57,320 --> 00:44:00,870
કે શા માટે આ કાર્યક્રમ નિષ્ફળ જાય તરીકે એક સુંદર મોટી સંકેતની આપવી જોઇએ.

554
00:44:00,870 --> 00:44:06,080
આગામી લખીને મને આગામી રેખા પર લઈ આવે છે, જ્યાં હું આ ફાઈલ ખોલવા માટે,

555
00:44:06,080 --> 00:44:11,140
અને પછી હું તરત જ અમારી વાક્ય છે, જ્યાં એક વાર હું આગામી ફટકો પ્રવેશ મેળવવા, તે segfault બનશે.

556
00:44:11,140 --> 00:44:16,880
શું કોઇને માટે એક કારણ અમે segfaulting હોઈ શકે કાઢી નાખવા માંગો છો?

557
00:44:16,880 --> 00:44:19,130
[વિદ્યાર્થી] ફાઈલ અસ્તિત્વમાં નથી. >> યાહ.

558
00:44:19,130 --> 00:44:22,250
આ સંકેત હશે તેવું માનવામાં આવે છે

559
00:44:22,250 --> 00:44:29,570
કે તમે જ્યારે ફાઈલ ખોલવા કરી રહ્યા છો તમે તપાસો કે ફાઇલ ખરેખર અસ્તિત્વમાં જરૂર છે.

560
00:44:29,570 --> 00:44:31,510
અહીં, "nonexistent.txt";

561
00:44:31,510 --> 00:44:34,700
જ્યારે અમે વાંચન માટે fopen ફાઇલનામ, અમે પછી કહેવું જરૂર

562
00:44:34,700 --> 00:44:45,870
જો અને ફાઇલ (NULL ==) કહે છે printf ("ફાઈલ અસ્તિત્વમાં નથી!"

563
00:44:45,870 --> 00:44:56,340
અથવા - હજુ સુધી સારી રીતે - ફાઈલનામ); 1 વળતર;

564
00:44:56,340 --> 00:45:00,300
તેથી હવે અમે જોવા માટે જો તે NULL છે તપાસ

565
00:45:00,300 --> 00:45:03,930
પહેલાં ખરેખર ચાલુ રાખવા માટે અને તે ફાઇલ વાંચવામાં પ્રયાસ કરે છે.

566
00:45:03,930 --> 00:45:08,800
અમે તેને રિમેક માત્ર કે જે કામો જોવા માટે કરી શકો છો.

567
00:45:11,020 --> 00:45:14,970
હું એક નવી લાઇન સમાવેશ કરવાનો હતો.

568
00:45:21,090 --> 00:45:25,290
તેથી હવે nonexistent.txt અસ્તિત્વમાં નથી.

569
00:45:26,890 --> 00:45:30,040
તમે હંમેશા વસ્તુ આ પ્રકારની તપાસ માટે કરીશું.

570
00:45:30,040 --> 00:45:33,870
તમે હંમેશા જોવા માટે જો fopen NULL આપે તપાસ કરીશું.

571
00:45:33,870 --> 00:45:38,170
તમે હંમેશા ખાતરી કરો કે malloc NULL નહિં આપે તેની ખાતરી કરવા તપાસો જોઈએ,

572
00:45:38,170 --> 00:45:41,410
અથવા તો તમે segfault.

573
00:45:42,200 --> 00:45:45,930
>> હવે buggy4.c.

574
00:45:49,190 --> 00:45:58,440
ચાલી રહ્યું છે. હું આ અનુમાન લગાવવા છું છે ઇનપુટ અથવા કદાચ અનંત રહ્યાં પ્રતીક્ષામાં છે.

575
00:45:58,440 --> 00:46:01,870
હા, તેને અનંત રહ્યાં છે.

576
00:46:01,870 --> 00:46:05,560
Buggy4 તેથી. એવું લાગે છે કે અમે અનંત રહ્યાં છો.

577
00:46:05,560 --> 00:46:12,590
અમે મુખ્ય અંતે તોડી શકે છે, અમારા કાર્યક્રમ ચલાવો.

578
00:46:12,590 --> 00:46:20,180
Gdb માં, લાંબા તરીકે સંક્ષેપ તમે ઉપયોગ અસંદિગ્ધ છે

579
00:46:20,180 --> 00:46:23,420
અથવા ખાસ સંક્ષેપ કે તેઓ તમારા માટે પૂરી પાડે છે,

580
00:46:23,420 --> 00:46:29,020
પછી તમે n નો ઉપયોગ કરવા માટે આગામી બધી રીતે ટાઇપ કર્યા બદલે આગામી વાપરી શકો છો.

581
00:46:29,020 --> 00:46:33,730
અને હવે હું ફટકો n એ કર્યું છે એકવાર, હું હમણાં જ દાખલ હિટ આગામી જઈને રાખી શકો છો

582
00:46:33,730 --> 00:46:36,640
તેના બદલે ફટકો n દાખલ કરો, n દાખલ કરો, n દાખલ કર્યા છે.

583
00:46:36,640 --> 00:46:44,630
એવું લાગે છે કે હું લૂપ કે એરે [i] 0 માટે સુયોજિત છે માટે કેટલાક પ્રકારની છું.

584
00:46:44,630 --> 00:46:50,510
એવું લાગે છે કે હું લૂપ માટે ક્યારેય ભંગ કરું છું આ.

585
00:46:50,510 --> 00:46:54,780
જો હું મને છાપો, જેથી હું 2 છે, પછી હું આગામી જવા પડશે.

586
00:46:54,780 --> 00:46:59,250
હું મને છાપો મને 3 છે, પછી મળશે હું આગામી જવા પડશે.

587
00:46:59,250 --> 00:47:05,360
હું મને છાપી અને હું 3 કરીશું. આગળ, હું છાપો, હું 4 છે.

588
00:47:05,360 --> 00:47:14,520
ખરેખર, પ્રિન્ટ (એરે) sizeof, તેથી એરે કદ 20 છે.

589
00:47:16,310 --> 00:47:32,870
પરંતુ લાગે છે કે ત્યાં જઈને ત્યાં સુધી કંઈક થાય છે માટે અમુક ખાસ gdb આદેશ છે.

590
00:47:32,870 --> 00:47:37,620
તે ચલની કિંમત પર શરત સુયોજિત જેવું છે. પરંતુ હું યાદ નથી કે તે શું છે.

591
00:47:37,620 --> 00:47:44,100
તેથી જો આપણે જઈને રાખો -

592
00:47:44,100 --> 00:47:47,120
તમે શું કહી હતી? તમે શું લાવ્યો?

593
00:47:47,120 --> 00:47:50,500
>> યાહ - [વિદ્યાર્થી] પ્રદર્શિત હું શું ઉમેરો. તેથી પ્રદર્શિત મને મદદ કરી શકો છો.

594
00:47:50,500 --> 00:47:54,530
જો અમે માત્ર હું દર્શાવવા માટે, તે અહીં મૂકો i ની કિંમત શું છે

595
00:47:54,530 --> 00:47:56,470
તેથી હું તેને છાપી બહાર દરેક સમય નથી.

596
00:47:56,470 --> 00:48:02,930
જો અમે માત્ર આગામી ચાલુ રાખવામાં, અમે 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5 જુઓ.

597
00:48:02,930 --> 00:48:08,530
કંઈક ખોટું ભયંકર રહ્યું છે, અને મને 0 રહી ફરીથી સેટ છે.

598
00:48:13,330 --> 00:48:22,220
Buggy4.c અંતે છીએ, અમે જોવા તમામ આવું થાય પૂર્ણાંક એરે [5] છે;

599
00:48:22,220 --> 00:48:26,200
(; i <= (એરે) sizeof; i + + હું = 0) માટે

600
00:48:26,200 --> 00:48:28,550
એરે [i] = 0;

601
00:48:28,550 --> 00:48:31,390
અમે શું નથી કે ખોટું અહીં છે?

602
00:48:31,390 --> 00:48:39,480
સંકેત તરીકે, જ્યારે હું buggy4 gdb કરી હતી - ચાલો મુખ્ય રન, ભંગ -

603
00:48:39,480 --> 00:48:45,980
હું પ્રિન્ટ sizeof (એરે) માત્ર જોવા માટે તેણે શરત શું છે જ્યાં હું આખરે ભંગ કરીશું.

604
00:48:47,690 --> 00:48:51,100
હું ક્યાં છું? શું હું સ્કોર?

605
00:48:51,100 --> 00:48:54,280
હું હજુ સુધી જાહેર ન હતી.

606
00:48:54,280 --> 00:48:58,680
તેથી sizeof (એરે) છાપો અને તે 20 છે,

607
00:48:58,680 --> 00:49:06,690
જે ત્યારથી મારા એરે 5 કદ છે તેવી અપેક્ષા છે અને તે 5 પૂર્ણાંકોના છે,

608
00:49:06,690 --> 00:49:12,410
જેથી સમગ્ર વસ્તુ 5 * sizeof (પૂર્ણાંક) બાઇટ્સ, જ્યાં sizeof (પૂર્ણાંક) માટે 4 હોઇ શકે છે પ્રયત્ન કરીશું.

609
00:49:12,410 --> 00:49:14,780
તેથી sizeof (એરે) 20 છે.

610
00:49:14,780 --> 00:49:17,420
આ શું હોવું જોઈએ?

611
00:49:17,420 --> 00:49:21,720
[વિદ્યાર્થી] sizeof (પૂર્ણાંક) દ્વારા વિભાજિત. >> અરે વાહ, / sizeof (પૂર્ણાંક).

612
00:49:21,720 --> 00:49:30,630
એવું લાગે છે કે હજી પણ એક સમસ્યા છે અહીં. મને લાગે છે કે આ માત્ર પ્રયત્ન કરીશું <

613
00:49:30,630 --> 00:49:36,960
કારણ કે તે ખૂબ સુંદર હંમેશા <અને = <નથી.

614
00:49:36,960 --> 00:49:44,860
હવે આપણે શા માટે આ ખરેખર ભાંગી હતી વિશે વિચારો.

615
00:49:44,860 --> 00:49:53,370
શું કોઇને ધારી શા માટે કરવામાં આવી હતી છે મને લૂપ દરેક ઇટરેશન મારફતે 0 પુનઃસુયોજિત કરવા માટે?

616
00:50:01,300 --> 00:50:09,350
અહીં કે ચાલી રહ્યું છે તે અંદર જ વસ્તુ છે કે જે એરે [i] 0 રહી સેટ છે.

617
00:50:09,350 --> 00:50:15,350
જેથી કોઈક, કોડના આ વાક્ય અમારા પૂર્ણાંક રહી છે મને 0 થી સુયોજિત કરવા માટે.

618
00:50:16,730 --> 00:50:23,130
[વિદ્યાર્થી] તે કારણ કે તે મને આ ભાગ મેમરી ઓવરરાઈડીંગ છે પ્રયત્ન કરી શકાયું નથી

619
00:50:23,130 --> 00:50:27,970
જ્યારે તે વિચારે છે તે એરે આગળના તત્વ છે? >> [બોડેન] હા.

620
00:50:27,970 --> 00:50:33,880
, જ્યારે અમે અમારા એરે ઓવરને બહાર જઈ રહ્યાં છો

621
00:50:33,880 --> 00:50:39,870
કોઈક કે જે જગ્યા છે કે અમે ઓવરરાઈડીંગ કરી રહ્યાં છો i ની કિંમત ઓવરરાઈડીંગ છે.

622
00:50:39,870 --> 00:50:48,030
અને તેથી જો આપણે buggy4 તપાસ, મુખ્ય રન, ભંગ

623
00:50:48,030 --> 00:50:53,120
ચાલો i ની સરનામા છાપો.

624
00:50:53,120 --> 00:50:57,280
એવું લાગે છે કે તે bffff124 છે.

625
00:50:57,280 --> 00:51:03,930
હવે આપણે ઍરેના સરનામા છાપો. [0] 110.

626
00:51:03,930 --> 00:51:06,290
શું [1] શું? 114.

627
00:51:06,290 --> 00:51:07,920
[2], 118.

628
00:51:07,920 --> 00:51:14,530
11c, 120. [5] એરે bfff124 છે.

629
00:51:14,530 --> 00:51:26,990
અરે તેથી [5] આઇ, જેનો અર્થ છે કે એરે [5] હું છે તે જ સરનામાં હોય છે.

630
00:51:26,990 --> 00:51:30,720
જો તેઓ તે જ સરનામાં હોય છે, તેઓ તે જ વસ્તુ છે.

631
00:51:30,720 --> 00:51:38,410
તેથી જ્યારે અમે [5] એરે સુયોજિત 0 થી, અમે આઈ 0 થી સુયોજિત કરી રહ્યા હોય.

632
00:51:38,410 --> 00:51:46,070
અને જો તમે સ્ટેક દ્રષ્ટિએ આ વિશે વિચારો,

633
00:51:46,070 --> 00:51:55,590
પૂર્ણાંક હું પ્રથમ જાહેર કરવામાં આવે છે, જેનો અર્થ છે મને સ્ટેક પર અમુક જગ્યા નોંધાયો નહીં.

634
00:51:55,590 --> 00:52:04,730
પછી [5] એરે ફાળવવામાં આવે છે, જેથી તે પછી 20 બાઇટ્સ સ્ટેક પર ફાળવવામાં આવે છે.

635
00:52:04,730 --> 00:52:08,400
તેથી હું પ્રથમ ફાળવવામાં નહીં, તો પછી આ 20 બાઇટ્સ ફાળવવામાં છે.

636
00:52:08,400 --> 00:52:11,400
તેથી હું એરે પહેલાં અધિકાર થાય છે,

637
00:52:11,400 --> 00:52:19,230
અને એ છે કે, છેલ્લા અઠવાડિયે જેમ હું જણાવ્યું હતું કે, જ્યાં ટેકનિકલી સ્ટેક નીચે ઊગે છે,

638
00:52:19,230 --> 00:52:28,520
જ્યારે તમે એરે માં અનુક્રમણિકા, અમે ખાતરી આપી છે કે જે એરે માં 0th સ્થિતિ

639
00:52:28,520 --> 00:52:31,970
હંમેશા એરે માં પ્રથમ સ્થાન પહેલાં થાય છે.

640
00:52:31,970 --> 00:52:35,900
આ કેવી રીતે હું છેલ્લા અઠવાડિયામાં તે દોર્યું પ્રકારની છે.

641
00:52:35,900 --> 00:52:42,210
નોંધ કરો કે તળિયે અમે 0 સરનામા હોય છે અને ટોચ પર અમે સરનામા મેક્સ છે.

642
00:52:42,210 --> 00:52:44,880
સ્ટેક હંમેશાં નીચે વધી રહી છે.

643
00:52:48,100 --> 00:52:53,500
હવે કહો કે અમે હું ફાળવો.

644
00:52:53,500 --> 00:52:59,680
અમે પૂર્ણાંક ફાળવવા આઇ, જેનો અર્થ થાય છે ચાલો હમણાં પૂર્ણાંક અહીં હું ફાળવવામાં નહીં કહો.

645
00:52:59,680 --> 00:53:06,420
તો પછી અમે 5 પૂર્ણાંકો અમારી એરે, કે જે નીચે તેનો અર્થ એ કે ફાળવણી,

646
00:53:06,420 --> 00:53:11,230
કારણ કે સ્ટેક નીચે વધતી જાય છે, તે 5 પૂર્ણાંકો ફાળવવામાં છે.

647
00:53:11,230 --> 00:53:15,900
પરંતુ કેવી રીતે એરે કામ કારણ કે, અમે ખાતરી આપી રહ્યાં છો કે જે એરે માં પ્રથમ સ્થાન

648
00:53:15,900 --> 00:53:22,260
હંમેશા એરે બીજી વસ્તુ કરતાં ઓછી સરનામા ધરાવે છે.

649
00:53:22,260 --> 00:53:28,270
તેથી એરે સ્થિતિ 0 હંમેશા મેમરી પ્રથમ થાય છે,

650
00:53:28,270 --> 00:53:30,700
જ્યારે એરે 1 સ્થિતિ કે પછી થાય છે

651
00:53:30,700 --> 00:53:33,310
અને એરે 2 પદ કે પછી થાય છે,

652
00:53:33,310 --> 00:53:37,900
જેનો અર્થ છે કે એરે સ્થિતિ 0 ક્યાંક નીચે અહીં શું થશે,

653
00:53:37,900 --> 00:53:40,690
એરે 1 પોઝિશન કે ઉપર શું થશે

654
00:53:40,690 --> 00:53:45,530
કારણ કે અપ ખસેડવાની ઉચ્ચ સરનામાં અર્થ થાય છે કારણ કે મહત્તમ સરનામા અહીં છે.

655
00:53:45,530 --> 00:53:50,490
[0] નીચે અહીં એરે તેથી, અરે [1] અહીં, અરે [2] અહીં, [3] એરે અહીં છે.

656
00:53:50,490 --> 00:53:55,620
નોટિસ પહેલાં અમે કેવી રીતે પૂર્ણાંક મને બધા અહીં માર્ગ ફાળવવામાં,

657
00:53:55,620 --> 00:54:01,040
અમે અમારા એરે આગળ અને આગળ ખસેડવા માટે, અમે નજીક અને અમારા પૂર્ણાંક હું નજીક મેળવવામાં આવે છે.

658
00:54:01,040 --> 00:54:07,640
તે માત્ર જેથી એરે થાય છે [5], જે આપણા એરે બહાર એક પદ છે,

659
00:54:07,640 --> 00:54:13,010
બરાબર પૂર્ણાંક જ્યાં i માટે ફાળવણી કરવામાં થયું છે.

660
00:54:13,010 --> 00:54:16,920
જેથી બિંદુ જ્યાં અમે સ્ટેક પર જગ્યા હિટ શકાય થાય છે

661
00:54:16,920 --> 00:54:21,680
કે પૂર્ણાંક i માટે ફાળવવામાં આવ્યો હતો, અને અમે તે 0 થી સુયોજિત કરી રહ્યાં છો.

662
00:54:21,680 --> 00:54:26,160
>> કે કેવી રીતે કામ કરે છે. પ્રશ્નો? યાહ.

663
00:54:26,160 --> 00:54:30,710
[વિદ્યાર્થી] કશો વાંધો નહીં. ઠીક છે.

664
00:54:30,710 --> 00:54:33,090
[વિદ્યાર્થી] તમે ભૂલો આ પ્રકારના કેવી રીતે બચું?

665
00:54:33,090 --> 00:54:41,190
ભૂલો આ પ્રકારની? તમારા પ્રોગ્રામિંગ ભાષા તરીકે ઉપયોગ કરશો નહીં. C

666
00:54:41,190 --> 00:54:45,840
એક ભાષા કે એરે ચકાસણી બાઉન્ડ્સ છે વાપરો.

667
00:54:45,840 --> 00:54:55,900
સુધી તમે કાળજી કરશો, તમે ફક્ત તમારા એરે સીમાડાં ભૂતકાળમાં જઈને ટાળવા જરૂર છે.

668
00:54:55,900 --> 00:54:58,300
[વિદ્યાર્થી] તેથી અહીં જ્યારે અમે તમારા એરે સીમાડાં ભૂતકાળમાં થયું હતું -

669
00:54:58,300 --> 00:55:01,840
[બોડેન] કે જ્યાં વસ્તુઓ ખોટી જઈને શરૂ કરો. >> [વિદ્યાર્થી] ઓહ, ઠીક છે.

670
00:55:01,840 --> 00:55:05,730
સુધી તમે તમારા એરે માટે ફાળવવામાં મેમરી અંદર રહેવાની, તમે દંડ છો.

671
00:55:05,730 --> 00:55:12,400
પરંતુ સી કોઈ ભૂલ ચકાસણી કરે છે. જો હું એરે કરવું [1000], તે રાજીખુશીથી માત્ર સુધારવા ગમે થાય છે કરશે -

672
00:55:12,400 --> 00:55:16,500
તે એરે શરૂઆત જાય, પછી તે પછી 1000 સ્થિતિ જાય છે અને તે સુયોજિત કરે છે 0 થી.

673
00:55:16,500 --> 00:55:20,000
તેને કોઈપણ ચકાસણી કે ઓહ, આ ખરેખર તેને 1000 વસ્તુઓ નથી કરતું નથી.

674
00:55:20,000 --> 00:55:22,750
1000 હું શું બદલવા જોઇએ આગળ રસ્તો છે,

675
00:55:22,750 --> 00:55:26,940
જ્યારે જાવા અથવા કંઈક તમે એરે સીમાથી અનુક્રમણિકા બહાર મળશે

676
00:55:26,940 --> 00:55:29,820
અથવા કિનારીઓ અપવાદ બહાર ઇન્ડેક્સ.

677
00:55:29,820 --> 00:55:33,950
કે શા માટે ઉચ્ચ કક્ષાની ભાષાઓ ઘણો આ બધી વસ્તુઓ છે

678
00:55:33,950 --> 00:55:37,340
જ્યાં જો તમે એરે ફરી વસ્તીની સીમાથી દૂર જાય છે, તમે નિષ્ફળ

679
00:55:37,340 --> 00:55:40,070
જેથી તમે વસ્તુઓ તમે નીચે માંથી બદલી શકો છો

680
00:55:40,070 --> 00:55:42,590
અને પછી વસ્તુઓ માત્ર અપવાદ મેળવવામાં કરતાં ઘણા ખરાબ જાઓ

681
00:55:42,590 --> 00:55:44,940
કહે છે કે તમે એરે ઓવરને બહાર ગયા હતા.

682
00:55:44,940 --> 00:55:50,970
[વિદ્યાર્થી] અને તેથી અમે ફક્ત બદલવા જોઈએ છે <= માત્ર <? >> [બોડેન] યાહ.

683
00:55:50,970 --> 00:55:54,800
તે <(એરે) sizeof / sizeof (પૂર્ણાંક) હોવી જોઇએ;

684
00:55:54,800 --> 00:55:59,560
ત્યારથી sizeof (એરે) 20 છે, પરંતુ અમે ફક્ત 5 માંગો છો. >> [વિદ્યાર્થી] અધિકાર.

685
00:55:59,560 --> 00:56:04,060
વધુ પ્રશ્નો છે? ઠીક છે.

686
00:56:04,060 --> 00:56:07,380
>> [વિદ્યાર્થી] હું એક પ્રશ્ન છે. >> યાહ.

687
00:56:07,380 --> 00:56:16,440
[વિદ્યાર્થી] વાસ્તવિક એરે ચલ શું છે?

688
00:56:16,440 --> 00:56:20,000
[બોડેન] જેમ શું એરે છે?

689
00:56:20,000 --> 00:56:24,930
પોતે અરે પ્રતીક છે.

690
00:56:24,930 --> 00:56:31,490
તે ફક્ત 20 બાઇટ્સ કે અમે સંદર્ભ છે શરૂઆત સરનામું છે.

691
00:56:31,490 --> 00:56:38,070
તમે તેને એક નિર્દેશક તરીકે લાગે શકે છે, પરંતુ તે સતત નિર્દેશક છે.

692
00:56:38,070 --> 00:56:44,140
જલદી વસ્તુઓ એકત્ર માટે, ચલ એરે હવે અસ્તિત્વમાં નથી.

693
00:56:44,140 --> 00:56:48,210
[વિદ્યાર્થી] તેથી તે કેવી રીતે એરે માપ શોધી નથી?

694
00:56:48,210 --> 00:56:54,130
અરે કદ કે બ્લોક માપ કે જે પ્રતીક સંદર્ભ લે ઉલ્લેખ કરે છે.

695
00:56:54,130 --> 00:57:01,240
જ્યારે હું printf કંઈક ("% પૃષ્ઠ \ n" એરે) ન કરો;

696
00:57:01,240 --> 00:57:05,140
ચાલો તે ચલાવો.

697
00:57:12,960 --> 00:57:15,530
હું શું માત્ર નહોતી ખોટું છે?

698
00:57:15,530 --> 00:57:19,220
અરે 'અરે' અહીં જાહેર કર્યું.

699
00:57:20,820 --> 00:57:23,200
ઓહ, અહીં.

700
00:57:23,200 --> 00:57:31,250
રણકાર હોંશિયાર છે, અને તે માટે નોટિસ કે હું 5 તત્વો તરીકે એરે જાહેર થાય છે

701
00:57:31,250 --> 00:57:34,540
પરંતુ હું 1000 સ્થિતિ માં ક્રમાંકિત છું.

702
00:57:34,540 --> 00:57:38,450
તે શું કારણ કે આ માત્ર સ્થિરાંકો છે કરી શકો છો.

703
00:57:38,450 --> 00:57:43,370
તે માત્ર ત્યારે જ ધ્યાનમાં લીધા કે હું એરે ફરી વસ્તીની સીમાથી દૂર જઈ રહ્યો છું માં અત્યાર સુધી જઈ શકે છે.

704
00:57:43,370 --> 00:57:46,880
પરંતુ જ્યારે આપણે હું ખોટો હોઈ પહેલાં નોટિસ,

705
00:57:46,880 --> 00:57:51,040
તે સંભવતઃ કેટલા કિંમતો મને લઇ શકે છે કે નહિં તે નક્કી કરી શકે છે,

706
00:57:51,040 --> 00:57:55,540
તેથી તે નક્કી કરી શકતા નથી કે હું એરે ઓવરને બહારના હતી.

707
00:57:55,540 --> 00:57:59,430
કે જે હમણાં જ હોંશિયાર હોવાથી રણકાર છે.

708
00:57:59,430 --> 00:58:03,340
>> પરંતુ હવે buggy4 બનાવે છે. તેથી બીજું શું હું ખોટું કરી રહ્યો છું?

709
00:58:03,340 --> 00:58:05,970
સર્વથા પુસ્તકાલય કાર્ય 'printf' જાહેર કર્યુ.

710
00:58:05,970 --> 00:58:14,960
હું # <stdio.h> સમાવેશ કરવા માંગો છો જાઉં છું.

711
00:58:14,960 --> 00:58:18,710
ઠીક છે. હવે buggy4 ચાલી રહ્યું છે.

712
00:58:18,710 --> 00:58:24,840
જેમ એરે ની કિંમત છાપવા હું અહીં આપી હતી, તે એક નિર્દેશક તરીકે છાપવા

713
00:58:24,840 --> 00:58:30,060
પ્રિન્ટ કંઈક કે આ જેવી લાગે છે - bfb8805c - જે કેટલાક સરનામું છે

714
00:58:30,060 --> 00:58:33,450
કે પ્રદેશ સ્ટેક-જેવું માં છે.

715
00:58:33,450 --> 00:58:41,820
પોતે અરે એક નિર્દેશક જેવા હોય છે, પરંતુ તે વાસ્તવિક નિર્દેશક નથી,

716
00:58:41,820 --> 00:58:45,410
અમે નિયમિત નિર્દેશક થી બદલી શકો છો.

717
00:58:45,410 --> 00:58:54,700
અરે માત્ર કેટલાક સતત છે. મેમરીનો 20 બ્લોક્સ સરનામા 0xbfb8805c શરુ થાય છે.

718
00:58:54,700 --> 00:59:09,020
તેથી આ સરનામા મારફતે bfb8805c +20- અથવા હું -20 ધારી -

719
00:59:09,020 --> 00:59:17,400
આ એરે માટે ફાળવવામાં મેમરી બધું છે.

720
00:59:17,400 --> 00:59:20,350
અરે, આ ચલ પોતે ગમે ત્યાં નથી સંગ્રહાયેલ છે.

721
00:59:20,350 --> 00:59:27,660
જ્યારે તમે સંકલન કરી રહ્યાં છો, પણ કમ્પાઇલર - તે અંતે હાથ મોજું -

722
00:59:27,660 --> 00:59:33,060
પરંતુ કમ્પાઇલર માત્ર જ્યાં તે એરે કરવા જાણે ઉપયોગ કરશે.

723
00:59:33,060 --> 00:59:36,090
તે જાણે છે કે જ્યાં એરે શરૂ કરે છે,

724
00:59:36,090 --> 00:59:40,910
અને તેથી તેને હંમેશાં માત્ર ઓફસેટો દ્રષ્ટિએ વસ્તુઓ કરી શકો છો કે શરૂઆતથી નથી.

725
00:59:40,910 --> 00:59:43,960
તે એક ચલ પોતે એરે પ્રતિનિધિત્વ જરૂર નથી.

726
00:59:43,960 --> 00:59:53,730
પરંતુ જ્યારે હું પૂર્ણાંક * પૃષ્ઠ એરે = કંઈક કરવું; હવે પૃષ્ઠ એક નિર્દેશક જે એરે નિર્દેશ છે,

727
00:59:53,730 --> 00:59:57,830
અને હવે પૃષ્ઠ ખરેખર સ્ટેક પર અસ્તિત્વમાં નથી.

728
00:59:57,830 --> 01:00:01,950
હું પૃષ્ઠ બદલવા મુક્ત છું. હું પૃષ્ઠ = malloc કરી શકો છો.

729
01:00:01,950 --> 01:00:06,500
તેથી તે મૂળભૂત એરે પર ધ્યાન; હવે તેને ઢગલો પર કેટલાક જગ્યા નિર્દેશ કરે છે.

730
01:00:06,500 --> 01:00:09,620
હું એરે = malloc ન કરી શકો.

731
01:00:09,620 --> 01:00:13,710
જો રણકાર હોંશિયાર છે, તે મને પર બેટ બોલ અધિકાર કિકિયારી આવશે.

732
01:00:17,000 --> 01:00:21,430
ખરેખર, હું ખૂબ ખાતરી કરો કે gcc આ પણ આવું કરશે છું.

733
01:00:21,430 --> 01:00:25,010
તેથી 'પૂર્ણાંક [5]' અરે પ્રકાર અસાઇનેબલ નથી.

734
01:00:25,010 --> 01:00:28,040
તમે કંઈક ઝાકઝમાળ પ્રકાર નથી સોંપી શકો છો

735
01:00:28,040 --> 01:00:30,500
કારણ કે એરે માત્ર એક સતત છે.

736
01:00:30,500 --> 01:00:34,760
તે એક પ્રતીક સંદર્ભો જે 20 બાઇટ્સ છે. હું તેને બદલી શકતા નથી.

737
01:00:34,760 --> 01:00:37,690
>> [વિદ્યાર્થી] અને જ્યાં એરે માપ સંગ્રહાયેલ છે?

738
01:00:37,690 --> 01:00:40,670
[બોડેન] તે ગમે ત્યાં નથી સ્ટોર છે. તે જ્યારે તે સંકલન છે.

739
01:00:40,670 --> 01:00:46,310
તેથી જ્યાં એરે માપ સંગ્રહાયેલ છે?

740
01:00:46,310 --> 01:00:51,870
તમે માત્ર કાર્ય કે એરે પોતે જાહેર કરવામાં આવે છે ની અંદર sizeof (એરે) નો ઉપયોગ કરી શકો છો.

741
01:00:51,870 --> 01:01:03,150
તેથી જો હું અમુક કાર્ય, foo, આમ અને હું (પૂર્ણાંક એરે [])

742
01:01:03,150 --> 01:01:10,450
printf ("% d \ n", sizeof (એરે));

743
01:01:10,450 --> 01:01:21,330
અને પછી નીચે અહીં હું foo (એરે) કહે છે;

744
01:01:21,330 --> 01:01:24,840
અંદર આ કાર્યનો એક - આપણે તેના ચલાવો.

745
01:01:34,200 --> 01:01:36,840
આ ચપળ ફરીથી હોવા રણકાર છે.

746
01:01:36,840 --> 01:01:43,890
તે મારા કહેવાની છે કે એરે કાર્ય પરિમાણ પર sizeof

747
01:01:43,890 --> 01:01:46,690
'પૂર્ણાંક *' નું માપ આપશે.

748
01:01:46,690 --> 01:01:55,150
આ ભૂલ હોય તો તે હું શું કરવા માગે છે માંગતા નથી.

749
01:01:55,150 --> 01:01:58,960
ચાલો ખરેખર બોલ Werror કરો.

750
01:02:14,950 --> 01:02:17,590
ચેતવણી. ચેતવણી દંડ છે.

751
01:02:17,590 --> 01:02:19,960
તે હજુ સુધી કમ્પાઇલ તે એક ચેતવણી હશે.

752
01:02:19,960 --> 01:02:22,910
/. A.out માટે 4 છાપી રહ્યું છે.

753
01:02:22,910 --> 01:02:28,650
ચેતવણી કે જે પેદા કરવામાં આવ્યો હતો કે શું ખોટું થયું સ્પષ્ટ સૂચક છે.

754
01:02:28,650 --> 01:02:34,120
આ પૂર્ણાંક એરે માત્ર sizeof (* પૂર્ણાંક) છાપી રહ્યું છે.

755
01:02:34,120 --> 01:02:39,790
જો હું અહીં [5] એરે મૂકી, તે હજુ પણ માત્ર છે માટે sizeof (* પૂર્ણાંક) છાપો જઈ રહી છે.

756
01:02:39,790 --> 01:02:47,440
તેથી જલદી તમે તે કાર્ય પસાર, એરે અને પોઇંટરો વચ્ચે તફાવત

757
01:02:47,440 --> 01:02:49,670
આવા કોઈ વલણને સ્થાન છે.

758
01:02:49,670 --> 01:02:52,640
આ ઝાકઝમાળ કે સ્ટેક પર જાહેર કરવામાં આવી બને છે,

759
01:02:52,640 --> 01:02:58,300
પરંતુ જલદી અમે તે કિંમત પસાર કરવા માટે, કે 0xbf મૂર્ખામી ભરેલી વાહિયાત વાત, મૂર્ખામી ભરેલી વાહિયાત વાત છે, આ કાર્ય માં મૂર્ખામી ભરેલી વાહિયાત વાત,

760
01:02:58,300 --> 01:03:03,350
તો પછી આ નિર્દેશક સ્ટેક પર કે એરે નિર્દેશ કરે છે.

761
01:03:03,350 --> 01:03:08,310
, કે જેથી અર્થ એ થાય કે sizeof માત્ર કાર્ય કરે છે જે એરે જાહેર કરવામાં આવી હતી તે લાગુ પડે છે

762
01:03:08,310 --> 01:03:11,230
જેનો અર્થ છે કે જ્યારે તમે આ કાર્ય કમ્પાઇલ કરવામાં આવે છે,

763
01:03:11,230 --> 01:03:17,330
જ્યારે રણકાર આ કાર્ય જાય છે, જુએ છે તે એરે 5 સાઈઝ પૂર્ણાંક એરે છે.

764
01:03:17,330 --> 01:03:20,640
તેથી પછી તે sizeof (એરે) જુએ છે. વેલ, અને તે 20 છે.

765
01:03:20,640 --> 01:03:26,440
કે ખરેખર કેવી રીતે sizeof મૂળભૂત લગભગ તમામ કિસ્સાઓમાં કામ કરે છે.

766
01:03:26,440 --> 01:03:31,150
Sizeof કાર્ય નથી; તેને એક ઓપરેટર છે.

767
01:03:31,150 --> 01:03:33,570
તમે sizeof કાર્ય નથી કહેતો.

768
01:03:33,570 --> 01:03:38,280
Sizeof (પૂર્ણાંક), પણ કમ્પાઇલર માત્ર જે 4 થી અનુવાદ થશે.

769
01:03:41,480 --> 01:03:43,700
તે મળ્યું? ઠીક છે.

770
01:03:43,700 --> 01:03:47,520
>> [વિદ્યાર્થી] તેથી મુખ્ય અને foo માં sizeof (એરે) વચ્ચે તફાવત શું છે?

771
01:03:47,520 --> 01:03:52,840
આ કારણ છે કે અમે (એરે) sizeof છે, જે પ્રકાર પૂર્ણાંક * છે કહી રહ્યાં છે,

772
01:03:52,840 --> 01:03:57,120
જ્યારે એરે નીચે અહીં પ્રકાર પૂર્ણાંક * નથી, તે પૂર્ણાંક એરે છે.

773
01:03:57,120 --> 01:04:04,540
>> [વિદ્યાર્થી] તેથી, જો તમે [] બદલે પૂર્ણાંક * અરે, અરે આ પરિમાણ હતી

774
01:04:04,540 --> 01:04:09,230
તેનો અર્થ છે કે તમે હજી પણ એરે ફેરફાર કારણ કે હવે તે એક નિર્દેશક છે કરી શકે છે?

775
01:04:09,230 --> 01:04:14,250
[બોડેન] આ ગમે છે? >> [વિદ્યાર્થી] યાહ. તમે કાર્ય કરી શકો છો અંદર એરે હવે બદલ્યો?

776
01:04:14,250 --> 01:04:18,420
[બોડેન] તમે બંને કિસ્સામાં એરે બદલી શકે છે.

777
01:04:18,420 --> 01:04:23,130
આ કિસ્સાઓમાં આ બંને તમને કહું છું [4] એરે = 0 મફત છે.

778
01:04:23,130 --> 01:04:26,590
[વિદ્યાર્થી] પરંતુ તમે કંઈક બીજું માટે એરે બિંદુ કરી શકો છો?

779
01:04:26,590 --> 01:04:30,230
[બોડેન] ઓહ. યાહ. ક્યાં કિસ્સામાં - >> [વિદ્યાર્થી] યાહ.

780
01:04:30,230 --> 01:04:38,410
[બોડેન] [] અને પૂર્ણાંક * અરે, અરે વચ્ચે આ તફાવત, ત્યાં કંઈ છે.

781
01:04:38,410 --> 01:04:42,570
તમે પણ અહીં કેટલાક બહુપરીમાણીય એરે મેળવી શકો છો

782
01:04:42,570 --> 01:04:47,050
કેટલાક અનુકૂળ સિન્ટેક્ષ માટે છે, પરંતુ તે હજુ પણ માત્ર એક નિર્દેશક છે.

783
01:04:47,050 --> 01:04:56,400
આનો અર્થ એ થાય કે હું એરે કરવા મુક્ત છું = (sizeof (પૂર્ણાંક)) malloc; અને હવે બીજે ક્યાંય નિર્દેશ કરે છે.

784
01:04:56,400 --> 01:04:59,610
પરંતુ ફક્ત માંગો કે કેવી રીતે આ કાયમ અને હંમેશા કામ કરે છે,

785
01:04:59,610 --> 01:05:03,210
તે કરીને આ એરે બદલવા કંઈક બીજું માટે નિર્દેશ

786
01:05:03,210 --> 01:05:07,570
નથી બદલી નીચે આ એરે અહીં કારણ કે તે દલીલ નકલ છે,

787
01:05:07,570 --> 01:05:10,780
તે દલીલ માટે નિર્દેશક નથી.

788
01:05:10,780 --> 01:05:16,070
અને ખરેખર, માત્ર વધારે સંકેત કરે છે કે તે બરાબર છે જ તરીકે -

789
01:05:16,070 --> 01:05:21,100
અમે પહેલાથી જ શું પ્રિન્ટીંગ એરે પ્રિન્ટ જોવા મળ્યો હતો -

790
01:05:21,100 --> 01:05:31,410
જો અમે ઍરેના સરનામું અથવા ઍરેના સરનામું સરનામા છાપો

791
01:05:31,410 --> 01:05:36,290
માટે તે ક્યાંતો?

792
01:05:41,770 --> 01:05:45,220
ચાલો આ એક અવગણો.

793
01:05:48,140 --> 01:05:51,660
ઠીક છે. આ દંડ છે. તે હવે a.out. / ચાલી રહી છે.

794
01:05:51,660 --> 01:06:00,220
પ્રિન્ટિંગ એરે, પછી ઍરેના સરનામા છાપવા માટે, આ જ વસ્તુ છે.

795
01:06:00,220 --> 01:06:02,870
અરે માત્ર અસ્તિત્વમાં નથી.

796
01:06:02,870 --> 01:06:08,190
તે જાણે છે કે જ્યારે તમે એરે છાપવા કરી રહ્યાં છો, તો તમે પ્રતીક કે તે 20 બાઇટ્સ સંદર્ભ લે છે છાપવા કરી રહ્યાં છો.

797
01:06:08,190 --> 01:06:11,940
એરે ની સરનામા છાપવા, તેમજ, અરે અસ્તિત્વમાં નથી.

798
01:06:11,940 --> 01:06:17,200
તે એક સરનામું નથી, તેથી તે માત્ર તે 20 બાઇટ્સ ની સરનામા છાપે છે.

799
01:06:20,820 --> 01:06:28,150
જલદી તમે કમ્પાઇલ, તમારા સંકલિત buggy4 માં ગમે /. A.out,

800
01:06:28,150 --> 01:06:30,340
એરે અસ્તિત્વ ધરાવતી હોય છે.

801
01:06:30,340 --> 01:06:33,640
પોઇન્ટર અસ્તિત્વ ધરાવે છે. નથી એરે.

802
01:06:34,300 --> 01:06:38,060
મેમરી ઓફ બ્લોકો એરે રજૂ હજુ પણ અસ્તિત્વ ધરાવે છે,

803
01:06:38,060 --> 01:06:43,270
પરંતુ ચલ એરે અને તે પ્રકારના ચલો અસ્તિત્વમાં નથી.

804
01:06:46,260 --> 01:06:50,270
તે એરે અને પોઇંટરો વચ્ચે મુખ્ય તફાવત જેવા છે

805
01:06:50,270 --> 01:06:55,590
છે જલદી તમે વિધેય કોલ કરવા માટે, ત્યાં કોઈ તફાવત નથી.

806
01:06:55,590 --> 01:07:00,460
પરંતુ કાર્ય કે એરે પોતે જાહેર કરવામાં આવે છે અંદર, sizeof અલગ રીતે કામ કરે છે

807
01:07:00,460 --> 01:07:05,190
કારણ કે તમે આ પ્રકારના માપ બદલે બ્લોકની કદ છાપવા કરી રહ્યાં છો,

808
01:07:05,190 --> 01:07:08,950
અને તમે તેને બદલવા કારણ કે તે પ્રતીક છે કરી શકો છો.

809
01:07:08,950 --> 01:07:14,370
અને આ વસ્તુ ની સરનામા વસ્તુ છાપવા જ વસ્તુ છાપે છે.

810
01:07:14,370 --> 01:07:18,480
અને તે ખૂબ ખૂબ તે છે.

811
01:07:18,480 --> 01:07:20,820
[વિદ્યાર્થી] કે જે તમને એક અથવા વધુ વખત કહેવું કરશો?

812
01:07:21,170 --> 01:07:24,170
હું કંઈક ચૂકી હોઈ શકે છે.

813
01:07:24,170 --> 01:07:29,260
પ્રિન્ટિંગ અને ઍરેની એરે સરનામું પણ એ જ વસ્તુ છાપે છે,

814
01:07:29,260 --> 01:07:33,180
જો તમે નિર્દેશક ની સરનામા વિરુદ્ધ એક નિર્દેશક છાપો જ્યારે,

815
01:07:33,180 --> 01:07:36,010
એક વસ્તુ તમે શું કરી રહ્યાં છો પોઇન્ટ ઓફ સરનામા છાપે છે,

816
01:07:36,010 --> 01:07:40,360
અન્ય સ્ટેક પર પોઇન્ટર ની સરનામા છાપે છે.

817
01:07:40,360 --> 01:07:47,040
તમે એક નિર્દેશક બદલી શકો છો; તમે ઝાકઝમાળ પ્રતીક બદલી શકતા નથી.

818
01:07:47,740 --> 01:07:53,270
અને sizeof નિર્દેશક કે નિર્દેશક પ્રકારના કદ છાપી રહ્યું છે.

819
01:07:53,270 --> 01:07:57,470
તેથી પૂર્ણાંક * પૃષ્ઠ sizeof (પી), 4 છાપી રહ્યું છે,

820
01:07:57,470 --> 01:08:04,110
પરંતુ પૂર્ણાંક [5] એરે પ્રિન્ટ sizeof (એરે) થી 20 છાપી રહ્યું છે.

821
01:08:04,110 --> 01:08:07,480
[વિદ્યાર્થી] તેથી પૂર્ણાંક [5] એરે 20 છાપશે? હા. >>

822
01:08:07,480 --> 01:08:13,300
કે buggy4 ની અંદર શા માટે છે જ્યારે તે sizeof (એરે) હોવો ઉપયોગ

823
01:08:13,300 --> 01:08:16,660
આ હું 20 <કરી હતી, જે નથી, આપણે શું ઇચ્છે છે.

824
01:08:16,660 --> 01:08:20,880
અમે i <5 માંગો છો. >> [વિદ્યાર્થી] ઠીક.

825
01:08:20,880 --> 01:08:25,569
[બોડેન] અને તે પછી તરત જ તમે વિધેયો માં પસાર શરૂ કરવા માટે,

826
01:08:25,569 --> 01:08:34,340
જો અમે પૂર્ણાંક * પૃષ્ઠ એરે =;

827
01:08:34,340 --> 01:08:39,779
આ કાર્ય ની અંદર, અમે મૂળભૂત રીતે બરાબર એ જ રીતે p અને એરે ઉપયોગ કરી શકો છો,

828
01:08:39,779 --> 01:08:43,710
સિવાય sizeof સમસ્યા અને બદલાતી સમસ્યા છે.

829
01:08:43,710 --> 01:08:49,810
પરંતુ પાનું 1 = [0]; [0] એરે = 1 જણાવ્યું હતું એ જ છે;

830
01:08:49,810 --> 01:08:55,600
અને જલદી અમે (એરે) foo કહે; અથવા foo (પી);

831
01:08:55,600 --> 01:08:59,760
આ foo કાર્ય ની અંદર, આ જ કોલ બમણું છે.

832
01:08:59,760 --> 01:09:03,350
ત્યાં આ બે કોલ્સ વચ્ચે કોઈ તફાવત નથી.

833
01:09:07,029 --> 01:09:11,080
>> કે સારા દરેક વ્યક્તિને? ઠીક છે.

834
01:09:14,620 --> 01:09:17,950
અમે 10 મિનિટ હોય છે.

835
01:09:17,950 --> 01:09:28,319
>> અમે આ હેકર Typer કાર્યક્રમ મારફતે પ્રયાસ કરીશું,

836
01:09:28,319 --> 01:09:32,350
આ વેબસાઇટ છે, જે ગયા વર્ષે અથવા કંઈક બહાર આવ્યા હતા.

837
01:09:34,149 --> 01:09:41,100
તે માત્ર હશે તેવું માનવામાં આવે છે કે તમે રેન્ડમ લખો અને તેને છાપે છે -

838
01:09:41,100 --> 01:09:46,729
ફાઈલ ગમે તે લાવી દીધા થાય છે તે શું લાગે છે કે તમે ટાઇપ કરી રહ્યા છો.

839
01:09:46,729 --> 01:09:52,069
તે ઓપરેટિંગ સિસ્ટમ કોડ કેટલાક પ્રકારની જેવો દેખાય છે.

840
01:09:53,760 --> 01:09:56,890
કે અમે શું અમલ કરવા માંગો છો.

841
01:10:08,560 --> 01:10:11,690
તમે એક દ્વિસંગી hacker_typer નામવાળી એક્ઝેક્યુટેબલ હોવા જોઈએ

842
01:10:11,690 --> 01:10:14,350
કે જે એક દલીલ લે છે, જે ફાઈલ "હેકર પ્રકાર."

843
01:10:14,350 --> 01:10:16,480
એક્ઝેક્યુટેબલ ચાલી રહેલ સ્ક્રીન સાફ કરીશું

844
01:10:16,480 --> 01:10:20,850
અને પછી ફાઈલ પસાર થતા-દરેક સમયે વપરાશકર્તા કી દબાવીને એક અક્ષર છાપો.

845
01:10:20,850 --> 01:10:24,990
કી ગમે તમે દબાવો, જેથી તે ફેંકી દેવું છે અને તેની જગ્યાએ ફાઈલ માંથી એક અક્ષર છાપો જોઈએ

846
01:10:24,990 --> 01:10:27,810
કે દલીલ છે.

847
01:10:29,880 --> 01:10:34,350
હું ખૂબ ખૂબ તમે કહો વસ્તુઓ અમે જાણવાની જરૂર જઈ રહ્યાં છો શું છે પડશે.

848
01:10:34,350 --> 01:10:36,440
પરંતુ અમે બહાર termios પુસ્તકાલય તપાસ કરવા માંગો છો.

849
01:10:36,440 --> 01:10:44,840
હું મારી સમગ્ર જીવન માં આ લાઇબ્રેરી ઉપયોગ ક્યારેય થતો નથી, તેથી તે ખૂબ જ ન્યૂનતમ હેતુઓ ધરાવે છે.

850
01:10:44,840 --> 01:10:48,610
પરંતુ આ માટે લાઈબ્રેરી અમે દૂર અક્ષર તમે ફટકો ફેંકવું ઉપયોગ કરી શકે રહ્યું છે

851
01:10:48,610 --> 01:10:52,390
જ્યારે તમે સાઇન ધોરણ માં ટાઇપ કરી રહ્યા છે

852
01:10:56,970 --> 01:11:05,840
તેથી hacker_typer.c, અને અમે તે માટે # <stdio.h> સમાવેશ કરવા માંગો છો જઈ રહ્યાં છો.

853
01:11:05,840 --> 01:11:12,870
Termios માટે મદદ પાનું અંતે છીએ - I'm તે ટર્મિનલ ઓએસ અથવા કંઈક અનુમાન લગાવવા -

854
01:11:12,870 --> 01:11:16,240
મને ખબર નથી કે તે કેવી રીતે વાંચી શકાય છે.

855
01:11:16,240 --> 01:11:21,040
આ અંતે છીએ, તે આ 2 ફાઈલો સમાવેશ કહે છે, તેથી અમે તે કરીશ.

856
01:11:37,620 --> 01:11:46,820
>> પ્રથમ વસ્તુ પ્રથમ, અમે એક દલીલ છે, કે જે ફાઈલ અમે ખોલવા જોઈએ છે માં લઈ જવા માંગો છો.

857
01:11:46,820 --> 01:11:52,420
તેથી હું શું કરવા માંગો છો? હું જોવા માટે હું એક દલીલ છે કે કેવી રીતે તપાસ કરી શકું?

858
01:11:52,420 --> 01:11:56,480
[વિદ્યાર્થી] જો argc તેને સમકક્ષ હોય છે. >> [બોડેન] યાહ.

859
01:11:56,480 --> 01:12:21,250
તેથી જો (argc = 2!) Printf ("વપરાશ:% [ફાઈલ ખોલવા માટે] ઓ").

860
01:12:21,250 --> 01:12:32,750
તેથી હવે જો હું બીજી દલીલ પૂરી વગર આ સ્કોર - ઓહ, હું નવી લાઇન કરવાની જરૂર પડશે -

861
01:12:32,750 --> 01:12:36,240
તમે તેને વપરાશ કહે જોશો:. / hacker_typer,

862
01:12:36,240 --> 01:12:39,770
અને પછી બીજા દલીલ ફાઈલ હું ખોલવા માંગો છો પ્રયત્ન કરીશું.

863
01:12:58,430 --> 01:13:01,260
હવે હું શું કરું?

864
01:13:01,260 --> 01:13:08,490
હું આ ફાઇલ વાંચવામાં કરવા માંગો છો. હું એક ફાઈલ કેવી રીતે વાંચી શકું?

865
01:13:08,490 --> 01:13:11,920
[વિદ્યાર્થી] તમે તે પ્રથમ ખોલો. >> યાહ.

866
01:13:11,920 --> 01:13:15,010
તેથી fopen. Fopen શું લાગતું નથી?

867
01:13:15,010 --> 01:13:22,980
[વિદ્યાર્થી] ફાઇલનામ. >> [બોડેન] ફાઇલનામ માટે argv [1] પ્રયત્ન રહ્યું છે.

868
01:13:22,980 --> 01:13:26,110
[વિદ્યાર્થી] અને તે પછી શું તમે તેની સાથે કરવા માંગો છો, તેથી - >> [બોડેન] યાહ.

869
01:13:26,110 --> 01:13:28,740
તેથી જો તમે યાદ નથી નહોતી, તો તમે માણસ fopen માત્ર કરી શકે,

870
01:13:28,740 --> 01:13:32,960
, જ્યાં તે એક const ઘરનાં પરચૂરણ કામો * પાથ છે કે જ્યાં પાથ અને ફાઈલનામ છે જ હશે

871
01:13:32,960 --> 01:13:34,970
const ઘરનાં પરચૂરણ કામો * મોડ.

872
01:13:34,970 --> 01:13:38,660
જો તમે યાદ સ્થિતિ શું છે ન થાય, તો પછી તમે સ્થિતિમાં જોવા માટે કરી શકો છો.

873
01:13:38,660 --> 01:13:44,660
મદદ પાનાંઓ અંદર છે, સ્લેશ અક્ષર છે તમે શું વસ્તુઓ શોધવા માટે ઉપયોગ કરી શકો છો.

874
01:13:44,660 --> 01:13:49,790
તેથી હું / માટે સ્થિતિ માટે શોધ સ્થિતિ લખો.

875
01:13:49,790 --> 01:13:57,130
n અને એન છે તમે શું શોધ મેચ મારફતે ખસેડવા માટે ઉપયોગ કરી શકો છો.

876
01:13:57,130 --> 01:13:59,800
અહીં તે શબ્દમાળા માટે દલીલ સ્થિતિમાં પોઇન્ટ કહે છે

877
01:13:59,800 --> 01:14:01,930
એક નીચેના ક્રમાંકો સાથે શરૂઆત કરી હતી.

878
01:14:01,930 --> 01:14:06,480
R તેથી, વાંચન માટે ઓપન ટેક્સ્ટ ફાઇલ. કે અમે શું કરવા માંગો છો.

879
01:14:08,930 --> 01:14:13,210
માટે વાંચવા, અને હું સંગ્રહવા માંગો છો.

880
01:14:13,210 --> 01:14:18,720
આ વસ્તુ એક છે FILE * પ્રયત્ન રહ્યું છે. હવે હું શું કરવા માંગો છો?

881
01:14:18,720 --> 01:14:21,200
મને બીજા આપો.

882
01:14:28,140 --> 01:14:30,430
ઠીક છે. હવે હું શું કરવા માંગો છો?

883
01:14:30,430 --> 01:14:32,940
[વિદ્યાર્થી] તપાસો જો તે NULL છે. >> [બોડેન] યાહ.

884
01:14:32,940 --> 01:14:38,690
કોઈપણ સમયે તમે ફાઈલ ખોલવા માટે, ખાતરી કરો કે તમે સફળતાપૂર્વક તેને ખોલવા સક્ષમ બનાવે છે.

885
01:14:58,930 --> 01:15:10,460
>> હવે હું termios સામગ્રી કરવા માંગો છો જ્યાં હું પ્રથમ મારા વર્તમાન સુયોજનો વાંચવા માંગો છો

886
01:15:10,460 --> 01:15:14,050
અને કંઈક માં તે સંગ્રહો, તો પછી હું મારી સેટિંગ્સ બદલવા માંગો છો

887
01:15:14,050 --> 01:15:19,420
દૂર કોઇ અક્ષર કે હું લખો ફેંકવું,

888
01:15:19,420 --> 01:15:22,520
અને પછી હું તે સેટિંગ્સને અપડેટ કરવા માંગો છો.

889
01:15:22,520 --> 01:15:27,250
અને પછી કાર્યક્રમ ઓવરને અંતે, હું મારા મૂળ સેટિંગ્સ પર પાછા બદલવા માંગો છો.

890
01:15:27,250 --> 01:15:32,080
તેથી સ્ટ્રક્ટ માટે પ્રકાર termios હોવા રહ્યું છે, અને હું બે લોકો કરવા માંગો છો જાઉં છું.

891
01:15:32,080 --> 01:15:35,600
પ્રથમ એક મારા current_settings પ્રયત્ન રહ્યું છે,

892
01:15:35,600 --> 01:15:42,010
અને પછી તેઓ મારા hacker_settings પ્રયત્ન રહ્યા છીએ.

893
01:15:42,010 --> 01:15:48,070
પ્રથમ, હું મારા વર્તમાન સુયોજનો સાચવવા માંગો છો જાઉં છું,

894
01:15:48,070 --> 01:15:53,790
પછી હું hacker_settings અપડેટ કરવા માંગો છો જાઉં છું,

895
01:15:53,790 --> 01:16:01,570
અને પછી મારી કાર્યક્રમ ઓવરને અંતે માર્ગ, હું વર્તમાન સુયોજનો ઉલટાવવાની કરવા માંગો છો.

896
01:16:01,570 --> 01:16:08,660
તેથી વર્તમાન સેટિંગ્સ સાચવતી, કે જે રીતે કામ કરે છે, અમે માણસ termios.

897
01:16:08,660 --> 01:16:15,810
અમે જુઓ કે જે આપણે આ પૂર્ણાંક tcsetattr, tcgetattr પૂર્ણાંક હોય છે.

898
01:16:15,810 --> 01:16:22,960
હું તેના નિર્દેશક દ્વારા termios સ્ટ્રક્ટ માં પસાર કરે છે.

899
01:16:22,960 --> 01:16:30,640
જે રીતે આ જોઈશું છે - I've પહેલાથી જ ભૂલી શું કાર્ય તરીકે ઓળખાતું હતું.

900
01:16:30,640 --> 01:16:34,930
કૉપિ કરો અને તેને પેસ્ટ કરો.

901
01:16:39,150 --> 01:16:45,500
Tcgetattr તેથી, પછી હું સ્ટ્રક્ટ પાસ કે હું આ માહિતી સાચવવામાં છું માંગો છો,

902
01:16:45,500 --> 01:16:49,650
જે current_settings પ્રયત્ન રહ્યું છે,

903
01:16:49,650 --> 01:16:59,120
અને પ્રથમ દલીલ વસ્તુ હું લક્ષણો સાચવવા માંગો છો માટે ફાઇલ વર્ણનકર્તા છે.

904
01:16:59,120 --> 01:17:04,360
ફાઇલ વર્ણનકર્તા છે શું કોઇ પણ સમયે ફાઇલ ખોલવા જેવા છે, તે ફાઇલ વર્ણનકર્તા નોંધાયો નહીં.

905
01:17:04,360 --> 01:17:14,560
Fopen હું જ્યારે argv [1], તે ફાઇલ વર્ણનકર્તા કે જે તમને સંદર્ભ કરવામાં આવે છે નોંધાયો નહીં

906
01:17:14,560 --> 01:17:16,730
જ્યારે પણ તમે વાંચી અથવા તે લખવા માટે કરવા માંગો છો.

907
01:17:16,730 --> 01:17:19,220
કે ફાઇલ વર્ણનકર્તા હું અહીં ઉપયોગ કરવા માંગો છો નથી.

908
01:17:19,220 --> 01:17:21,940
ત્યાં ત્રણ ફાઈલ વર્ણનકાર તમે મૂળભૂત રીતે હોય છે,

909
01:17:21,940 --> 01:17:24,310
જે પ્રમાણભૂત છે, પ્રમાણભૂત આઉટ અને પ્રમાણભૂત ભૂલ.

910
01:17:24,310 --> 01:17:29,960
મૂળભૂત રીતે, મને લાગે છે કે તે પ્રમાણભૂત છે 0, પ્રમાણભૂત બહાર 1, અને પ્રમાણભૂત ભૂલ 2 છે.

911
01:17:29,960 --> 01:17:33,980
તેથી હું શું માટે સુયોજનો બદલવા માંગો છો?

912
01:17:33,980 --> 01:17:37,370
હું જ્યારે પણ હું એક અક્ષર ફટકો ના સેટિંગ્સ બદલવા માંગો છો,

913
01:17:37,370 --> 01:17:41,590
હું તે પાત્ર ફેંકવું તેને સ્ક્રીન પર છાપવા બદલે દૂર કરવા માંગો છો.

914
01:17:41,590 --> 01:17:45,960
માં ધોરણ આઉટ, અથવા પ્રમાણભૂત ભૂલ ધોરણ - સ્ટ્રીમ શું -

915
01:17:45,960 --> 01:17:52,050
વસ્તુઓ પ્રતિભાવ જ્યારે હું કીબોર્ડ પર લખ્યું છે? >> [વિદ્યાર્થી] >> યાહ સાઇન સ્ટાન્ડર્ડ.

916
01:17:52,050 --> 01:17:56,450
તેથી હું ક્યાં તો 0 કરવા કરી શકો છો અથવા હું stdin ની કરી શકો છો.

917
01:17:56,450 --> 01:17:59,380
હું સ્ટાન્ડર્ડ current_settings સાઇન મેળવવામાં છું

918
01:17:59,380 --> 01:18:01,720
>> હવે હું તે સેટિંગ્સને અપડેટ કરવા માંગો છો,

919
01:18:01,720 --> 01:18:07,200
તેથી પ્રથમ હું hacker_settings મારા current_settings શું છે કૉપિ પડશે.

920
01:18:07,200 --> 01:18:10,430
અને કેવી રીતે સ્ટ્ર્ક્ટ્સ કાર્ય છે તે માત્ર નકલ થશે.

921
01:18:10,430 --> 01:18:14,510
આ બધા ક્ષેત્રોમાં નકલ કરે છે, કારણ કે તમે અપેક્ષા રાખી શકે છે.

922
01:18:14,510 --> 01:18:17,410
>> હવે હું ક્ષેત્રોમાં કેટલાક અપડેટ કરવા માંગો છો.

923
01:18:17,410 --> 01:18:21,670
Termios અંતે છીએ, તમે આ ઘણો દ્વારા વાંચી હશે

924
01:18:21,670 --> 01:18:24,110
માત્ર જોવા માટે તમે શું જોવા માટે કરવા માંગો છો કરશે,

925
01:18:24,110 --> 01:18:28,210
પરંતુ ફ્લેગ કરવા માટે તમે જોવા માટે કરવા માંગો છો જઈ રહ્યાં છો પડઘો છે,

926
01:18:28,210 --> 01:18:33,110
જેથી ઇકો અક્ષરો ઇનપુટ ઇકો.

927
01:18:33,110 --> 01:18:37,710
પ્રથમ હું સેટ કરવા માંગો છો - I've પહેલાથી જ ભૂલી ક્ષેત્રો શું છે.

928
01:18:45,040 --> 01:18:47,900
આ છે સ્ટ્રક્ટ શું જુએ છે.

929
01:18:47,900 --> 01:18:51,060
ઇનપુટ સ્થિતિઓ મને લાગે છે અમે બદલવા માંગો છો.

930
01:18:51,060 --> 01:18:54,210
અમે ઉકેલ જોવા ખાતરી કરો કે અમે શું બદલવા માંગો છો બનાવવા પડશે.

931
01:19:04,060 --> 01:19:12,610
અમે lflag ફેરફાર કરવા માટે ક્રમમાં આ તમામ દ્વારા જોવા જરૂર રોકવા માંગો છો.

932
01:19:12,610 --> 01:19:14,670
અમે સ્થાનિક સ્થિતિઓ બદલવા માંગો છો.

933
01:19:14,670 --> 01:19:17,710
તમે આ સમગ્ર વસ્તુ મારફતે વાંચી છે તે સમજવા માટે જ્યાં બધું અનુલક્ષે કરશે

934
01:19:17,710 --> 01:19:19,320
કે અમે બદલવા માંગો છો.

935
01:19:19,320 --> 01:19:24,120
પરંતુ તે સ્થાનિક સ્થિતિઓ જ્યાં અમે કરવા માટે કે બદલવા માંગો છો જઈ રહ્યાં છો ની અંદર છે.

936
01:19:27,080 --> 01:19:33,110
તેથી hacker_settings.cc_lmode છે શુ કહેવાય છે.

937
01:19:39,630 --> 01:19:43,020
c_lflag.

938
01:19:49,060 --> 01:19:52,280
આ તે છે જ્યાં અમે bitwise ઓપરેટરો માં મેળવો.

939
01:19:52,280 --> 01:19:54,860
અમે સમય બહાર પ્રકારની છીએ, પરંતુ અમે તેને વાસ્તવિક ઝડપી પસાર કરશો.

940
01:19:54,860 --> 01:19:56,600
આ તે છે જ્યાં અમે bitwise ઓપરેટરો પ્રવેશ મેળવવા,

941
01:19:56,600 --> 01:19:59,950
જ્યાં મને લાગે છે કે હું એક લાંબા સમયથી પહેલા કહ્યું હતું કે, જ્યારે તમે ફ્લેગ સાથે કામ શરૂ

942
01:19:59,950 --> 01:20:03,370
તમે bitwise ઓપરેટર ઘણો ઉપયોગ કરી રહ્યા છીએ.

943
01:20:03,370 --> 01:20:08,240
ધ્વજ દરેક બીટ વર્તન અમુક પ્રકારની અનુલક્ષે છે.

944
01:20:08,240 --> 01:20:14,090
અહીં, આ ધ્વજ અલગ વસ્તુઓ છે, જ્યાં તેમને બધા કંઇક અલગ અર્થ સમૂહ છે.

945
01:20:14,090 --> 01:20:18,690
પરંતુ હું શું કરવા માંગો છો કે માત્ર બોલ છે બીટ જે ECHO અનુલક્ષે કરો.

946
01:20:18,690 --> 01:20:25,440
તેથી ચાલુ કરવા માટે કે બોલ હું અને = ¬ ECHO.

947
01:20:25,440 --> 01:20:30,110
ખરેખર, મને લાગે છે કે તે tECHO અથવા કંઈક જેવું છે. મેં હમણાં ફરીથી તપાસ જાઉં છું.

948
01:20:30,110 --> 01:20:34,050
હું તેને termios કરી શકો છો. તે માત્ર ECHO છે.

949
01:20:34,050 --> 01:20:38,440
ECHO એક બીટ પ્રયત્ન રહ્યું છે.

950
01:20:38,440 --> 01:20:44,230
¬ ECHO અર્થ બધા બિટ્સ 1 સુયોજિત છે, કે જેનો અર્થ તમામ ધ્વજો સાચું સુયોજિત હોય છે રહ્યું છે

951
01:20:44,230 --> 01:20:47,140
આ ECHO બીટ સિવાય.

952
01:20:47,140 --> 01:20:53,830
આ સાથે મારા સ્થાનિક ફ્લેગો અંત સુધીમાં, આ તમામ ધ્વજો કે જે વર્તમાનમાં સાચું સુયોજિત હોય છે, એટલે

953
01:20:53,830 --> 01:20:56,520
હજુ પણ સાચું સુયોજિત કરવામાં આવશે.

954
01:20:56,520 --> 01:21:03,240
જો મારું ECHO ધ્વજ સાચું સુયોજિત થયેલ હોય, તો પછી આ માટે જરૂરી ECHO ધ્વજ પર ખોટા સુયોજિત થયેલ છે.

955
01:21:03,240 --> 01:21:07,170
તેથી કોડ આ વાક્ય માત્ર બોલ ECHO ધ્વજ કરે છે.

956
01:21:07,170 --> 01:21:16,270
કોડ અન્ય રેખાઓ, હું હમણાં જ તેમને સમય રસ નકલ અને પડશે પછી તેમને સમજાવવું.

957
01:21:27,810 --> 01:21:30,180
ઉકેલ માં, તેમણે 0 જણાવ્યું હતું.

958
01:21:30,180 --> 01:21:33,880
તે કદાચ વધુ સારી રીતે સ્પષ્ટ રીતે stdin ની કહે છે.

959
01:21:33,880 --> 01:21:42,100
>> નોંધ કરો કે હું પણ ECHO છું કરવાનું | ICANON અહીં.

960
01:21:42,100 --> 01:21:46,650
ICANON અલગ કંઈક છે, કે જે પ્રમાણભૂત સ્થિતિમાં અર્થ ઉલ્લેખ કરે છે.

961
01:21:46,650 --> 01:21:50,280
પ્રમાણભૂત સ્થિતિમાં અર્થ શું સામાન્ય રીતે જ્યારે તમે આદેશ વાક્ય લખી રહ્યા છો,

962
01:21:50,280 --> 01:21:54,670
પ્રમાણભૂત કંઈપણ પ્રક્રિયા સુધી તમે NEWLINE ફટકો નથી.

963
01:21:54,670 --> 01:21:58,230
તેથી જ્યારે તમે GetString નથી, તો તમે વસ્તુઓ સમૂહ લખો, પછી તમે NEWLINE નહીં.

964
01:21:58,230 --> 01:22:00,590
કે જ્યારે તે સાઇન પ્રમાણભૂત માટે મોકલવામાં આવે છે

965
01:22:00,590 --> 01:22:02,680
કે મૂળભૂત છે.

966
01:22:02,680 --> 01:22:05,830
જ્યારે હું બોલ પ્રમાણભૂત સ્થિતિમાં ચાલુ છે, હવે દરેક એક અક્ષર તમે દબાવો

967
01:22:05,830 --> 01:22:10,910
છે શું પ્રક્રિયા, નહીં કે જે સામાન્ય રીતે ખરાબ પ્રકારની કારણ કે તે આ બધી વસ્તુઓ પર પ્રક્રિયા ધીમી છે,

968
01:22:10,910 --> 01:22:14,330
કેમ કે તે સારી છે તે સમગ્ર લીટીઓમાં બફર.

969
01:22:14,330 --> 01:22:16,810
પરંતુ હું દરેક અક્ષર પ્રક્રિયા કરવા માંગો છો

970
01:22:16,810 --> 01:22:18,810
કારણ કે હું તેને મારા માટે NEWLINE હિટ રાહ નથી માંગતા

971
01:22:18,810 --> 01:22:21,280
તે પહેલા તમામ અક્ષરો પ્રક્રિયા હું લખીને થઈ.

972
01:22:21,280 --> 01:22:24,760
આ બોલ પ્રમાણભૂત સ્થિતિમાં કરે છે.

973
01:22:24,760 --> 01:22:31,320
આ સામગ્રી ફક્ત અર્થ થાય છે જ્યારે તે વાસ્તવમાં અક્ષરો પ્રક્રિયા.

974
01:22:31,320 --> 01:22:35,830
આનો અર્થ એ થાય તેમને તુરંત જ પ્રક્રિયા; જલદી હું તેમને લખીને છું, તેમને પ્રક્રિયા કરે છે.

975
01:22:35,830 --> 01:22:42,510
અને આ કાર્ય જે પ્રમાણભૂત માટે મારી સેટિંગ્સ અપડેટ થાય છે,

976
01:22:42,510 --> 01:22:45,480
અને TCSA અર્થ તે હમણાં નથી.

977
01:22:45,480 --> 01:22:50,310
અન્ય વિકલ્પો સુધી બધું છે કે સ્ટ્રીમ પર હાલમાં પ્રક્રિયા રાહ છે.

978
01:22:50,310 --> 01:22:52,030
કે ખરેખર તો કોઈ વાંધો નથી.

979
01:22:52,030 --> 01:22:56,920
જસ્ટ હમણાં મારી સેટિંગ્સ પ્રયત્ન ગમે hacker_typer_settings હાલમાં છે બદલો.

980
01:22:56,920 --> 01:23:02,210
હું માનું હું તે hacker_settings કહેવાય છે, તેથી આપણે કે બદલો.

981
01:23:09,610 --> 01:23:13,500
Hacker_settings માટે બધું બદલો.

982
01:23:13,500 --> 01:23:16,870
>> હવે અમારી કાર્યક્રમ ઓવરને અંતે અમે પાછા ફરવા માટે કરવા માંગો છો જઈ રહ્યાં છો

983
01:23:16,870 --> 01:23:20,210
શું હાલમાં normal_settings ની અંદર છે,

984
01:23:20,210 --> 01:23:26,560
જે માત્ર normal_settings અને જેમ દેખાય રહ્યું છે.

985
01:23:26,560 --> 01:23:30,650
હું મારા normal_settings કોઇપણ મૂળભૂત રીતે તે મેળવવામાં થી બદલાઈ નથી નોટિસ.

986
01:23:30,650 --> 01:23:34,520
પછી ફક્ત તેને પાછા બદલી શકે છે, હું તેમને ઓવરને અંતે પાછળ પસાર કરે છે.

987
01:23:34,520 --> 01:23:38,390
આ સુધારો હતો. ઠીક છે.

988
01:23:38,390 --> 01:23:43,900
>> હવે અંદર અહીં મેં હમણાં જ સમય રસ કોડ સમજાવવું પડશે.

989
01:23:43,900 --> 01:23:46,350
તે ખૂબ કોડ નથી.

990
01:23:50,770 --> 01:24:03,750
અમે જુઓ ફાઇલ પર અમે એક અક્ષર વાંચી શકાય છે. અમે તેને એફ કહેવાય છે.

991
01:24:03,750 --> 01:24:07,850
હવે તમે માણસ fgetc કરી શકો છો, પરંતુ fgetc કેવી રીતે કામ રહ્યું છે

992
01:24:07,850 --> 01:24:11,910
છે માત્ર તે અક્ષર કે જે તમે હમણાં જ વાંચી અથવા EOF પરત ચાલી રહ્યું છે,

993
01:24:11,910 --> 01:24:15,680
જે ફાઈલ અથવા કેટલીક ભૂલ થાય અંતે અનુલક્ષે છે.

994
01:24:15,680 --> 01:24:19,900
અમે રહ્યાં છે, જે ફાઈલ એક અક્ષર વાંચી નિરંતર,

995
01:24:19,900 --> 01:24:22,420
ત્યાં સુધી અમે અક્ષરો સ્કોર કર્યું વાંચો.

996
01:24:22,420 --> 01:24:26,650
અને જ્યારે અમે તે કરી રહ્યા છીએ, અમે સાઇન પ્રમાણભૂત એક પાત્ર પર રાહ જોવી

997
01:24:26,650 --> 01:24:29,090
દરેક એક સમય તમે આદેશ વાક્ય પર કંઈક લખો

998
01:24:29,090 --> 01:24:32,820
કે, એક અક્ષર પ્રમાણભૂત માંથી સાઇન reading છે

999
01:24:32,820 --> 01:24:38,330
પછી putchar માત્ર કોલસો બનાવો અમે વાંચો ફાઇલ માંથી ધોરણ આઉટ કરવા માટે અહીં મૂકવામાં રહ્યું છે.

1000
01:24:38,330 --> 01:24:42,890
તમે માણસ putchar કરી શકો છો, પરંતુ તે માત્ર ધોરણ માટે મૂકી છે આઉટ તે અક્ષર છાપવા છે.

1001
01:24:42,890 --> 01:24:51,600
તમે પણ માત્ર printf કરી શકે ("% C", C); સેમ વિચાર.

1002
01:24:53,330 --> 01:24:56,670
કે અમારી કામ બલ્ક કરવા જઇ રહી છે.

1003
01:24:56,670 --> 01:25:00,300
>> છેલ્લા વસ્તુ અમે કરવા માંગો છો જઈ રહ્યાં છો છે અમારા ફાઈલ fclose.

1004
01:25:00,300 --> 01:25:03,310
જો તમે ન fclose નથી, કે જે મેમરી છિદ્ર છે.

1005
01:25:03,310 --> 01:25:06,680
અમે ફાઈલ અમે મૂળ ખોલી fclose કરવા માંગો છો, અને મને લાગે છે કે તે છે.

1006
01:25:06,680 --> 01:25:13,810
જો આપણે એ બનાવવા માટે, હું પહેલેથી જ સમસ્યાઓ મળી.

1007
01:25:13,810 --> 01:25:17,260
ચાલો જુઓ.

1008
01:25:17,260 --> 01:25:19,960
તે શેના વિશે ફરિયાદ કરી?

1009
01:25:19,960 --> 01:25:30,220
અપેક્ષિત 'પૂર્ણાંક' પરંતુ દલીલ પ્રકાર 'સ્ટ્રક્ટ _IO_FILE *' છે.

1010
01:25:36,850 --> 01:25:39,370
અમે જો કે કામ કરે છે જોશો.

1011
01:25:45,210 --> 01:25:53,540
માત્ર C99 માં મંજૂરી આપી હતી. Augh. ઠીક છે, hacker_typer બનાવે છે.

1012
01:25:53,540 --> 01:25:57,760
હવે અમે વધુ ઉપયોગી વર્ણનો મળે છે.

1013
01:25:57,760 --> 01:25:59,900
તેથી બિનજાહેર ઓળખકર્તા 'normal_settings' ના વાપરો.

1014
01:25:59,900 --> 01:26:04,170
હું તેને normal_settings નથી કહી ન હતી. હું તેને current_settings કહેવાય છે.

1015
01:26:04,170 --> 01:26:12,090
તેથી આપણે તે બધા બદલો.

1016
01:26:17,920 --> 01:26:21,710
હવે દલીલ પસાર.

1017
01:26:26,290 --> 01:26:29,500
હવે હું માટે આ 0 બનાવવા પડશે.

1018
01:26:29,500 --> 01:26:36,720
ઠીક છે. /. Hacker_typer cp.c.

1019
01:26:36,720 --> 01:26:39,590
હું પણ શરૂઆતમાં સ્ક્રીન સાફ ન હતી.

1020
01:26:39,590 --> 01:26:42,960
પરંતુ તમે પાછા છેલ્લા સમસ્યા સેટ નજર જોવા માટે તમે કેવી રીતે સ્ક્રીન સાફ કરી શકો છો.

1021
01:26:42,960 --> 01:26:45,160
તે માત્ર કેટલાક અક્ષરો છાપવા છે

1022
01:26:45,160 --> 01:26:47,210
જ્યારે આવું થાય છે હું શું કરવા માંગો છો.

1023
01:26:47,210 --> 01:26:48,900
ઠીક છે.

1024
01:26:48,900 --> 01:26:55,280
અને શા માટે આ 0 stdin ની જગ્યાએ જરૂર વિશે વિચારવું,

1025
01:26:55,280 --> 01:27:00,560
જે 0 # વ્યાખ્યાયિત કરવા જોઇએ,

1026
01:27:00,560 --> 01:27:03,890
આ કે ફરિયાદ છે -

1027
01:27:13,150 --> 01:27:19,360
જ્યારે હું જણાવ્યું હતું કે ત્યાં ફાઈલ ડિસ્ક્રીપ્ટર્સ છે પછી પણ તમે પણ તમારા છે FILE * પહેલાં,

1028
01:27:19,360 --> 01:27:23,210
ફાઇલ વર્ણનકર્તા માત્ર એક પૂર્ણાંક છે,

1029
01:27:23,210 --> 01:27:26,970
જ્યારે એક છે FILE * સામગ્રી સંપૂર્ણ સમૂહ તેની સાથે સંકળાયેલ છે.

1030
01:27:26,970 --> 01:27:30,380
કારણ અમે stdin ની બદલે 0 કહેવું જરૂર

1031
01:27:30,380 --> 01:27:37,480
છે કે stdin ની એક છે FILE * જે વસ્તુ કે ફાઈલ 0 વર્ણનકર્તા સંદર્ભ આપે છે નિર્દેશ છે.

1032
01:27:37,480 --> 01:27:45,070
તેથી પણ અહીં જ્યારે હું fopen કરવું (argv [1], હું એક છે FILE * મળતો રહ્યો છું નહીં.

1033
01:27:45,070 --> 01:27:51,180
પરંતુ તે ફાઇલ * ક્યાંક તે ફાઈલ માટે ફાઇલ વર્ણનકર્તા સંબંધિત વસ્તુ છે.

1034
01:27:51,180 --> 01:27:57,430
જો તમે ઓપન માટે મદદ પાનું જોવા માટે છે, તેથી મને લાગે છે કે તમે 3 માણસ ઓપન કરવા પડશે - ના -

1035
01:27:57,430 --> 01:27:59,380
2 માણસ ઓપન - હા.

1036
01:27:59,380 --> 01:28:06,250
જો તમે ઓપન માટે પાનું જોવા માટે, ઓપન એક fopen નીચા સ્તર જેવા છે,

1037
01:28:06,250 --> 01:28:09,350
અને તે વાસ્તવિક ફાઇલ વર્ણનકર્તા પરત છે.

1038
01:28:09,350 --> 01:28:12,050
fopen ઓપન ટોચ પર સામગ્રી સમૂહ કરે છે,

1039
01:28:12,050 --> 01:28:17,640
પરત માત્ર તે ફાઇલ વર્ણનકર્તા સંપૂર્ણ છે FILE * નિર્દેશક આપે બદલે જે

1040
01:28:17,640 --> 01:28:20,590
અંદર જે અમારી થોડી ફાઇલ વર્ણનકર્તા છે.

1041
01:28:20,590 --> 01:28:25,020
તેથી છે FILE * વસ્તુ સંદર્ભ લે માં ધોરણ,

1042
01:28:25,020 --> 01:28:29,120
જ્યારે 0 માત્ર પોતે ફાઇલ વર્ણનકર્તા પ્રમાણભૂત સંદર્ભ આપે છે.

1043
01:28:29,120 --> 01:28:32,160
>> પ્રશ્નો?

1044
01:28:32,160 --> 01:28:35,930
[Laughs] કે મારફતે ઉડાવી.

1045
01:28:35,930 --> 01:28:39,140
અધિકાર છે. અમે પૂર્ણ કરી લીધું. [Laughs]

1046
01:28:39,140 --> 01:28:42,000
>> [CS50.TV]