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