1
00:00:00,000 --> 00:00:10,970
>> [સંગીત વગાડવાનો]

2
00:00:10,970 --> 00:00:12,536
>> ડેવિડ જે MALAN: બધા અધિકાર.

3
00:00:12,536 --> 00:00:13,392
>> [હાસ્ય]

4
00:00:13,392 --> 00:00:14,240
>> પાછા આપનું સ્વાગત છે.

5
00:00:14,240 --> 00:00:14,990
આ CS50 છે.

6
00:00:14,990 --> 00:00:16,890
અને આ અઠવાડિયે પાંચ ઓવરને.

7
00:00:16,890 --> 00:00:20,020
અને હવે ત્યાં સુધી, અમે ખૂબ ખૂબ કર્યું
મંજૂર માટે લઈ ગયેલ છે કે ત્યાં

8
00:00:20,020 --> 00:00:23,480
તમે કર્યું કે આ કમ્પાઈલર, રણકાર, અસ્તિત્વમાં છે
આ માર્ગ દ્વારા આવાહન કરતો કરવામાં આવી

9
00:00:23,480 --> 00:00:27,100
અન્ય સાધન છે કે જે અચાનક કરો કહેવાય
જાદુઇ તમારો સ્રોત કોડ ફેરવે

10
00:00:27,100 --> 00:00:31,350
ઑબ્જેક્ટ કોડ છે, આ zeros અને રાશિઓ માં
જે તમારા કમ્પ્યુટર્સ CPU, કેન્દ્રિય

11
00:00:31,350 --> 00:00:33,410
પ્રક્રિયા એકમ, વાસ્તવમાં સમજે છે.

12
00:00:33,410 --> 00:00:36,770
કોઈ નંબર છે બહાર છે, પરંતુ તે કરે છે
માં હૂડ નીચે ચાલુ

13
00:00:36,770 --> 00:00:38,690
ઇનપુટ અને આઉટપુટ વચ્ચે.

14
00:00:38,690 --> 00:00:41,800
>> અને હું માનું છું કે આપણે માંસ પ્રસ્તાવ કરવા માંગો છો
થોડી વધારે વિગત માં કે બહાર

15
00:00:41,800 --> 00:00:45,130
આ ચાર પગલાંઓ, કહેવાય કંઈક છે
પૂર્વ પ્રક્રિયા, કંઈક

16
00:00:45,130 --> 00:00:48,300
અમે જોવા મળે છે, જે સંકલન, કહેવાય
કંઈક ભેગા કહેવાય છે, અને

17
00:00:48,300 --> 00:00:49,420
કંઈક લિંક કહેવાય છે.

18
00:00:49,420 --> 00:00:53,270
તેથી અપ હવે ત્યાં સુધી, અમારા કેટલાક
કાર્યક્રમો, અમે તીવ્ર સમાવેશ થાય હતી.

19
00:00:53,270 --> 00:00:56,650
તાજેતરમાં અમે કેટલીક તીવ્ર હતી કર્યું
સ્થિરાંકો માટે વ્યાખ્યાયિત કરે છે.

20
00:00:56,650 --> 00:01:00,660
તેથી તે બહાર વળે તે વસ્તુઓ છે કે જે
હેશ પ્રતીક અથવા સાથે પ્રિફિક્સ કરેલા છે

21
00:01:00,660 --> 00:01:04,150
પાઉન્ડ પ્રતીક પૂર્વ પ્રોસેસર છે
ડાઈરેક્ટીવો.

22
00:01:04,150 --> 00:01:07,960
માત્ર તે કહેતા ફેન્સી માર્ગ
ખરેખર છે કે કોડ કે જે એક લીટી

23
00:01:07,960 --> 00:01:12,280
આ પહેલા કંઈક બીજું રૂપાંતરીત
કોમ્પ્યુટર પણ કન્વર્ટ કરવા પ્રયાસ તમારા

24
00:01:12,280 --> 00:01:13,800
zeros અને રાશિઓ માં કાર્યક્રમ.

25
00:01:13,800 --> 00:01:19,000
>> હમણાં પૂરતું, તીક્ષ્ણ પ્રમાણભૂત સમાવેશ થાય છે
I / O. H, ખૂબ ખૂબ માત્ર જાઓ અર્થ એ થાય

26
00:01:19,000 --> 00:01:24,010
આગળ, ફાઈલો સમાવિષ્ટો પડાવી લેવું
stdio.h અને જમણી ત્યાં તેમને પેસ્ટ કરો.

27
00:01:24,010 --> 00:01:25,880
તેથી કોઈ zeros અને રાશિઓ
હજુ સુધી તે સમયે.

28
00:01:25,880 --> 00:01:27,470
તે ખરેખર માત્ર એક અવેજી છે.

29
00:01:27,470 --> 00:01:30,790
અને તે કહેવાતા દરમિયાન કરવામાં આવ્યું છે
પૂર્વ પ્રક્રિયા સ્ટેજ, ત્યારે તમે

30
00:01:30,790 --> 00:01:34,230
ખરેખર ખાસ રણકાર સ્કોર અથવા
મોટા ભાગના કિસ્સાઓમાં બનાવો.

31
00:01:34,230 --> 00:01:36,950
તેથી એ બધા આ શું થઈ રહ્યું કરવામાં આવ્યું છે
પ્રથમ આપમેળે આમ અત્યાર સુધી.

32
00:01:36,950 --> 00:01:38,800
>> પછી સંકલન પગલું આવે છે.

33
00:01:38,800 --> 00:01:40,920
પરંતુ અમે oversimplified કરવામાં આવ્યાં છે
સંકલન.

34
00:01:40,920 --> 00:01:45,060
એક કાર્યક્રમ સંકલન ખરેખર અર્થ
જો, સી કંઈક તેને લેવા

35
00:01:45,060 --> 00:01:48,430
સ્ત્રોત કોડ અમે નીચે, લેખન કર્યું છે
કંઈક વિધાનસભા કહેવાય છે.

36
00:01:48,430 --> 00:01:52,900
એસેમ્બલી ભાષા નીચા સ્તરે છે
ભાષા કે, thankfully, અમે નહીં

37
00:01:52,900 --> 00:01:55,480
ઘણી પ્રસંગ છે
આ સત્ર લખો.

38
00:01:55,480 --> 00:01:59,100
પરંતુ તે સૌથી નીચો સ્તર પર છે
તમે શાબ્દિક લખવાનું શરૂ કે અર્થમાં

39
00:01:59,100 --> 00:02:04,270
ઉમેરો અને બાદબાકી અને ગુણાકાર અને લોડ કરી
મેમરી અને મેમરી સંગ્રહવા માટે,

40
00:02:04,270 --> 00:02:08,259
ખૂબ જ મૂળભૂત સૂચનો કે કોમ્પ્યુટર,
હૂડ નીચે,

41
00:02:08,259 --> 00:02:09,639
ખરેખર સમજે છે.

42
00:02:09,639 --> 00:02:14,930
>> છેલ્લે, ભેગા ભાષા લે છે
અમે કરી છે કે zeros અને રાશિઓ માટે

43
00:02:14,930 --> 00:02:16,190
આમ અત્યાર સુધી વર્ણન.

44
00:02:16,190 --> 00:02:19,270
અને સાચી છેલ્લે, કહેવાતા નથી
તબક્કા લિંક છે, કે જે અમે કરીશું

45
00:02:19,270 --> 00:02:22,360
જોડાયેલું છે, જે માત્ર એક ક્ષણ માં જુઓ
તમારા zeros અને zeros સાથે રાશિઓ અને

46
00:02:22,360 --> 00:02:24,870
પહેલાં રાશિઓ અન્ય લોકો
તમે બનાવેલ છે.

47
00:02:24,870 --> 00:02:26,660
>> તેથી આ સુપર સરળ કાર્યક્રમ ગણે છે.

48
00:02:26,660 --> 00:02:27,560
તે અઠવાડિયું 1 હતો.

49
00:02:27,560 --> 00:02:29,610
તે માત્ર, વિશ્વ હેલો, જણાવ્યું હતું કે,
સ્ક્રીન પર.

50
00:02:29,610 --> 00:02:30,920
અમે રણકાર દ્વારા આ ચાલી હતી.

51
00:02:30,920 --> 00:02:33,200
અથવા આપણે તે મારફતે મેક ચાલી હતી
જે રણકાર ચાલી હતી.

52
00:02:33,200 --> 00:02:36,170
અને તે સમયે outputted જ્યાં
કેટલાક zeros અને રાશિઓ.

53
00:02:36,170 --> 00:02:38,100
ત્યાં બહાર છે, પરંતુ તે કરે છે
મધ્યવર્તી પગલું.

54
00:02:38,100 --> 00:02:40,460
હું અહીં જાઓ તો - અરે, ન
હજુ સુધી તેને જોવા માંગો છો.

55
00:02:40,460 --> 00:02:44,800
હું મારા ઉપકરણ માટે અહીં પર જાઓ તો
અને હું hello.c, અહીં ખોલો

56
00:02:44,800 --> 00:02:46,160
તે જ પ્રોગ્રામ છે.

57
00:02:46,160 --> 00:02:48,600
અને શું હું મારા ટર્મિનલમાં કરવા જઇ રહ્યો છું
અહીં વિન્ડો હું જઈ રહ્યો છે

58
00:02:48,600 --> 00:02:51,430
, રણકાર સ્કોર બદલે બનાવો જે
તમામ ચાર automates

59
00:02:51,430 --> 00:02:52,870
અમારા માટે તે જાય છે.

60
00:02:52,870 --> 00:02:58,620
અને હું રણકાર-S કરવા જઇ રહ્યો છું અને
દાખલ પછી hello.c અને પછી.

61
00:02:58,620 --> 00:03:00,590
>> અને હું ખીલેલું પ્રોમ્પ્ટ વિચાર
ફરીથી, જે સારા હોય છે.

62
00:03:00,590 --> 00:03:05,280
અને હવે સહેજ મોટા વિંડોમાં,
હું અહીં gedit અપ ખોલવા માટે જઇ રહ્યો છું.

63
00:03:05,280 --> 00:03:09,610
અને હું કે જે, ફાઇલ ખોલવા માટે જઇ રહ્યો છું
બહાર વળે, hello.s આ કહેવામાં આવે છે

64
00:03:09,610 --> 00:03:11,870
કે એસેમ્બલી ભાષા છે
હું અગાઉ કરવામાં આવે છે.

65
00:03:11,870 --> 00:03:15,060
અને આ વિધાનસભા કહેવાય છે તે છે
ભાષા, એકદમ નીચા સ્તરે

66
00:03:15,060 --> 00:03:18,470
સૂચનો કે તમારી ઇન્ટેલ CPU
અથવા ગમે તે અંદર છે

67
00:03:18,470 --> 00:03:19,350
સમજે છે.

68
00:03:19,350 --> 00:03:24,480
અને mov ચાલ માટે છે. કૉલ માટે છે
, ખૂબ જ ઓછી સ્તર વિધેય ફોન.

69
00:03:24,480 --> 00:03:26,380
પેટા બાદબાકી માટે છે.

70
00:03:26,380 --> 00:03:30,370
>> તમે અંદર ચોક્કસ CPU તેથી, જ્યારે
તમારા કમ્પ્યુટરની, તે શું કરે છે

71
00:03:30,370 --> 00:03:34,300
પર અલગ, વિરુદ્ધ અન્ય સીપીયુ
બજાર છે, જે સૂચનાઓ તે

72
00:03:34,300 --> 00:03:39,460
સમજે છે અને ઘણી વખત કેવી રીતે કાર્યક્ષમ તે
તે કેટલીક ચલાવ્યા છે કેવી રીતે ઝડપી છે,

73
00:03:39,460 --> 00:03:40,380
તે સૂચનો.

74
00:03:40,380 --> 00:03:45,150
હવે આ પર વધુ માટે, તમે લઈ શકે છે
કોલેજ ખાતે આગામી વિકેટનો ક્રમ ઃ CS61.

75
00:03:45,150 --> 00:03:48,170
પરંતુ અહીં આપણે થોડા દાખલા તરીકે, તમારી પાસે
પરિચિત જુઓ શકે છે આઇડેન્ટીફાયર.

76
00:03:48,170 --> 00:03:50,150
hello.c કાર્યક્રમ નામ છે.

77
00:03:50,150 --> 00:03:51,070
>> . લખાણ -

78
00:03:51,070 --> 00:03:54,190
રસ ખૂબ ત્યાં ત્યાં નથી
માત્ર હવે, યાદ છે કે લખાણ

79
00:03:54,190 --> 00:03:59,190
જ્યાં સેગમેન્ટમાં, સોમવાર તરીકે છે,
મેમરી તમારા કાર્યક્રમ ખરેખર અપ અંત થાય છે.

80
00:03:59,190 --> 00:04:01,330
કે જેથી ઓછામાં ઓછા અસ્પષ્ટ છે
ત્યાં પરિચિત.

81
00:04:01,330 --> 00:04:03,730
અહીં, અલબત્ત, એક ઉલ્લેખ છે
અમારા મુખ્ય કાર્ય છે.

82
00:04:03,730 --> 00:04:07,220
સ્ક્રોલ, આ વસ્તુઓ નો સંદર્ભ લો
કહેવાતા રજિસ્ટર ખૂબ નાના ટુકડા

83
00:04:07,220 --> 00:04:09,190
તમારી વાસ્તવિક CPU ના મેમરી આધારિત છે.

84
00:04:09,190 --> 00:04:12,930
અને હું પણ સરકાવો જો
વધુમાં, હું અમુક પ્રકારના જુઓ

85
00:04:12,930 --> 00:04:14,240
ASCII ઓફ પરોક્ષ ઉલ્લેખ થાય છે.

86
00:04:14,240 --> 00:04:17,120
અને, ખરેખર, તે સ્ટ્રિંગ છે,
હેલ્લો, અલ્પવિરામ, વર્લ્ડ.

87
00:04:17,120 --> 00:04:20,079
>> તેથી લાંબા વાર્તા ટૂંકી, આ રહ્યું છે
, આપોઆપ, તમારા માટે શું થઈ રહ્યું

88
00:04:20,079 --> 00:04:22,140
હૂડ નીચે આ સમયે બધા.

89
00:04:22,140 --> 00:04:26,450
અને શું થઈ રહ્યું રહ્યું છે ખરેખર એક વાર છે
તમે રણકાર ચલાવો, અથવા માર્ગ દ્વારા કર્યું

90
00:04:26,450 --> 00:04:29,150
, તમારે પ્રથમ રહ્યાં છો, બનાવો
સ્ત્રોત કોડ માંથી

91
00:04:29,150 --> 00:04:30,700
એસેમ્બલી ભાષા કહેવાતી.

92
00:04:30,700 --> 00:04:35,210
પછી રણકાર આ વિધાનસભા રૂપાંતર થયેલ છે
નીચે zeros અને રાશિઓ માટે ભાષા.

93
00:04:35,210 --> 00:04:38,340
અને આ અમે શરૂ સ્લાઇડ છે
પર અઠવાડિયું 0 અમારા ચર્ચા -

94
00:04:38,340 --> 00:04:39,840
અને પછી પર અઠવાડિયું 1.

95
00:04:39,840 --> 00:04:44,030
અને પછી છેવટે, તે zeros અને રાશિઓ
જો zeros અને રાશિઓ સાથે જોડવામાં આવે છે

96
00:04:44,030 --> 00:04:47,190
તે પુસ્તકાલયો પરથી આપણે લઈ આવી છે
ધોરણ I / O અથવા જેમ મંજૂર માટે

97
00:04:47,190 --> 00:04:50,010
શબ્દમાળા લાઇબ્રેરી અથવા પણ
જો CS50 પુસ્તકાલય.

98
00:04:50,010 --> 00:04:54,200
>> તેથી વધુ આ ચિત્ર કરું
દૃષ્ટિની, અમે hello.c છે.

99
00:04:54,200 --> 00:04:57,220
અને તે, અલબત્ત, આ printf વાપરે છે
હેલો વર્લ્ડ, કહે કાર્ય કરે છે.

100
00:04:57,220 --> 00:05:01,810
આ સંકલન પગલું રન લે છે
તે ફાઈલ આપણે પણ hello.s જોયું

101
00:05:01,810 --> 00:05:04,290
સામાન્ય રીતે કાઢી નાખવામાં આવ્યું છે કે તેમ છતાં
આપોઆપ તમારા માટે.

102
00:05:04,290 --> 00:05:06,050
પરંતુ તે વિધાનસભા કોડ છે
મધ્યમ પગલું છે.

103
00:05:06,050 --> 00:05:09,750
અને પછી અમે વિધાનસભા ભેગા ત્યારે
જ્યારે તમે ભાષા, જેથી વાત કરવા માટે, કે

104
00:05:09,750 --> 00:05:10,830
તે zeros અને રાશિઓ વિચાર.

105
00:05:10,830 --> 00:05:13,920
તેથી અમે આજે અસરકારક માં ઝૂમ કરેલું કર્યું
શું મંજૂર માટે અમે લઈ કરવામાં આવ્યા છે,

106
00:05:13,920 --> 00:05:16,430
સ્ત્રોત કોડ જવા અર્થ એ થાય
કોડ વાંધો નહીં.

107
00:05:16,430 --> 00:05:18,850
>> પરંતુ છેલ્લે, હવે તે જ ચિત્ર -
તે બોલ ધક્કો લેટ્સ

108
00:05:18,850 --> 00:05:20,020
ડાબી બાજુ.

109
00:05:20,020 --> 00:05:22,880
અને નોંધો કે ટોચ ત્યાં
હું stdio.h ઉલ્લેખ કર્યો છે.

110
00:05:22,880 --> 00:05:25,030
કે અમે સમાવેશ કર્યા છે કે ફાઈલ છે
લગભગ તમામ માં

111
00:05:25,030 --> 00:05:26,250
અમે લખેલા કર્યું કાર્યક્રમો.

112
00:05:26,250 --> 00:05:28,830
અને તે કે જેના સમાવિષ્ટો ફાઈલની
નકલ પેસ્ટ કરો,

113
00:05:28,830 --> 00:05:30,350
અસરકારક રીતે તમારો કોડ માથે.

114
00:05:30,350 --> 00:05:34,170
પરંતુ તે છે કે, એક કમ્પ્યુટર પર બહાર વળે
સિસ્ટમ ક્યાંક, અનુમાન એક છે

115
00:05:34,170 --> 00:05:39,150
કોઈને વર્ષ લખ્યું હતું કે stdio.c ફાઇલ
પહેલાં કે તમામ અમલીકરણ

116
00:05:39,150 --> 00:05:41,870
જાહેર કરવામાં આવ્યા હતા કે કાર્યો
stdio.h છે.

117
00:05:41,870 --> 00:05:45,465
>> હવે વાસ્તવિકતા માં તેના પર કદાચ નથી
અથવા પણ તમારા મેક કે તમારા પીસી

118
00:05:45,465 --> 00:05:47,660
CS50 સાધન કાચું સી કોડ છે.

119
00:05:47,660 --> 00:05:52,710
કોઇકે પહેલેથી તે સંકલન અને સમાવેશ થાય છે
. ઓ પદાર્થ કોડ માટે ફાઈલ અથવા. એક

120
00:05:52,710 --> 00:05:56,020
વહેંચાયેલ લાઈબ્રેરીનો ઉલ્લેખ કરે છે, જે ફાઇલ,
કે પૂર્વ સ્થાપિત કરવામાં આવી છે

121
00:05:56,020 --> 00:05:57,240
જો તમે પહેલાથી કમ્પાઇલ કરેલ છે.

122
00:05:57,240 --> 00:06:01,950
પરંતુ ખરેખર અસ્તિત્વ ધરાવે છે કે જે ધારવું
સમાંતર અમારા કમ્પ્યુટર પર stdio.c

123
00:06:01,950 --> 00:06:02,650
રણકાર સાથે.

124
00:06:02,650 --> 00:06:04,960
તમારો કોડ કમ્પાઈલ કરવામાં આવી રહ્યું છે
અને એસેમ્બલ.

125
00:06:04,960 --> 00:06:09,200
stdio.c 'ઓ કોડ કમ્પાઈલ અને આવી રહી છે
એસેમ્બલ છે, તેથી આ ખૂબ જ છેલ્લા કે

126
00:06:09,200 --> 00:06:13,730
અહીં નીચે, પગલું, અમે અચાનક છે
કડી, તેથી વાત કરવા માટે, તમારા zeros અને રાશિઓ

127
00:06:13,730 --> 00:06:18,430
એક માં તેના અથવા તેણીના zeros અને રાશિઓ સાથે
આખરે છે કે સાદા કાર્યક્રમની

128
00:06:18,430 --> 00:06:20,540
હેલો માત્ર કહેવાય છે.

129
00:06:20,540 --> 00:06:23,340
>> કે જેથી તે જાદુ બધા ચોક્કો
આમ અત્યાર સુધી રહ્યું કરવામાં આવી.

130
00:06:23,340 --> 00:06:26,430
અને આ લેવા માટે ચાલુ રહેશે
માટે પ્રક્રિયાઓ મંજૂર છે, પરંતુ ખ્યાલ

131
00:06:26,430 --> 00:06:28,750
રસદાર વિગતો ઘણો છે
ત્યાં નીચે ચાલે.

132
00:06:28,750 --> 00:06:31,920
અને આ છે તે છે તમારા
ઇન્ટેલ ઇનસાઇડ સાથે કમ્પ્યુટર

133
00:06:31,920 --> 00:06:33,940
ખાસ કરીને અલગ.

134
00:06:33,940 --> 00:06:37,020
>> તેથી નોંધ કરો કે, તમને ગમશે તો
આ શુક્રવાર બપોરના અમને જોડાવા, જાઓ કરવું

135
00:06:37,020 --> 00:06:41,570
સામાન્ય સ્થળ cs50.net/rsvp માટે,
1:15 PM પર પોસ્ટેડ આ શુક્રવાર.

136
00:06:41,570 --> 00:06:43,400
અને હવે થોડા જાહેરાત.

137
00:06:43,400 --> 00:06:44,670
તેથી અમે કેટલાક સારા સમાચાર છે.

138
00:06:44,670 --> 00:06:45,970
અને અમે કેટલાક ખરાબ સમાચાર છે.

139
00:06:45,970 --> 00:06:47,260
અહીં કેટલાક સારા સમાચાર સાથે શરૂ કરો.

140
00:06:47,260 --> 00:06:52,038

141
00:06:52,038 --> 00:06:54,510
>> [કિચૂડ કિચૂડ અવાજ કરતું]

142
00:06:54,510 --> 00:06:54,710
>> બધા અધિકાર.

143
00:06:54,710 --> 00:06:56,670
ઠીક છે, તેથી તે, ટેકનીકલી રજા છે
તેથી તે ખૂબ અમારી પાસેથી ભેટ નથી.

144
00:06:56,670 --> 00:06:58,030
અલબત્ત, પરંતુ પછી ખરાબ સમાચાર.

145
00:06:58,030 --> 00:07:00,550

146
00:07:00,550 --> 00:07:01,880
>> [કિચૂડ કિચૂડ અવાજ કરતું]

147
00:07:01,880 --> 00:07:03,530
>> હું સમય ઘણો ખર્ચ્યા
આ એનિમેશન છે.

148
00:07:03,530 --> 00:07:04,690
>> [હાસ્ય]

149
00:07:04,690 --> 00:07:07,000
>> એક સમીક્ષા સત્ર હશે
આ સોમવાર આવતા.

150
00:07:07,000 --> 00:07:08,340
તે 5:30 PM પર પોસ્ટેડ ખાતે જશે.

151
00:07:08,340 --> 00:07:11,210
અમે આ બધા વિગતો તમને યાદ કરશે
કોર્સ માતાનો પર ઇમેઇલ દ્વારા

152
00:07:11,210 --> 00:07:13,470
ટ્રેડીંગ સમય માત્ર એક દંપતિ માં વેબસાઇટ.

153
00:07:13,470 --> 00:07:16,610
તે ફિલ્માંકન અને ઉપલબ્ધ કરવામાં આવશે
ત્યારબાદ ટૂંક સમયમાં.

154
00:07:16,610 --> 00:07:19,200
તમે કરી શકતા નથી તેથી જો કે સોમવાર
રાત્રે સ્લોટ, ચિંતા ન કરશો.

155
00:07:19,200 --> 00:07:22,270
વિભાગો આ આગામી સપ્તાહ પણ ચાલશે
ક્વિઝ માટે સમીક્ષા પર ધ્યાન કેન્દ્રિત.

156
00:07:22,270 --> 00:07:25,670
તમારા વિભાગ છે જે સોમવાર, પર છે
ખરેખર યુનિવર્સિટીમાં રજા, અમે ચાલશે

157
00:07:25,670 --> 00:07:26,920
હજુ વિભાગ માં પૂરી.

158
00:07:26,920 --> 00:07:28,890
તમે ખાલી કે ન કરી શકે તો
વિભાગ તમને જઈ રહ્યાં છો કારણ કે

159
00:07:28,890 --> 00:07:29,860
દૂર, કે દંડ છે.

160
00:07:29,860 --> 00:07:33,710
એક રવિવાર કે મંગળવાર વિભાગ કે હાજર
જેસન માતાનો વિભાગમાં ટ્યુન માં, છે

161
00:07:33,710 --> 00:07:35,110
ઓનલાઇન ઉપલબ્ધ.

162
00:07:35,110 --> 00:07:37,490
>> તેથી, વધુ ખરાબ સમાચાર.

163
00:07:37,490 --> 00:07:41,960
તેથી અભ્યાસક્રમ અનુસાર,
અમે આગામી શુક્રવાર વ્યાખ્યાન છે.

164
00:07:41,960 --> 00:07:43,690
પરંતુ સારા સમાચાર -

165
00:07:43,690 --> 00:07:44,860
સ્પષ્ટ રીતે, હું આ પર પણ ઘણો સમય પસાર કર્યો.

166
00:07:44,860 --> 00:07:45,280
>> [હાસ્ય]

167
00:07:45,280 --> 00:07:47,140
>> અમે શુક્રવાર ભાષણો આગામી રદ પડશે.

168
00:07:47,140 --> 00:07:50,590
કે જેથી આપણા માટે એક ભેટ હશે, જેથી તમે
ખરેખર સરસ રાહત માં કરી શકો છો

169
00:07:50,590 --> 00:07:52,990
આ સપ્તાહ અને તેથી બે અઠવાડિયા વચ્ચે.

170
00:07:52,990 --> 00:07:57,460
આ બોલ પર કોઈ વ્યાખ્યાન આગામી સપ્તાહ, માત્ર એક નાના તેથી
તમે પ્રયત્ન કરીશું કે જેના માટે થોડી ક્વિઝ,

171
00:07:57,460 --> 00:07:59,030
વધુને વધુ ઉત્સાહિત થયા.

172
00:07:59,030 --> 00:08:03,870
>> તેથી હવે અમારા ધ્યાન ચાલુ દો
ખરેખર વધુ દ્રશ્ય કે કંઈક

173
00:08:03,870 --> 00:08:06,990
અને વધુ ઉત્તેજક અને સ્ટેજ સુયોજિત કરવા માટે
ક્ષિતિજ પર જશે તે માટે

174
00:08:06,990 --> 00:08:08,420
અઠવાડિયા સમય માત્ર એક દંપતિ છે.

175
00:08:08,420 --> 00:08:12,160
પ્રથમ ક્વિઝ પછી, અમે ચાલુ કરીશું
અમારા સમસ્યા સેટમાં અન્ય ધ્યાન કેન્દ્રિત

176
00:08:12,160 --> 00:08:16,710
ડોમેન ચોક્કસ સમસ્યા, કે
વધુ સામાન્ય વિદેશી અથવા સુરક્ષા.

177
00:08:16,710 --> 00:08:19,550
>> આ સમસ્યા સાથે હકીકતમાં, પરંપરા
સમૂહ મારા માટે એક છે

178
00:08:19,550 --> 00:08:24,850
સમગ્ર જવામાં સાથી અથવા સીએએસ શિક્ષણ
કેટલાક ફોટોગ્રાફ્સ લેવા કેમ્પસ

179
00:08:24,850 --> 00:08:29,450
ઓળખી પરંતુ બિન સ્પષ્ટ લોકો,
પછી સ્થળો, અથવા વસ્તુઓ, દર વર્ષે હું

180
00:08:29,450 --> 00:08:34,520
અચાનક આકસ્મિક કાઢી નાખવા મેનેજ કરો
અથવા ડિજિટલ મીડિયા કાર્ડ ભ્રષ્ટ

181
00:08:34,520 --> 00:08:35,720
અમારી કેમેરા ની અંદર છે.

182
00:08:35,720 --> 00:08:36,860
પરંતુ કોઈ મોટા સોદો.

183
00:08:36,860 --> 00:08:39,200
હું આગળ જાઓ અને પ્લગ કરી શકો છો
મારા કમ્પ્યુટરને માં છે.

184
00:08:39,200 --> 00:08:43,010
હું તેથી, તે એક ફોરેન્સિક ઇમેજ બનાવી શકે છે
જો zeros કૉપિ કરીને, વાત અને

185
00:08:43,010 --> 00:08:46,830
કે મેમરી કાર્ડ રાશિઓ બંધ છે કે નહીં,
તેના SD કાર્ડ અથવા કોમ્પેક્ટ ફ્લેશ કાર્ડ અથવા

186
00:08:46,830 --> 00:08:48,100
તમે પરિચિત છો ગમે.

187
00:08:48,100 --> 00:08:49,300
અને પછી અમે તે બહાર હાથ કરી શકો છો.

188
00:08:49,300 --> 00:08:53,190
>> અને તેથી અન્ય વચ્ચે આગળ પડકાર,
તમે માટે વસ્તુઓ લખવા માટે હશે

189
00:08:53,190 --> 00:08:58,630
એક આખી ટોળું ધક્કામાંથી કે સી કોડ
મારા માટે JPEGs અને જાહેર થશે

190
00:08:58,630 --> 00:09:00,190
તે લોકો, સ્થળો, અથવા વસ્તુઓ.

191
00:09:00,190 --> 00:09:03,340
અને અમે પણ આ સમસ્યા છે, વાત કરીશું
સેટ અને દિવસ વિશે, આવવા

192
00:09:03,340 --> 00:09:04,440
વધુ સામાન્ય ગ્રાફિક્સ.

193
00:09:04,440 --> 00:09:06,140
અમે, એક કોર્સ તેમને ઉપયોગ કર્યા
બહાર ભંગ માટે.

194
00:09:06,140 --> 00:09:09,080
મંજૂર, પરંતુ તમે પ્રકારના ભર્યું છે
આ ઉચ્ચ સ્તર માન્યતા ત્યાં હાજર છે

195
00:09:09,080 --> 00:09:10,680
લંબચોરસ અને ovals છે.

196
00:09:10,680 --> 00:09:12,450
પરંતુ હૂડ નીચે
પિક્સેલ્સ છે.

197
00:09:12,450 --> 00:09:14,370
અને તમે શરૂ કરવા માટે આવી હોય
તે વિશે વિચારવાનો.

198
00:09:14,370 --> 00:09:18,800
અથવા તમે પૃષ્ઠ સેટ 4 વિચારવું પડશે માટે
તમારા ઇંટો વચ્ચે તફાવત વિશે કેવી રીતે

199
00:09:18,800 --> 00:09:21,990
ઝડપથી તમે બોલ સમગ્ર ખસેડવાની છે રહ્યાં છો
માટે સ્ક્રીન બહાર તૂટી જાય છે.

200
00:09:21,990 --> 00:09:24,830
તેથી આ ખ્યાલ છે
કે તમારી સ્ક્રીન પર બિંદુઓ

201
00:09:24,830 --> 00:09:26,290
પહેલેથી જ નાટક થવું.

202
00:09:26,290 --> 00:09:29,430
>> હવે તમે જુઓ શું છે, જોકે, શું છે
તમે કમ્પ્યુટર સ્ક્રીન પર મેળવો.

203
00:09:29,430 --> 00:09:33,680
તમે ક્યારેય કેટલાક સારા અથવા નિહાળવામાં કર્યું છે
ખરાબ ટીવી, અવરોધો તેઓ ખૂબ ખૂબ છે

204
00:09:33,680 --> 00:09:36,280
technophobes જેવા પ્રેક્ષકોને સારવાર
જે નથી ખરેખર કરવું

205
00:09:36,280 --> 00:09:37,630
ખૂબ કમ્પ્યુટિંગ વિશે ખબર.

206
00:09:37,630 --> 00:09:40,840
અને તેથી તે પોલીસ માટે ખૂબ જ સરળ છે
કહે ડિટેક્ટીવ, તમે આ કરી શકો છો

207
00:09:40,840 --> 00:09:41,710
મારા માટે કે સાફ?

208
00:09:41,710 --> 00:09:42,710
અથવા જમણે, વધારવા?

209
00:09:42,710 --> 00:09:45,550
એન્હેન્સ માં Buzz શબ્દ જેવી છે
સૌથી વધુ કોઈપણ ગુના સંબંધિત શો.

210
00:09:45,550 --> 00:09:49,240
જો તમે ખૂબ લેવા તો વાસ્તવિકતા છે
કરવાથી શંકા છે blurry ચિત્ર

211
00:09:49,240 --> 00:09:51,620
કંઇક ખરાબ, તમે કરી શકતા નથી
માત્ર તે વધારે છે.

212
00:09:51,620 --> 00:09:53,080
તમે અનંત ઝૂમ કરી શકતા નથી.

213
00:09:53,080 --> 00:09:56,350
તમે કોઈને ના તેજનો ચમકારો જોવા નથી કરી શકો છો
કે પ્રતિબદ્ધ જે આંખ

214
00:09:56,350 --> 00:09:59,860
જો હોવા છતાં ખાસ અપરાધ,
ટીવી પર આ ફેલાવો.

215
00:09:59,860 --> 00:10:04,110
>> અને જેથી માતાનો ઉત્સાહિત દો સાથે
આગામી સમસ્યા પર એક ઝલક સાથે સુયોજિત

216
00:10:04,110 --> 00:10:05,765
કેટલાક શો છે, જે સાથે તમે
પરિચિત હોઈ શકે છે.

217
00:10:05,765 --> 00:10:06,500
>> [વિડિઓ પ્લેબેક]

218
00:10:06,500 --> 00:10:07,835
>> -ઠીક.

219
00:10:07,835 --> 00:10:09,956
હવે, તમે એક સારા દેખાવ વિચાર કરીએ.

220
00:10:09,956 --> 00:10:17,060

221
00:10:17,060 --> 00:10:17,766
>> તે પકડો.

222
00:10:17,766 --> 00:10:18,658
કે પાછા ચલાવો.

223
00:10:18,658 --> 00:10:19,550
>> એક મિનિટ પ્રતીક્ષા-.

224
00:10:19,550 --> 00:10:21,580
અધિકાર જાઓ.

225
00:10:21,580 --> 00:10:21,800
>> -હતી.

226
00:10:21,800 --> 00:10:22,690
કે સ્થિર કરો.

227
00:10:22,690 --> 00:10:23,692
>> સ્ક્રીન પૂર્ણ.

228
00:10:23,692 --> 00:10:23,846
>> -ઠીક.

229
00:10:23,846 --> 00:10:24,154
કે સ્થિર કરો.

230
00:10:24,154 --> 00:10:25,140
>> યા, કે જે પર આવશે અપ વધુ કડક?

231
00:10:25,140 --> 00:10:27,090
>> કે વ્યક્તિ પર વેક્ટર
પાછળ વ્હીલ દ્વારા.

232
00:10:27,090 --> 00:10:29,730
>> આ સ્થળ પર અધિકાર અહીં-મોટું.

233
00:10:29,730 --> 00:10:33,700
>> -સાથે યોગ્ય સાધનો, આ તસવીર
ફૂલે અને sharpened કરી શકાય છે.

234
00:10:33,700 --> 00:10:34,490
>> -શું કે છે?

235
00:10:34,490 --> 00:10:35,870
>> ઇટ ઉન્નતીકરણ કાર્યક્રમ છે.

236
00:10:35,870 --> 00:10:36,793
>> -શકાતી તમે કોઈપણ અપ કે સાફ?

237
00:10:36,793 --> 00:10:38,560
>> હું ખબર નથી.

238
00:10:38,560 --> 00:10:39,090
માતાનો તેને વધારવા દો.

239
00:10:39,090 --> 00:10:41,690
>> વિભાગ એ 6 એન્હેન્સ.

240
00:10:41,690 --> 00:10:43,510
>> -I વિગતવાર વધારી અને -

241
00:10:43,510 --> 00:10:44,456
>> હું વધારવા માટે ત્યાં પૂરતી છે એવું લાગે છે.

242
00:10:44,456 --> 00:10:45,402
મારા સ્ક્રીન પર તે રિલીઝ.

243
00:10:45,402 --> 00:10:47,300
>> તેના આંખ માં પ્રતિબિંબ-એન્હેન્સ.

244
00:10:47,300 --> 00:10:49,330
>> માતાનો આ દ્વારા રન દો
વિડિઓ વધારવી.

245
00:10:49,330 --> 00:10:50,340
>> -એડગર, તમે આ વધારવા કરી શકો છો?

246
00:10:50,340 --> 00:10:52,320
>> પર અટકી.

247
00:10:52,320 --> 00:10:54,290
>> -I've આ પ્રતિબિંબ પર કામ કરવામાં આવ્યું.

248
00:10:54,290 --> 00:10:55,560
>> -કોઇએ માતાનો પ્રતિબિંબ.

249
00:10:55,560 --> 00:10:56,440
>> -રિફ્લેક્શન.

250
00:10:56,440 --> 00:10:57,940
>> પ્રતિબિંબ-નથી
માણસ માતાનો ચહેરો.

251
00:10:57,940 --> 00:10:58,860
>> -પ્રતિબિંબ.

252
00:10:58,860 --> 00:10:59,710
>> -ત્યાં એક પ્રતિબિંબ છે.

253
00:10:59,710 --> 00:11:00,900
>> આ મિરર પર ઇન ઝૂમ વધારો.

254
00:11:00,900 --> 00:11:03,500
>> તમને એક પ્રતિબિંબ જોઈ શકો છો.

255
00:11:03,500 --> 00:11:04,700
>> -શકો છો અહીં ઇમેજ વધારવા?

256
00:11:04,700 --> 00:11:05,700
>> -શકો છો અહીં તેને વધારવા?

257
00:11:05,700 --> 00:11:06,500
>> -શકાતી તમે તેને વધારવા?

258
00:11:06,500 --> 00:11:07,380
>> -શકાતી તમે તેને વધારવા?

259
00:11:07,380 --> 00:11:08,190
>> -શકાતી અમે આ વધારવા?

260
00:11:08,190 --> 00:11:08,940
>> -શકાતી તમે તેને વધારવા?

261
00:11:08,940 --> 00:11:10,280
>> એક બીજા પર પકડ, હું વધારવા પડશે.

262
00:11:10,280 --> 00:11:11,570
>> દરવાજા પર ઇન ઝૂમ વધારો.

263
00:11:11,570 --> 00:11:12,180
>> -X10.

264
00:11:12,180 --> 00:11:13,052
>> -મોટું.

265
00:11:13,052 --> 00:11:13,197
>> [હાસ્ય]

266
00:11:13,197 --> 00:11:14,360
>> સાઇન-ખસેડો

267
00:11:14,360 --> 00:11:15,100
>> બંધ,-પ્રતીક્ષા.

268
00:11:15,100 --> 00:11:15,740
>> -રોકો.

269
00:11:15,740 --> 00:11:16,290
>> તે વિરામ.

270
00:11:16,290 --> 00:11:19,390
>> આસપાસ 75 ડિગ્રી-ફેરવો
ઊભી કરો.

271
00:11:19,390 --> 00:11:19,886
>> [હાસ્ય]

272
00:11:19,886 --> 00:11:24,350
>> ભાગ માટે બેક રોકો, અને
દરવાજા વિશે ફરી.

273
00:11:24,350 --> 00:11:26,330
>> એક છબી enhancer-ગોટ
કે બીટમેપ કરી શકો છો?

274
00:11:26,330 --> 00:11:28,990
>> -કદાચ અમે પ્રદીપ સેન ઉપયોગ કરી શકો છો
પદ્ધતિ વિન્ડો માં જોવા માટે.

275
00:11:28,990 --> 00:11:30,680
>> -આ સોફ્ટવેર કલાના રાજ્ય છે.

276
00:11:30,680 --> 00:11:31,676
>> ધ ચિહ્ન કિંમત બંધ છે.

277
00:11:31,676 --> 00:11:34,166
>> -સાથે યોગ્ય મિશ્રણ
ગાણિતીક નિયમો છે.

278
00:11:34,166 --> 00:11:38,399
>> -કુલ પર પ્રકાશ ગાણિતીક નિયમો લેવામાં આવ્યું છે
આગલા સ્તર અને હું તેમને ઉપયોગ કરી શકો છો

279
00:11:38,399 --> 00:11:38,648
આ ફોટોગ્રાફ વધારે છે.

280
00:11:38,648 --> 00:11:42,050
>> પર લોક અને Z-અક્ષ મોટું.

281
00:11:42,050 --> 00:11:42,760
>> -એન્હેન્સ.

282
00:11:42,760 --> 00:11:43,060
>> -એન્હેન્સ.

283
00:11:43,060 --> 00:11:43,760
>> -એન્હેન્સ.

284
00:11:43,760 --> 00:11:45,010
>> -સ્થિર અને વધારે છે.

285
00:11:45,010 --> 00:11:47,470

286
00:11:47,470 --> 00:11:47,910
>> [END વિડિઓ પ્લેબેક]

287
00:11:47,910 --> 00:11:51,470
>> ડેવિડ જે MALAN: તેથી સમસ્યા સમૂહ
5 ત્યાં આગળ આવેલું છે.

288
00:11:51,470 --> 00:11:55,260
તેથી અમે તરત જ સારી સમજ મળશે
જ્યારે અને શા માટે તમે આ કરી શકો છો કે

289
00:11:55,260 --> 00:11:57,300
અને અમારા જે રીતે વિસ્તૃત કરી શકતાં નથી.

290
00:11:57,300 --> 00:12:00,090
પરંતુ પ્રથમ, ચાલો અમારા ધ્યાન પાછા દો
અમે કરીશું મકાન બ્લોકો કેટલાક

291
00:12:00,090 --> 00:12:02,250
કે વાર્તા કહી સમક્ષ રજુ કરવાનો પ્રયત્ન કરવાની જરૂર છે.

292
00:12:02,250 --> 00:12:05,580
>> તેથી અમે આ ચિત્ર પર દોર્યું કે યાદ
સોમવારે અને થોડી છેલ્લા અઠવાડિયે.

293
00:12:05,580 --> 00:12:09,970
અને આ વસ્તુઓ લેઆઉટ વર્ણવે છે
તમારા કમ્પ્યુટરની મેમરી ત્યારે

294
00:12:09,970 --> 00:12:11,000
અમુક કાર્યક્રમ ચાલી.

295
00:12:11,000 --> 00:12:14,310
ઉપર ટેક સેગમેન્ટમાં, બોલાવવાનો, સંદર્ભ લે છે
વાસ્તવિક zeros અને રાશિઓ માટે

296
00:12:14,310 --> 00:12:16,000
જે તમારા કાર્યક્રમ કંપોઝ.

297
00:12:16,000 --> 00:12:19,340
ત્યાં, કે નીચે, કેટલાક આરંભ અથવા
uninitialized માહિતી છે, કે જે સામાન્ય રીતે

298
00:12:19,340 --> 00:12:22,910
અથવા સ્થિરાંકો જેવી વસ્તુઓ ઉલ્લેખ કરે છે
શબ્દમાળાઓ કે છે કે વૈશ્વિક ચલો

299
00:12:22,910 --> 00:12:24,200
અગાઉથી જાહેર કરવામાં આવ્યું.

300
00:12:24,200 --> 00:12:26,500
ત્યાં ઢગલો છે, પરંતુ અમે આવો પડશે
પાછા બીટ છે કે નહીં.

301
00:12:26,500 --> 00:12:27,410
>> અને પછી સ્ટેક નથી.

302
00:12:27,410 --> 00:12:30,660
મોટા ભાગનું માં ટ્રેની એક સ્ટેક જેવી
મેમરી બોલ જ્યાં કાફેટેરિયા, આ છે

303
00:12:30,660 --> 00:12:33,610
સ્તરવાળી અને જ્યારે સ્તરવાળી
તમે એક કાર્યક્રમ શું છે?

304
00:12:33,610 --> 00:12:36,380

305
00:12:36,380 --> 00:12:37,730
માટે સ્ટેક ઉપયોગ શું છે?

306
00:12:37,730 --> 00:12:39,320
>> યાહ?

307
00:12:39,320 --> 00:12:40,000
>> કાર્ય કૉલ કરો.

308
00:12:40,000 --> 00:12:42,890
તમે એક કાર્ય કૉલ કોઈપણ સમયે, તે છે
તેના માટે મેમરી sliver આપવામાં

309
00:12:42,890 --> 00:12:45,020
સ્થાનિક ચલો અથવા તેના પરિમાણો.

310
00:12:45,020 --> 00:12:48,810
અને pictorially, અમે જુઓ કે જે દરેક સાથે
જ્યારે ક્રમિક કાર્ય કહેવાય

311
00:12:48,810 --> 00:12:52,520
કોલ્સ બી કોલ્સ સી કોલ્સ ડી, તેઓ
સ્ટેક પર સ્તરવાળી મળે છે.

312
00:12:52,520 --> 00:12:55,630
અને તે કાપી નાંખ્યું દરેક અંદર
મેમરી અનિવાર્યપણે એક અનન્ય સ્કોપ છે

313
00:12:55,630 --> 00:12:58,590
કે કાર્ય માટે છે, કે જે કોર્સ છે,
તમે હાથ માંગો, તો સમસ્યાજનક છે

314
00:12:58,590 --> 00:13:01,850
એક કાર્ય બીજા એક ભાગ માટે
તમે તેને કરવા માંગો છો કે જે માહિતી

315
00:13:01,850 --> 00:13:03,500
પરિવર્તનશીલ પણ બનાવાય અથવા બદલવા માટે.

316
00:13:03,500 --> 00:13:08,060
>> તેથી સક્રિય કરવા માટે અમારા ઉકેલ શું હતું
એક સ્ટેક દ્વારા રજૂ કાર્ય

317
00:13:08,060 --> 00:13:11,390
અંદર મેમરી બદલવા માટે ફ્રેમની
અન્ય સ્ટેક ફ્રેમ?

318
00:13:11,390 --> 00:13:14,590
કેવી રીતે એક બીજા માટે તે બે ચર્ચા કરે છે?

319
00:13:14,590 --> 00:13:18,510
તેથી પોઇન્ટર અથવા સરનામાં માર્ગ દ્વારા,
જ્યાં જે, ફરી, માત્ર વર્ણન

320
00:13:18,510 --> 00:13:22,280
ચોક્કસ ઓફ મેમરી, દ્વારા માર્ગ
ડંખ નંબર, ચોક્કસ

321
00:13:22,280 --> 00:13:23,830
કિંમત મળી શકે છે.

322
00:13:23,830 --> 00:13:26,860
તેથી અમે ચાલુ રાખ્યું છેલ્લા સમય યાદ
એક સમયે વાર્તા અને જોવામાં

323
00:13:26,860 --> 00:13:28,280
એકદમ બગડેલ કાર્યક્રમ.

324
00:13:28,280 --> 00:13:32,900
અને આ કાર્યક્રમ થોડા માટે બગડેલ છે
કારણો છે, પરંતુ સૌથી worrisome એક છે

325
00:13:32,900 --> 00:13:34,620
તે શું તપાસો નિષ્ફળ જાય છે કારણ કે?

326
00:13:34,620 --> 00:13:39,111

327
00:13:39,111 --> 00:13:40,450
>> અરે વાહ, તે ઇનપુટ તપાસો નિષ્ફળ જાય છે.

328
00:13:40,450 --> 00:13:41,870
માફ કરશો?

329
00:13:41,870 --> 00:13:43,880
>> તે 12 અક્ષરો કરતાં વધુ છે, તો.

330
00:13:43,880 --> 00:13:47,260
તેથી ખૂબ જ smartly, memcopy કૉલ કરતી વખતે,
જે નામ સૂચવે છે, માત્ર

331
00:13:47,260 --> 00:13:50,630
તેના બીજા દલીલ માંથી નકલો મેમરી
તેની પ્રથમ દલીલ માં.

332
00:13:50,630 --> 00:13:54,730
ત્રીજા દલીલ ખૂબ smartly છે,
તમે નથી તેની ખાતરી કરવા માટે ચેક

333
00:13:54,730 --> 00:13:59,400
પણ, આ કિસ્સામાં, લંબાઈ કરતાં વધુ નકલ
બાર છે, અક્ષરો નંબર,

334
00:13:59,400 --> 00:14:03,810
અંતિમ મુકામ માં છે, કે જે આ છે
અરે સી પરંતુ સમસ્યા એ છે કે શું

335
00:14:03,810 --> 00:14:07,230
સી પોતે પૂરતી મોટી નથી તો
કે નિયંત્રિત કરવા માટે?

336
00:14:07,230 --> 00:14:09,900
તમે નંબર નકલ કરવા જઈ રહ્યાં છો
તમે આપવામાં આવી છે તે બાઇટ્સ.

337
00:14:09,900 --> 00:14:13,040
પરંતુ તમે ખરેખર વધુ શું હોય છે
તમે માટે જગ્યા હોય કરતાં બાઇટ્સ?

338
00:14:13,040 --> 00:14:16,770
>> વેલ, આ કાર્યક્રમ ખૂબ જ foolishly માત્ર
આંખ મીંચીને તે ગમે લેવા આગળ

339
00:14:16,770 --> 00:14:20,650
આપવામાં હેલ્લો બેકસ્લેશ 0 છે
સ્ટ્રિંગ ટૂંકા છે મહાન જો

340
00:14:20,650 --> 00:14:22,040
પૂરતી છે, પાંચ અક્ષરો છે.

341
00:14:22,040 --> 00:14:26,470
પરંતુ વાસ્તવમાં તે 12 અક્ષરો છે અથવા તો
1,200 અક્ષરો, અમે છેલ્લા સમય જોયું

342
00:14:26,470 --> 00:14:29,380
તમે માત્ર સંપૂર્ણપણે કરવા જઈ રહ્યાં છો કે જે
મેમરી પર ફરીથી લખી કે

343
00:14:29,380 --> 00:14:30,470
તમે ને અનુલક્ષતું નથી.

344
00:14:30,470 --> 00:14:34,390
અને ખરાબમાં ખરાબ કિસ્સામાં, તમે ફરીથી લખી જો કે
અમે કહેવાય છે કે ત્યાં લાલ ભાગ

345
00:14:34,390 --> 00:14:35,380
સરનામા પાછા -

346
00:14:35,380 --> 00:14:38,370
આ છે માત્ર જ્યાં કમ્પ્યુટર
આપોઆપ, તમે માટે, પાછળ

347
00:14:38,370 --> 00:14:43,130
દૂર દ્રશ્યો, બનાવ્યો એક 32-bit કિંમત છે કે જે
તે જોઈએ તે સરનામા માટે તેને યાદ અપાવે છે

348
00:14:43,130 --> 00:14:47,080
પાછા જ્યારે foo, આ અન્ય કાર્ય,
અમલ કરવામાં આવે છે.

349
00:14:47,080 --> 00:14:49,320
તે પ્રકારના એક બ્રેડ નાનો ટુકડો બટકું છે
જે તે આપે છે.

350
00:14:49,320 --> 00:14:52,490
તમે સંભવિત છે કે, જો પર ફરીથી લખી
તમે ખરાબ વ્યક્તિ હો, તો કરી શકો છો શકે

351
00:14:52,490 --> 00:14:54,750
સંભવિત લેવા
કોઈના કમ્પ્યુટર.

352
00:14:54,750 --> 00:14:58,020
અને તમે સૌથી વધુ ચોક્કસપણે પડશે
મોટા ભાગના કિસ્સાઓમાં તે ભંગાણ.

353
00:14:58,020 --> 00:15:01,690
>> હવે આ સમસ્યા માત્ર ઉત્તેજિત કરવામાં આવી હતી
અમે મેમરી વિશે વાત શરૂ

354
00:15:01,690 --> 00:15:03,010
વધુ સામાન્ય મેનેજમેન્ટ.

355
00:15:03,010 --> 00:15:07,150
અને malloc, મેમરી ફાળવણી માટે છે, એક
અમે ફાળવવા માટે ઉપયોગ કરી શકો છો કે જે કાર્ય

356
00:15:07,150 --> 00:15:11,260
અમે અગાઉથી ખબર નથી ત્યારે મેમરી
અમે કેટલીક જરૂર પડી શકે છે કે જે.

357
00:15:11,260 --> 00:15:13,960
તેથી, ઉદાહરણ તરીકે, હું પાછા જાઓ તો
અહીં સાધન છે.

358
00:15:13,960 --> 00:15:21,010
અને હું છેલ્લા સમય hello2.c માંથી ખોલો
જોવામાં જે અહીં આ કાર્યક્રમ, યાદ

359
00:15:21,010 --> 00:15:23,500
આ જેમ થોડી કંઈક,
માત્ર ત્રણ રેખાઓ -

360
00:15:23,500 --> 00:15:27,940
તમારું નામ, તો પછી શબ્દમાળા નામ, રાજ્ય
ડાબી પર, getstring બરાબર.

361
00:15:27,940 --> 00:15:29,690
અને પછી અમે તેને છાપે
વપરાશકર્તાના નામ.

362
00:15:29,690 --> 00:15:31,170
>> તેથી આ એક સુપર સરળ કાર્યક્રમ હતો.

363
00:15:31,170 --> 00:15:34,870
સ્પષ્ટ છે, મને આગળ જવા દો
અને હેલો-2 બનાવે છે.

364
00:15:34,870 --> 00:15:36,680
હું કોઈ સ્લેશ હેલ્લો -2 કરવા જઇ રહ્યો છું.

365
00:15:36,680 --> 00:15:37,750
તમારું નામ સ્થિતિ -

366
00:15:37,750 --> 00:15:38,140
ડેવિડ.

367
00:15:38,140 --> 00:15:38,840
દાખલ કરો.

368
00:15:38,840 --> 00:15:39,540
ડેવિડ હેલો.

369
00:15:39,540 --> 00:15:41,060
તે ઠીક કામ કરવા લાગે છે.

370
00:15:41,060 --> 00:15:43,140
પરંતુ શું ખરેખર ચાલુ છે
અહીં હૂડ નીચે?

371
00:15:43,140 --> 00:15:44,670
પ્રથમ ચાલો કેટલાક સ્તરો પાછા છાલ.

372
00:15:44,670 --> 00:15:48,380
શબ્દમાળા અમે કર્યું માત્ર એક પર્યાયવાચી શબ્દ છે
તે માટે સમજાયું?

373
00:15:48,380 --> 00:15:49,110
ચાર સ્ટાર.

374
00:15:49,110 --> 00:15:52,740
તેથી માતાનો જો તે થોડી વધુ arcane બનાવવા દો
પરંતુ વધુ તકનિકી સાચું કે આ

375
00:15:52,740 --> 00:15:55,570
એનો અર્થ એ કે એક ચાર સ્ટાર છે,
નામ, હા, એક પરિબળ છે.

376
00:15:55,570 --> 00:15:59,920
પરંતુ શું નામ સ્ટોર્સ સરનામું છે
થોડી વિચિત્ર લાગે છે કે જે ચાર,

377
00:15:59,920 --> 00:16:01,050
હું શબ્દમાળા પાછા ફરવામાં રહ્યો છે.

378
00:16:01,050 --> 00:16:03,580
હું પાછો બહુવિધ મેળવવામાં છું
અક્ષરો એક ચાર નથી.

379
00:16:03,580 --> 00:16:07,400
>> પરંતુ અલબત્ત, તમે માત્ર પ્રથમ જરૂર
યાદ ચાર માતાનો સરનામા જ્યાં

380
00:16:07,400 --> 00:16:08,870
કારણ કે શા માટે સમગ્ર શબ્દમાળા છે?

381
00:16:08,870 --> 00:16:12,700
તમે કેવી રીતે બહાર આકૃતિ નથી જ્યાં ઓવરને
શબ્દમાળા શરૂઆત જાણીને છે?

382
00:16:12,700 --> 00:16:13,630
આ બેકસ્લેશ શૂન્ય.

383
00:16:13,630 --> 00:16:17,260
તેથી તે બે કડીઓ સાથે તમે બહાર આકૃતિ
શરૂઆત અને અંત પહેલાં

384
00:16:17,260 --> 00:16:20,280
કોઇપણ શબ્દમાળા તેઓ કરશો જેથી લાંબા તરીકે છે,
યોગ્ય રીતે નલ સાથે રચના

385
00:16:20,280 --> 00:16:22,110
ટર્મીનેટર, કે જે બેકસ્લેશ શૂન્ય.

386
00:16:22,110 --> 00:16:24,520
>> પરંતુ આ getstring ફોન છે.

387
00:16:24,520 --> 00:16:28,020
અને તે getstring બહાર વળે
આ બધા સમય પ્રકારની કરવામાં આવી છે

388
00:16:28,020 --> 00:16:28,820
અમને છેતરપિંડીની.

389
00:16:28,820 --> 00:16:32,460
તે ખાતરી કરવા માટે, આ શ્રમ કરી રહ્યું છે
વપરાશકર્તા માંથી શબ્દમાળા મેળવવામાં.

390
00:16:32,460 --> 00:16:34,580
પરંતુ તે મેમરી જ્યાં ચોક્કો
આવતા છે?

391
00:16:34,580 --> 00:16:38,440
અમે અહીં ચિત્ર પર પાછા જાઓ અને જો
માત્ર એક ના વ્યાખ્યા અરજી

392
00:16:38,440 --> 00:16:42,610
ક્ષણ પહેલા, કે સ્ટેક છે
કાર્યો કહેવામાં આવે છે ત્યારે મેમરી, જાય

393
00:16:42,610 --> 00:16:45,370
કે તર્ક દ્વારા, તમે getstring કૉલ ત્યારે,
અને પછી હું લખો

394
00:16:45,370 --> 00:16:50,900
D-A-V એ હું-d, કંપની છે D-A-V-આઇ ડી
બેકસ્લેશ શૂન્ય પર આધારિત છે, સ્ટોર

395
00:16:50,900 --> 00:16:53,480
વાર્તા અમે અત્યાર સુધી અમને જે કહ્યું છે?

396
00:16:53,480 --> 00:16:55,190
>> તે હોઈ લાગશે
સ્ટેક, બરાબર ને?

397
00:16:55,190 --> 00:16:58,120
તમે શબ્દમાળા વિચાર કૉલ કરો ત્યારે તમે એક વિચાર
સ્ટેક પર મેમરી થોડી સ્લાઇસ.

398
00:16:58,120 --> 00:17:01,630
તેથી તે D-A-V-આઇ ડી કારણ રહે
બેકસ્લેશ શૂન્ય સંગ્રહાયેલ છે

399
00:17:01,630 --> 00:17:02,770
ત્યાં સ્ટેક માં.

400
00:17:02,770 --> 00:17:07,680
પરંતુ વળતર getstring, એક મિનિટ રાહ જુઓ
કે શબ્દમાળા છે, તેથી વાત કરવા માટે, જેનો અર્થ થાય છે

401
00:17:07,680 --> 00:17:11,700
તે કાફે માંથી ટ્રે છે
સ્ટેક બોલ લેવામાં આવે છે.

402
00:17:11,700 --> 00:17:14,560
અને અમે તે જલદી તરીકે છેલ્લા સમય જણાવ્યું હતું કે,
કાર્ય વળતર, અને તમે લઇ

403
00:17:14,560 --> 00:17:20,109
સ્ટેક બંધ ટ્રે, તેથી વાત કરવા માટે,, શું
તમે અવશેષો વિશે ધારણ કરી શકે છે

404
00:17:20,109 --> 00:17:21,819
કે મેમરી?

405
00:17:21,819 --> 00:17:25,160
હું પ્રકારની પ્રશ્ન ગુણ તેમને redrew
તેઓ અસરકારક રીતે બની છે, કારણ કે

406
00:17:25,160 --> 00:17:26,250
અજ્ઞાત કિંમતો.

407
00:17:26,250 --> 00:17:29,500
જ્યારે કેટલાક તેઓ ફરીથી ઉપયોગ કરી શકાય
આગામી કાર્ય તરીકે ઓળખાય છે.

408
00:17:29,500 --> 00:17:31,870
>> અન્ય શબ્દોમાં, આપણે થાય છે
સ્ટોર કરવા માટે -

409
00:17:31,870 --> 00:17:34,350
હું એક ઝડપી ચિત્ર ડ્રો પડશે
અહીં સ્ટેક.

410
00:17:34,350 --> 00:17:38,690
અમે નીચે ચિત્રકામ કરવાની થાય છે
મારા મેમરી સેગમેન્ટ છે, અને આપણે કહી શકશો

411
00:17:38,690 --> 00:17:42,230
આ મેમરી સ્થળ છે કે
મુખ્ય અને કદાચ ARG કેચ અને દ્વારા કબજો

412
00:17:42,230 --> 00:17:46,790
ARG વિરુદ્ધ અને પ્રોગ્રામમાં અન્ય કંઈપણ
getstring કહેવામાં આવે છે ત્યારે,

413
00:17:46,790 --> 00:17:51,120
અનુમાન getstring નહીં
અહીં મેમરી એક ચંકને.

414
00:17:51,120 --> 00:17:53,940
અને પછી D-A-V-આઇ ડી અચાનક
આ કાર્ય પૂર્ણ થાય છે.

415
00:17:53,940 --> 00:17:55,320
અને હું વધુ સરળતા માટે જઇ રહ્યો છું.

416
00:17:55,320 --> 00:18:00,050
પરંતુ માતાનો ધારે દો તેના D-A-V-આઇ ડી કે
બેકસ્લેશ શૂન્ય.

417
00:18:00,050 --> 00:18:03,500
તેથી આ ઘણા બાઇટ્સ ઉપયોગ થાય છે
getstring માટે ફ્રેમ.

418
00:18:03,500 --> 00:18:08,270
>> પરંતુ જલદી getstring વળતર તરીકે, અમે
છેલ્લા સમય જણાવ્યું હતું કે, પર આ મેમરી

419
00:18:08,270 --> 00:18:11,340
અહીં બધા બને - woops! -

420
00:18:11,340 --> 00:18:14,270
બધા અસરકારક રીતે ભૂંસી બને છે.

421
00:18:14,270 --> 00:18:17,220
અને અમે પ્રશ્ન તરીકે હવે આ વિચાર કરી શકો છો
ગુણ જાણે છે, કારણ કે

422
00:18:17,220 --> 00:18:18,720
શું છે કે જે મેમરી બનવા જઈ રહ્યું છે.

423
00:18:18,720 --> 00:18:22,130
ખરેખર, હું ઘણી વાર કાર્યો કૉલ
getstring કરતાં અન્ય.

424
00:18:22,130 --> 00:18:24,750
અને તરત હું કેટલાક અન્ય કૉલ તરીકે
getstring કરતાં કાર્ય, કદાચ ન

425
00:18:24,750 --> 00:18:28,860
આપણે જોયું તો આ ચોક્કસ કાર્યક્રમ
પરંતુ કેટલાક અન્ય ચોક્કસ કેટલાક અન્ય ખાતે

426
00:18:28,860 --> 00:18:34,180
કાર્ય આપવામાં આવી અંત શકે છે
સ્ટેક આ આગામી હાજર.

427
00:18:34,180 --> 00:18:39,410
>> તેથી તે getstring સ્ટોર્સ કરી શકાતી નથી
સ્ટેક પર D-A-V-આઇ ડી હું કારણ

428
00:18:39,410 --> 00:18:41,040
તરત જ તેને ઍક્સેસ ગુમાવી બેસે છે.

429
00:18:41,040 --> 00:18:43,720
પરંતુ અમે તેઓ getstring ખબર
માત્ર શું આપે?

430
00:18:43,720 --> 00:18:47,220
તે પરત ન
મને છ અક્ષરો.

431
00:18:47,220 --> 00:18:51,090
તે સાચી શું હતી પરત થયેલ છે
અમે છેલ્લા સમય તારણ?

432
00:18:51,090 --> 00:18:52,480
પ્રથમ આ સરનામું.

433
00:18:52,480 --> 00:18:56,650
તેથી અચાનક, તમે getstring કહેવાય,
તે માટે મેમરી એક ચંકને ફાળવણી છે

434
00:18:56,650 --> 00:18:59,620
શબ્દમાળા કે જે વપરાશકર્તાઓને પ્રકાર અને
તે પછી પરત સરનામું.

435
00:18:59,620 --> 00:19:02,930
અને તે તમે જ્યારે ઇચ્છો છો કે બહાર વળે
આ મેમરીને ફાળવવા માટે કામ કરે છે

436
00:19:02,930 --> 00:19:08,390
માર્ગ અને કહેવાય જે વ્યક્તિ માટે વળતર
કે કાર્ય ની સરનામા

437
00:19:08,390 --> 00:19:11,870
મેમરી કે ચંકને, તમે એકદમ
જો ખાતે સ્ટેક માં મૂકી શકતા નથી

438
00:19:11,870 --> 00:19:14,750
તળિયે, કારણ કે વિધેયાત્મક રીતે તે માત્ર છે
ખૂબ જ તમારામાં ન બની જવા

439
00:19:14,750 --> 00:19:17,800
ઝડપથી, જેથી તમે કદાચ ધારી શકો છો જ્યાં
અમે કદાચ ટૉસ માટે જઈ રહ્યાં છો

440
00:19:17,800 --> 00:19:20,130
તેના બદલે, કહેવાતા ઢગલો.

441
00:19:20,130 --> 00:19:25,290
>> તેથી તમારી મેમરી માતાનો તળિયે વચ્ચે
લેઆઉટ અને તમારી મેમરી ની ટોચ

442
00:19:25,290 --> 00:19:26,820
લેઆઉટ સેગમેન્ટોને સમગ્ર ટોળું છે.

443
00:19:26,820 --> 00:19:29,270
એક સ્ટેક છે, અને અધિકાર
તે ઉપર ઢગલો છે.

444
00:19:29,270 --> 00:19:33,680
અને ઢગલો માત્ર એક અલગ ચંકને છે
કાર્યો માટે ઉપયોગ નથી કે મેમરી

445
00:19:33,680 --> 00:19:34,770
તેઓ કહેવામાં આવે ત્યારે.

446
00:19:34,770 --> 00:19:38,100
તે, જ્યારે લાંબા ગાળાના મેમરી માટે વપરાય છે
તમે એક કાર્ય કેટલાક પડાવી લેવું કરવા માંગો છો

447
00:19:38,100 --> 00:19:42,700
મેમરી અને તે પર અટકી સમક્ષ રજુ કરવાનો પ્રયત્ન
તેની પર નિયંત્રણ ગુમાવ્યા વગર.

448
00:19:42,700 --> 00:19:45,550
>> હવે તમે કદાચ તરત જ કરી શકે
આ નથી કે જુઓ

449
00:19:45,550 --> 00:19:48,060
એક સંપૂર્ણ ડિઝાઇન જરૂરી.

450
00:19:48,060 --> 00:19:51,350
તમારા પ્રોગ્રામ પર મેમરી ફાળવવામાં તરીકે
સ્ટેક કરો, અથવા તમે કૉલ તરીકે વધુ અને

451
00:19:51,350 --> 00:19:55,540
વધુ કાર્યો, અથવા તમે ફાળવી તરીકે
તરીકે બંધ malloc સાથે ઢગલો પર મેમરી

452
00:19:55,540 --> 00:20:00,690
getstring કરી, શું સ્પષ્ટ થયેલ છે
અનિવાર્ય સમસ્યા હોઈ લાગે છે?

453
00:20:00,690 --> 00:20:00,860
>> અધિકાર.

454
00:20:00,860 --> 00:20:03,150
હકીકત જેવી છે કે આ તીર
દરેક અન્ય તરફ સંકેત છે

455
00:20:03,150 --> 00:20:04,380
સારી આગાહી નથી.

456
00:20:04,380 --> 00:20:08,630
અને ખરેખર, અમે ખૂબ જ ઝડપથી તૂટી શકે છે
માર્ગો કોઇ પણ નંબર એક કાર્યક્રમ.

457
00:20:08,630 --> 00:20:12,050
હકીકતમાં, હું અમે હોઈ શકે છે લાગે છે
આ આકસ્મિક એકવાર પૂર્ણ થઈ.

458
00:20:12,050 --> 00:20:14,020
અથવા જો નહિં, તો તે શું કરીએ
ઇરાદાપૂર્વક હવે.

459
00:20:14,020 --> 00:20:21,330
મને આગળ વધો અને ઝડપથી સુપર લખવા દો
એક કાર્યક્રમ dontdothis.c કહેવાય છે.

460
00:20:21,330 --> 00:20:26,730
અને હવે હું અહીં જાઓ અને પડશે
તીવ્ર stdio.h સમાવેશ થાય છે નથી.

461
00:20:26,730 --> 00:20:32,620
કાર્ય foo લે જાહેર ચાલો
આ બોલ પર કોઈ દલીલો છે

462
00:20:32,620 --> 00:20:34,040
રદબાતલ દ્વારા તેમજ સૂચિત.

463
00:20:34,040 --> 00:20:37,830
>> અને foo શું ચાલે છે તે જ વસ્તુ છે
કદાચ નથી, જે કોલ foo,

464
00:20:37,830 --> 00:20:39,100
હોંશિયાર વિચાર છે, પરંતુ તેથી તે છે.

465
00:20:39,100 --> 00:20:40,490
ઇએનટી મુખ્ય રદબાતલ.

466
00:20:40,490 --> 00:20:45,270
હવે મુખ્ય ચાલે છે તે જ વસ્તુ
કરવા માટે તેમજ foo કૉલ છે.

467
00:20:45,270 --> 00:20:51,050
અને માત્ર કિક્સ માટે, હું જવા માટે જઇ રહ્યો છું
આગળ અહીં અને માંથી હેલો "printf કહે છે

468
00:20:51,050 --> 00:20:52,340
foo. "

469
00:20:52,340 --> 00:20:52,890
>> ઠીક.

470
00:20:52,890 --> 00:21:00,160
હું કોઇ પણ ભૂલો કરી ન હતી તેથી જો,
Dontdothis પર કોઈ સ્લેશ બનાવો.

471
00:21:00,160 --> 00:21:01,960
અને ચાલો એક મોટી વિંડોમાં તે શું -

472
00:21:01,960 --> 00:21:03,210
કોઈ સ્લેશ, dontdothis.

473
00:21:03,210 --> 00:21:07,590

474
00:21:07,590 --> 00:21:08,840
પર આવો.

475
00:21:08,840 --> 00:21:10,940

476
00:21:10,940 --> 00:21:11,890
ઓહો.

477
00:21:11,890 --> 00:21:13,100
દેખીતી રીતે, તમે આ કરી શકો છો.

478
00:21:13,100 --> 00:21:15,190
તે ખરેખર.

479
00:21:15,190 --> 00:21:16,190
ઠીક.

480
00:21:16,190 --> 00:21:16,580
રાહ જુઓ.

481
00:21:16,580 --> 00:21:17,370
દ્વારા ઊભા.

482
00:21:17,370 --> 00:21:18,270
અમે હતી -

483
00:21:18,270 --> 00:21:20,110
અમે ખાતરી સાથે ઉપયોગ કર્યો હતો.

484
00:21:20,110 --> 00:21:22,050
>> [SIGHS]

485
00:21:22,050 --> 00:21:25,110
>> મને ખબર છે, પરંતુ હું અમે લાગે છે
ફક્ત કે જે કાઢી નાખી.

486
00:21:25,110 --> 00:21:28,410
ઉહ, હા.

487
00:21:28,410 --> 00:21:30,660
તે ખરેખર.

488
00:21:30,660 --> 00:21:32,640
આ રોબ ઉકેલો.

489
00:21:32,640 --> 00:21:34,678
શું?

490
00:21:34,678 --> 00:21:35,928
તે ખૂબ જ સરળ છે.

491
00:21:35,928 --> 00:21:43,820

492
00:21:43,820 --> 00:21:47,360
હા, અમે ઓપ્ટિમાઇઝેશન બંધ છે.

493
00:21:47,360 --> 00:21:48,970
બરાબર, બાય ઊભા.

494
00:21:48,970 --> 00:21:49,950
હવે હું સારી લાગે છે.

495
00:21:49,950 --> 00:21:51,390
ઠીક.

496
00:21:51,390 --> 00:21:51,780
બધા અધિકાર.

497
00:21:51,780 --> 00:21:53,430
>> તેથી માતાનો આ recompile દો -

498
00:21:53,430 --> 00:21:55,880
તમે dontdothis બનાવો.

499
00:21:55,880 --> 00:22:00,090
તમે આ નામ બદલવા હોઈ શકે છે
માત્ર એક ક્ષણ dothis.c.

500
00:22:00,090 --> 00:22:00,710
ત્યાં અમે જાઓ.

501
00:22:00,710 --> 00:22:01,240
આપનો આભાર.

502
00:22:01,240 --> 00:22:02,050
ઠીક.

503
00:22:02,050 --> 00:22:05,480
તેથી હું પ્રિન્ટ થયો હતો તે હકીકત
કંઈક બહાર માત્ર વાસ્તવમાં હતી

504
00:22:05,480 --> 00:22:08,150
પ્રક્રિયા ધીમી છે કે જેના દ્વારા અમે
કે બિંદુ સુધી પહોંચી ગયા હતા.

505
00:22:08,150 --> 00:22:08,510
ઠીક.

506
00:22:08,510 --> 00:22:08,870
Phew!

507
00:22:08,870 --> 00:22:11,180
>> તેથી શું ખરેખર ચાલુ છે?

508
00:22:11,180 --> 00:22:14,440
માત્ર એક કોરે તરીકે ત્યાં કારણ છે,
ઇનપુટ દ્રષ્ટિએ કંઇ કરવાનું અને

509
00:22:14,440 --> 00:22:17,270
આઉટપુટ ધીમી હોય છે કારણ કે તમે
આ માટે અક્ષરો લખવા માટે છે

510
00:22:17,270 --> 00:22:18,600
સ્ક્રીન, તે સરકાવવા માટે છે.

511
00:22:18,600 --> 00:22:21,720
તેથી લાંબા વાર્તા ટૂંકી, હું ખરેખર હતી
તેથી ઉત્સુક બન્યું, અમે હશે

512
00:22:21,720 --> 00:22:23,260
તેમજ આ અંતિમ પરિણામ જોઈ છે.

513
00:22:23,260 --> 00:22:26,220
હું પ્રિન્ટ અપ્સ ઓફ રાઈડ મળી, હવે તે
અમે અધિકાર દૂર તે જુઓ.

514
00:22:26,220 --> 00:22:28,410
તેથી શા માટે આ શું થઈ રહ્યું છે.

515
00:22:28,410 --> 00:22:31,300
ઠીક છે, અલબત્ત આ સરળ સમજૂતી,
કે foo કદાચ ન જોઈએ છે

516
00:22:31,300 --> 00:22:32,500
પોતે ફોન કરી શકે છે.

517
00:22:32,500 --> 00:22:34,470
>> હવે સામાન્ય અર્થમાં,
આ પુનરાવર્તન છે.

518
00:22:34,470 --> 00:22:36,970
અને અમે એક દંપતિ અઠવાડિયા વિચાર્યું
પહેલાં પૂનરાવર્તિત સારો છે.

519
00:22:36,970 --> 00:22:40,330
પુનરાવર્તનના આ જાદુઈ માર્ગ છે
succinctly સુપર જાતને વ્યક્ત.

520
00:22:40,330 --> 00:22:41,400
અને તે માત્ર કામ કરે છે.

521
00:22:41,400 --> 00:22:45,060
પરંતુ બધી કી લક્ષણ છે
અમે વાત કરી કરેલા પૂનરાવર્તિત કાર્યક્રમો

522
00:22:45,060 --> 00:22:48,260
વિશે અને જોવામાં આમ અત્યાર સુધી, જે
તેઓ શું હતી?

523
00:22:48,260 --> 00:22:52,610
કેટલાક હાર્ડ કોડેડ હતી કે જે આધાર કેસ,
કેટલીક પરિસ્થિતિ માં જણાવ્યું હતું કે, કેસ

524
00:22:52,610 --> 00:22:56,210
સ્પષ્ટ છે કે જે foo, કૉલ નથી
અહીં ન હોય.

525
00:22:56,210 --> 00:22:58,920
>> તેથી શું ખરેખર શું થઈ રહ્યું છે
આ ચિત્ર દ્રષ્ટિએ?

526
00:22:58,920 --> 00:23:01,790
ઠીક છે, જ્યારે મુખ્ય foo, તે કહે છે
મેમરી એક સ્લાઇસ નોંધાયો નહીં.

527
00:23:01,790 --> 00:23:04,150
Foo foo કહે છે ત્યારે તે નહીં
મેમરી એક સ્લાઇસ.

528
00:23:04,150 --> 00:23:06,430
Foo foo કહે છે ત્યારે તે એક સ્લાઇસ નોંધાયો નહીં.

529
00:23:06,430 --> 00:23:07,080
તે એક સ્લાઇસ નોંધાયો નહીં.

530
00:23:07,080 --> 00:23:08,120
તે એક સ્લાઇસ નોંધાયો નહીં.

531
00:23:08,120 --> 00:23:09,460
Foo પરત ક્યારેય થયેલ છે કારણ કે.

532
00:23:09,460 --> 00:23:12,160
અમે તે એક ભૂંસી નાખી ક્યારેય રહ્યાં છો
સ્ટેક થી ફ્રેમ.

533
00:23:12,160 --> 00:23:15,930
તેથી અમે ઢગલો મારફતે નથી બ્લોએંગ કરી રહ્યાં છો
કોણ શું બીજું જાણે છે, અને ઉલ્લેખ

534
00:23:15,930 --> 00:23:19,600
અમે અમારા ની સીમાથી વધુ પડતા પગલાં રહ્યા છો
મેમરી સેગમેન્ટ કહેવાતી.

535
00:23:19,600 --> 00:23:21,790
સેગ્મેન્ટેશન ખોટા જાઓ ભૂલ.

536
00:23:21,790 --> 00:23:24,110
>> તેથી ત્યાં ઉકેલ
સ્પષ્ટ રીતે આવું નથી.

537
00:23:24,110 --> 00:23:28,830
પરંતુ મોટી અસર તે છે કે, હા, છે
એકદમ અમુક મર્યાદા હોય છે

538
00:23:28,830 --> 00:23:32,470
તે સારી રીતે કેવી રીતે કરવી, વ્યાખ્યાયિત નથી તો પણ
જો તમે માં કૉલ કરી શકો છો ઘણા કાર્યો

539
00:23:32,470 --> 00:23:34,970
કાર્યક્રમ કેવી રીતે ઘણી વખત એક કાર્ય
પોતે કૉલ કરી શકો છો.

540
00:23:34,970 --> 00:23:38,430
અમે પુનરાવર્તનના ઉપદેશ હતી તેથી છતાં પણ
આ સંભવિત જાદુઈ વસ્તુ તરીકે

541
00:23:38,430 --> 00:23:41,870
જો સિગ્મા માટે પહેલા અઠવાડિયા દંપતિ
કાર્ય, અને જ્યારે અમે માહિતી મળી

542
00:23:41,870 --> 00:23:45,270
માળખાં અને CS50, તમે અન્ય જોશો
તે માટે અરજીઓ, તે નથી

543
00:23:45,270 --> 00:23:46,500
જરૂરી શ્રેષ્ઠ વસ્તુ.

544
00:23:46,500 --> 00:23:50,070
એક કાર્ય પોતે કહે છે, કારણ કે જો
આધાર છે, પણ જો પોતે કહે છે

545
00:23:50,070 --> 00:23:54,860
કેસ, તમે તે આધાર કેસ હિટ ન હોય તો
1,000 કોલ્સ અથવા 10,000 કોલ્સ માટે, દ્વારા

546
00:23:54,860 --> 00:23:58,800
તમે રૂમ બહાર ચાલે છે કે જે કદાચ સમય
તમારા કહેવાતા સ્ટેક અને હિટ પર

547
00:23:58,800 --> 00:24:00,400
મેમરી કેટલાક અન્ય સેગમેન્ટો.

548
00:24:00,400 --> 00:24:03,950
તેથી તે ખૂબ ડિઝાઇન વેપાર બંધ છે
લાવણ્ય વચ્ચે અને વચ્ચે

549
00:24:03,950 --> 00:24:06,920
તમારા ચોક્કસ ઓફ રોબસ્ટનેસ
અમલીકરણ.

550
00:24:06,920 --> 00:24:10,780
>> તેથી અન્ય નુકસાન અથવા ત્યાં છે
અમે કર્યું છે તે માટે બીજી gotcha

551
00:24:10,780 --> 00:24:11,720
આમ અત્યાર સુધી કરી દેવામાં.

552
00:24:11,720 --> 00:24:12,980
હું getstring કહેવાય -

553
00:24:12,980 --> 00:24:15,120
મને હેલો-2 માં પાછા જવા દો.

554
00:24:15,120 --> 00:24:18,170
, હું getstring ફોન કરું છું કે નોટિસ
જે એક સરનામું પરત આવે છે.

555
00:24:18,170 --> 00:24:20,730
અને આજે આપણે દાવો છે કે સરનામા
આ ઢગલો છે.

556
00:24:20,730 --> 00:24:24,480
અને હવે હું બહાર છાપવા છું
કે સરનામા અંતે સ્ટ્રિંગ.

557
00:24:24,480 --> 00:24:27,000
પરંતુ અમે કહેવાય ક્યારેય કર્યું
getstring વિરોધી.

558
00:24:27,000 --> 00:24:30,850
અમે જેમ કાર્ય calll માટે ક્યારેય કર્યું
જ્યાં તમે હાથ પાછા ungetstring,

559
00:24:30,850 --> 00:24:31,610
કે મેમરી.

560
00:24:31,610 --> 00:24:33,250
પરંતુ પ્રમાણિકપણે અમે કદાચ
આવી જોઈએ.

561
00:24:33,250 --> 00:24:37,390
કારણ કે અમે કમ્પ્યુટર પૂછવા રાખવા
જેમ વ્યક્તિ મેમરી માટે, દ્વારા માર્ગ

562
00:24:37,390 --> 00:24:40,830
getstring પરંતુ ચોક્કસ, તે પાછું આપે ક્યારેય
તે પણ જીવી બંધાયેલા છે

563
00:24:40,830 --> 00:24:42,970
અમે મેમરી રન આઉટ જેમાં સમસ્યાઓ.

564
00:24:42,970 --> 00:24:46,140
>> અને હકીકતમાં, આપણે આ માટે જોઈ શકો છો
જેના ઉપયોગ નવા સાધન સાથે સમસ્યાઓ

565
00:24:46,140 --> 00:24:47,640
ટાઇપ કરવા માટે થોડી વિસ્મૃત છે.

566
00:24:47,640 --> 00:24:50,960
પરંતુ મને આગળ વધો અને તે સ્પ્લેશ દો
માત્ર એક ક્ષણ સ્ક્રીન પર.

567
00:24:50,960 --> 00:24:56,940
હું આગળ જાઓ અને Valgrind સ્કોર જઇ રહ્યો છું
જેની પ્રથમ આદેશ પરિમાણ સાથે

568
00:24:56,940 --> 00:25:00,260
વાક્ય દલીલ નામ છે
કે કાર્યક્રમ હેલ્લો-2.

569
00:25:00,260 --> 00:25:02,650
અને કમનસીબે તે
આઉટપુટ atrociously છે

570
00:25:02,650 --> 00:25:04,290
આ બોલ પર કોઈ વાજબી કારણ માટે જટિલ.

571
00:25:04,290 --> 00:25:06,280
તેથી આપણે બધા કે વાસણ જુઓ.

572
00:25:06,280 --> 00:25:07,530
ડેવિડ મારું નામ રાજ્ય છે.

573
00:25:07,530 --> 00:25:09,760
કે જેથી કાર્યક્રમનો
વાસ્તવમાં ચાલી.

574
00:25:09,760 --> 00:25:11,180
અને હવે અમે આ આઉટપુટ મેળવી.

575
00:25:11,180 --> 00:25:13,400
>> તેથી Valgrind સમાન છે
GDB માટે ભાવના છે.

576
00:25:13,400 --> 00:25:14,950
તે સે દીઠ એક ડીબગર નથી.

577
00:25:14,950 --> 00:25:16,270
પરંતુ તે એક મેમરી પરીક્ષક છે.

578
00:25:16,270 --> 00:25:20,140
તે તમારા ચાલશે કે કાર્યક્રમ છે
કાર્યક્રમ અને તમે પૂછવામાં જો તમે કહી

579
00:25:20,140 --> 00:25:23,860
મેમરી માટે કોમ્પ્યુટર અને ક્યારેય તેને આપ્યો
પાછા, ત્યાં કે તમારી પાસે જેનો અર્થ

580
00:25:23,860 --> 00:25:24,570
મેમરી છિદ્ર.

581
00:25:24,570 --> 00:25:26,240
અને મેમરી લિક ખરાબ હોય છે.

582
00:25:26,240 --> 00:25:29,120
અને તમે કમ્પ્યુટર્સ વપરાશકર્તાઓને હોય છે
કદાચ આ તમે એક છે, શું લાગ્યું

583
00:25:29,120 --> 00:25:30,300
મેક કે પીસી.

584
00:25:30,300 --> 00:25:33,730
તમે ક્યારેય માટે તમારા કમ્પ્યુટર વપરાય છે
અને કેટલાક માં રીબુટ નહિં જ્યારે

585
00:25:33,730 --> 00:25:36,820
દિવસ અથવા તમે માત્ર એક ઘણો મળી છે
ચાલી રહેલ કાર્યક્રમો, અને ખરેખર વસ્તુ

586
00:25:36,820 --> 00:25:42,360
એક ગ્રાઇન્ડીંગ થંભી ધીમો પડી જાય છે, અથવા ઓછામાં ઓછા
કારણ કે તે વાપરવા માટે સુપર હેરાન છે

587
00:25:42,360 --> 00:25:44,350
બધું માત્ર સુપર ધીમી થઈ જાય છે.

588
00:25:44,350 --> 00:25:46,260
>> હવે તે કારણોસર કોઇ પણ નંબર બની શકે છે.

589
00:25:46,260 --> 00:25:49,600
તે અનંત લૂપ માં ભૂલ હોઈ શકે છે
કોઈના કોડ છે, અથવા, વધુ સરળ, તે

590
00:25:49,600 --> 00:25:53,250
તમે વધુ ઉપયોગ કરી રહ્યાં છો કે જે અર્થ થઇ શકે છે
તમારા કરતાં મેમરી, અથવા પ્રયાસ

591
00:25:53,250 --> 00:25:54,920
કોમ્પ્યુટર ખરેખર છે.

592
00:25:54,920 --> 00:25:57,770
અને કદાચ અમુક કાર્યક્રમ માં ભૂલ છે
મેમરી માટે પૂછવા રાખે.

593
00:25:57,770 --> 00:26:02,480
વર્ષ માટે બ્રાઉઝર્સ માટે કુખ્યાત હતા
આ વધુ અને વધુ મેમરી માટે પૂછતી

594
00:26:02,480 --> 00:26:03,870
પરંતુ તે પાછા સોંપવામાં નથી.

595
00:26:03,870 --> 00:26:07,220
ચોક્કસ, તમે ફક્ત એક મર્યાદિત હોય તો
મેમરી જથ્થો, તમે પૂછી શકતા નથી

596
00:26:07,220 --> 00:26:09,990
માટે અનંત ઘણી વખત
કે મેમરી કેટલાક.

597
00:26:09,990 --> 00:26:13,070
>> અને તેથી તમે, છતાં પણ અહીં જોવા શું
ફરી Valgrind આઉટપુટનું છે

598
00:26:13,070 --> 00:26:17,490
અંતે ચમકારો માટે બિનજરૂરીપણે જટિલ
પ્રથમ, આ રસપ્રદ ભાગ છે.

599
00:26:17,490 --> 00:26:18,890
હિપ -

600
00:26:18,890 --> 00:26:20,060
બહાર નીકળો અંતે ઉપયોગ.

601
00:26:20,060 --> 00:26:22,810
તેથી અહીં કેટલી મેમરી હતી ચોક્કો
જો ખાતે ઢગલો વપરાશમાં

602
00:26:22,810 --> 00:26:24,300
સમય મારા કાર્યક્રમ બહાર -

603
00:26:24,300 --> 00:26:27,280
એક બ્લોકમાં દેખીતી રીતે છ બાઇટ્સ.

604
00:26:27,280 --> 00:26:28,710
તેથી હું મારા હાથ તરંગ જઈ રહ્યો
શું એક બ્લોક છે.

605
00:26:28,710 --> 00:26:31,270
વધુ, તે માત્ર એક ભાગ છે વિચારો
ચંકને માટે તકનિકી શબ્દ.

606
00:26:31,270 --> 00:26:33,140
છ બાઇટ્સ પરંતુ -

607
00:26:33,140 --> 00:26:36,870
છ બાઇટ્સ શું છે
હજુ પણ વપરાશમાં હતા?

608
00:26:36,870 --> 00:26:37,390
>> બરાબર.

609
00:26:37,390 --> 00:26:41,520
D-A-V-આઇ ડી બેકસ્લેશ શૂન્ય, પાંચ અક્ષર
નામ વત્તા નલ ટર્મીનેટર.

610
00:26:41,520 --> 00:26:46,350
તેથી આ કાર્યક્રમ જણાયું Valgrind કે હું
દ્વારા, દેખીતી રીતે, છ બાઇટ્સ માટે પૂછવામાં

611
00:26:46,350 --> 00:26:48,950
getstring માર્ગ, પરંતુ ક્યારેય
તેમને પાછા આપી હતી.

612
00:26:48,950 --> 00:26:52,030
અને હકીકતમાં, આ આવું ન હોઇ શકે
મારા કાર્યક્રમ ત્રણ નથી સ્પષ્ટ જો

613
00:26:52,030 --> 00:26:53,590
રેખાઓ, પરંતુ તે 300 લીટીઓ છે.

614
00:26:53,590 --> 00:26:56,920
તેથી આપણે ખરેખર અન્ય આદેશ આપી શકે છે
વાક્ય દલીલ માટે Valgrind માટે

615
00:26:56,920 --> 00:26:58,290
તે વધુ વર્બોઝ બનાવે છે.

616
00:26:58,290 --> 00:26:59,760
તેને યાદ રાખવા માટે થોડું ત્રાસદાયક છે.

617
00:26:59,760 --> 00:27:01,580
પરંતુ હું તો -

618
00:27:01,580 --> 00:27:01,930
માતાનો જોવા દો.

619
00:27:01,930 --> 00:27:03,540
લીક -

620
00:27:03,540 --> 00:27:05,030
તે લીક કરવામાં આવી હતી -

621
00:27:05,030 --> 00:27:07,580
પણ હું યાદ નથી
તે હાથ બોલ શું છે.

622
00:27:07,580 --> 00:27:08,550
>> - લીક તપાસો સંપૂર્ણ બરાબર.

623
00:27:08,550 --> 00:27:10,180
Yep, તમે ખૂબ ખૂબ આભાર.

624
00:27:10,180 --> 00:27:12,520
- લીક તપાસો સંપૂર્ણ બરાબર.

625
00:27:12,520 --> 00:27:13,800
દાખલ કરો.

626
00:27:13,800 --> 00:27:14,940
જ કાર્યક્રમ ચાલી રહ્યો છે.

627
00:27:14,940 --> 00:27:16,180
ફરી ડેવિડ લખો.

628
00:27:16,180 --> 00:27:17,660
હવે હું થોડી વધારે વિગત માટે જુઓ.

629
00:27:17,660 --> 00:27:20,890
પરંતુ ઢગલો સારાંશ નીચે, જે
ચાર સરખા છે - આહ,

630
00:27:20,890 --> 00:27:22,120
આ સરસ પ્રકારની છે.

631
00:27:22,120 --> 00:27:25,460
હવે Valgrind ખરેખર જોઈ છે
મારી કોડ કઠણ થોડી.

632
00:27:25,460 --> 00:27:29,580
અને તે દેખીતી રીતે, કહે છે કે છે
વાક્ય પર malloc -

633
00:27:29,580 --> 00:27:30,580
અમે બહાર ઝૂમ.

634
00:27:30,580 --> 00:27:31,980
પર લાઈન -

635
00:27:31,980 --> 00:27:32,930
અમે તેને શું છે રેખા જોવા નથી.

636
00:27:32,930 --> 00:27:35,110
પરંતુ malloc પ્રથમ ગુનેગાર છે.

637
00:27:35,110 --> 00:27:38,630
Malloc એક બ્લોગ છે.

638
00:27:38,630 --> 00:27:39,810
>> બધા અધિકાર?

639
00:27:39,810 --> 00:27:40,450
ઠીક, નં.

640
00:27:40,450 --> 00:27:40,940
બરાબર ને?

641
00:27:40,940 --> 00:27:42,520
હું getstring કહેવાય છે.

642
00:27:42,520 --> 00:27:44,460
getstring દેખીતી રીતે malloc કહે છે.

643
00:27:44,460 --> 00:27:47,800
તેથી શું કોડ લાઇન ઓફ દેખીતી રીતે છે
આકરી ભૂલમાં

644
00:27:47,800 --> 00:27:49,050
આ મેમરી ફાળવવામાં?

645
00:27:49,050 --> 00:27:51,560

646
00:27:51,560 --> 00:27:55,540
ચાલો રહેલી વ્યકિત malloc લખ્યું હતું કે ધારે
લાંબા પૂરતી છે કે આસપાસ કરવામાં આવી છે

647
00:27:55,540 --> 00:27:56,390
તેમના દોષ.

648
00:27:56,390 --> 00:27:57,520
તેથી તે કદાચ ખાણ છે.

649
00:27:57,520 --> 00:28:02,000
cs50.c માં getstring - એક કે તેથી
કમ્પ્યુટર પર ક્યાંક ફાઈલ -

650
00:28:02,000 --> 00:28:05,210
લાઇન 286 એ ગુનેગાર લાગે છે.

651
00:28:05,210 --> 00:28:08,140
હવે cs50 છે કે ધારે દો
તેથી સમય યોગ્ય રકમ માટે આસપાસ

652
00:28:08,140 --> 00:28:09,720
અમે પણ અમોઘ છે.

653
00:28:09,720 --> 00:28:14,080
અને તેથી તે getstring માં કદાચ નથી
આ ભૂલ આવેલું છે, પરંતુ તે

654
00:28:14,080 --> 00:28:17,810
હેલ્લો-2.c રેખા 18.

655
00:28:17,810 --> 00:28:20,670
>> તેથી માતાનો પર એક નજર કરીએ
તે લીટી 18 શું હતી.

656
00:28:20,670 --> 00:28:21,130
ઓહ.

657
00:28:21,130 --> 00:28:27,130
અચાનક આ વાક્ય જરૂરી નથી
બગડેલ, દીઠ સે, પરંતુ તે કારણ છે

658
00:28:27,130 --> 00:28:28,630
કે મેમરી લીક પાછળ છે.

659
00:28:28,630 --> 00:28:32,140
તેથી સુપર સરળ શું તર્ક કરશે
અહીં ઉકેલ હોઈ?

660
00:28:32,140 --> 00:28:34,710
અમે મેમરી માટે પૂછી રહ્યાં છો, તો ક્યારેય ન હતો
તે પાછા આપ્યા છે, અને તે એક હોઈ લાગે છે

661
00:28:34,710 --> 00:28:37,940
સમસ્યા છે, કારણ કે સમય મારા કમ્પ્યુટરને ઉપર
મેમરી રન આઉટ શકે છે, ધીમું હોઈ શકે છે

662
00:28:37,940 --> 00:28:42,110
નીચે, ખરાબ વસ્તુઓ, સારી રીતે, થાય શકે છે
સરળ સાહજિક ઉકેલ શું છે?

663
00:28:42,110 --> 00:28:43,140
માત્ર તે પાછું આપે છે.

664
00:28:43,140 --> 00:28:44,770
>> તમે કેવી રીતે છે કે મેમરી મુક્ત નથી?

665
00:28:44,770 --> 00:28:49,970
વેલ, thankfully તે ખૂબ સરળ છે
ફક્ત મફત નામ કહે છે.

666
00:28:49,970 --> 00:28:51,260
અને અમે પહેલાં આ ક્યારેય નહોતું કર્યું.

667
00:28:51,260 --> 00:28:55,890
પરંતુ તમે આવશ્યક વિચાર કરી શકો છો
malloc વિરુદ્ધની તરીકે મફત.

668
00:28:55,890 --> 00:28:58,030
મફત વિરોધી છે
મેમરી ફાળવણી.

669
00:28:58,030 --> 00:28:59,540
તેથી હવે મને આ recompile દો.

670
00:28:59,540 --> 00:29:02,050
હેલ્લો-2 કરો.

671
00:29:02,050 --> 00:29:04,620
મને તે ફરીથી ચલાવવા દો. હેલ્લો-2 ડેવિડ.

672
00:29:04,620 --> 00:29:07,290
તેથી તે કામ કરવા લાગે છે
બરાબર એ જ રીતે.

673
00:29:07,290 --> 00:29:11,180
પરંતુ હું Valgrind પર પાછા જાઓ અને ફરીથી ચલાવો તો
મારા નવા પર તે જ આદેશ

674
00:29:11,180 --> 00:29:14,720
સંકલિત કાર્યક્રમ, ટાઈપ
પહેલાં તરીકે મારા નામ -

675
00:29:14,720 --> 00:29:15,370
સરસ.

676
00:29:15,370 --> 00:29:16,760
ઢગલો સાર -

677
00:29:16,760 --> 00:29:17,740
- બહાર નીકળો અંતે ઉપયોગ

678
00:29:17,740 --> 00:29:19,370
શૂન્ય બ્લોકમાં શૂન્ય બાઇટ્સ.

679
00:29:19,370 --> 00:29:21,840
અને આ સુપર સરસ, બધા છે
ઢગલો બ્લોકો મુક્ત કરવામાં આવ્યા હતા.

680
00:29:21,840 --> 00:29:23,480
આ બોલ પર કોઈ લિક શક્ય છે.

681
00:29:23,480 --> 00:29:27,200
>> તેથી, બિન સમસ્યા સેટ 4 સાથે, અપ આવતા
પરંતુ સમસ્યા સમૂહ 5, જો વિદેશી સાથે

682
00:29:27,200 --> 00:29:30,740
અને આગળ, આ પણ એક બની જશે
તમારી ચોકસાઈ ના માપ

683
00:29:30,740 --> 00:29:33,630
તમારી પાસે શું નથી અથવા કાર્યક્રમ,
અથવા મેમરી લિક નથી.

684
00:29:33,630 --> 00:29:36,900
પરંતુ thankfully, તમે કારણ શકતા નથી જ
તેમને તર્ક, જેના દ્વારા

685
00:29:36,900 --> 00:29:40,430
નાના પ્રોગ્રામ માટે સરળ, તાર્કિક છે,
પરંતુ મોટા કાર્યક્રમો માટે કઠણ,

686
00:29:40,430 --> 00:29:43,860
, તે મોટા કાર્યક્રમો માટે, Valgrind
તમે ઓળખી શકો છો

687
00:29:43,860 --> 00:29:45,360
ચોક્કસ સમસ્યા નથી.

688
00:29:45,360 --> 00:29:47,500
>> પરંતુ એક અન્ય સમસ્યા
કે જન્મી શકે છે.

689
00:29:47,500 --> 00:29:51,245
, જે છે, મને અહીં આ ફાઇલ ખોલવા દો
ફરીથી, એક અંશે સરળ ઉદાહરણ છે.

690
00:29:51,245 --> 00:29:53,760
પરંતુ ચાલો તેના પર ધ્યાન કેન્દ્રિત
આ પ્રોગ્રામ કરે છે.

691
00:29:53,760 --> 00:29:55,190
આ memory.c કહેવામાં આવે છે.

692
00:29:55,190 --> 00:29:58,380
અમે આ પછી આજે પોસ્ટ પડશે
આજના સ્રોત કોડ ઝીપ.

693
00:29:58,380 --> 00:30:01,610
અને હું નામની એક કાર્ય છે કે નોટિસ
દલીલો અને કોઈ લે કે એફ

694
00:30:01,610 --> 00:30:02,800
કંઈ આપે છે.

695
00:30:02,800 --> 00:30:07,240
રેખા 20 માં, હું દેખીતી રીતે એક જાહેર છું
એક ઈન્ અને તે X ફોન માટે પોઇન્ટર.

696
00:30:07,240 --> 00:30:09,570
હું સોંપવા છું પરત છે
malloc બજારમૂલ્ય.

697
00:30:09,570 --> 00:30:14,590
અને માત્ર છું કેટલા બાઇટ્સ, સ્પષ્ટ કરવા
હું કદાચ malloc માંથી પાછા ફરવામાં

698
00:30:14,590 --> 00:30:17,080
આ પરિસ્થિતિ માં?

699
00:30:17,080 --> 00:30:18,040
>> કદાચ 40.

700
00:30:18,040 --> 00:30:18,840
જ્યાં તમે કે વિચાર નથી?

701
00:30:18,840 --> 00:30:22,410
વેલ, તમે ઈન્ વારંવાર કે યાદ તો
4 બાઇટ્સ, ઓછામાં ઓછા તે છે

702
00:30:22,410 --> 00:30:25,110
ઉપકરણ, ગુણ્યા 4 10 દેખીતી રીતે 40 છે.

703
00:30:25,110 --> 00:30:28,920
તેથી malloc એક સરનામા પરત થયેલ છે
એક મેમરી ચંકને અને સ્ટોર કે

704
00:30:28,920 --> 00:30:30,800
X આખરે સંબોધવા.

705
00:30:30,800 --> 00:30:32,570
તેથી, સ્પષ્ટ કરવા શું
પછી શું થઈ રહ્યું છે?

706
00:30:32,570 --> 00:30:34,990
ઠીક છે, મને પાછા સ્વિચ દો
અહીં અમારા ચિત્ર છે.

707
00:30:34,990 --> 00:30:38,150
મને માત્ર મારા તળિયે ડ્રો નથી દો
કોમ્પ્યુટરની મેમરી, મને આગળ જવા દો અને

708
00:30:38,150 --> 00:30:42,990
સમગ્ર લંબચોરસ દોરો કે
મારી RAM ના બધા રજૂ કરે છે.

709
00:30:42,990 --> 00:30:44,790
>> અમે કહી શકશો કે સ્ટેક
તળિયે છે.

710
00:30:44,790 --> 00:30:47,010
અને લખાણ સેગમેન્ટમાં છે
જો uninitialized માહિતી.

711
00:30:47,010 --> 00:30:49,880
પરંતુ હું માત્ર અમૂર્ત તે જઈ રહ્યો
દૂર ડોટ, કોઈ કોઈ અન્ય વસ્તુઓ.

712
00:30:49,880 --> 00:30:53,470
હું ફક્ત આ સંદર્ભ માટે જઇ રહ્યો છું
ટોચ પર ઢગલો છે.

713
00:30:53,470 --> 00:30:57,070
અને તે પછી આ ચિત્ર તળિયે,
મુખ્ય પ્રતિનિધિત્વ કરવા માટે, હું જાઉં છું

714
00:30:57,070 --> 00:30:59,880
જો તે કાપી નાંખ્યું મેમરી આપી
સ્ટેક પર.

715
00:30:59,880 --> 00:31:03,150
એફ માટે, હું તે એક સ્લાઇસ આપવા જઈ રહ્યો છું
સ્ટેક પર મેમરી.

716
00:31:03,150 --> 00:31:05,140
હવે, હું મારા સંપર્ક કરવા માટે મળી
ફરી સ્રોત કોડ.

717
00:31:05,140 --> 00:31:07,170
મુખ્ય માટે સ્થાનિક ચલો શું છે?

718
00:31:07,170 --> 00:31:10,710
દેખીતી રીતે કંઈ છે, તેથી તે સ્લાઇસ છે
અસરકારક રીતે ખાલી નથી અથવા પણ મોટા

719
00:31:10,710 --> 00:31:11,600
હું તે દોરેલા કર્યું છે.

720
00:31:11,600 --> 00:31:15,730
પરંતુ એફ, હું, સ્થાનિક ચલ છે
જે X કહેવાય છે.

721
00:31:15,730 --> 00:31:20,410
તેથી હું આગળ જાઓ અને એફ આપવા જઈ રહ્યો છું
તે X ફોન મેમરી એક ચંકને.

722
00:31:20,410 --> 00:31:24,680
>> , 10 ગુણ્યા 4 અને હવે malloc
કે જ્યાં malloc 40, તેથી

723
00:31:24,680 --> 00:31:25,430
મેમરી આવતા?

724
00:31:25,430 --> 00:31:27,530
અમે એક ચિત્ર દોરવામાં નથી કર્યું
પહેલાં આ ગમે છે.

725
00:31:27,530 --> 00:31:31,140
પરંતુ માતાનો તે અસરકારક રીતે કે ધારવું દો
જેથી એક, અહીં આવતા,

726
00:31:31,140 --> 00:31:33,170
બે, ત્રણ, ચાર, પાંચ.

727
00:31:33,170 --> 00:31:34,680
અને હવે હું આ 40 જરૂર છે.

728
00:31:34,680 --> 00:31:37,540
તેથી હું માત્ર સૂચવે ડોટ, ડોટ, ડોટ કરીશ
પણ વધુ મેમરી છે તે

729
00:31:37,540 --> 00:31:39,350
આ ઢગલો થી પાછા આવતા.

730
00:31:39,350 --> 00:31:40,710
હવે સરનામા શું છે?

731
00:31:40,710 --> 00:31:42,620
ચાલો અમારી મનસ્વી પસંદ
હંમેશની જેમ સરનામું -

732
00:31:42,620 --> 00:31:46,310
તે કદાચ રહ્યું હોવા છતાં Ox123,
સંપૂર્ણપણે અલગ કંઈક છે.

733
00:31:46,310 --> 00:31:50,420
તે પ્રથમ બાઇટ ની સરનામા ચોક્કો
હું malloc પૂછવા છું મેમરી છે.

734
00:31:50,420 --> 00:31:53,630
>> તેથી ટૂંકા, એકવાર લીટી માં 20, ચલાવે છે
શાબ્દિક શું છે

735
00:31:53,630 --> 00:31:57,170
અહીં x ની અંદર સંગ્રહિત?

736
00:31:57,170 --> 00:31:58,730
Ox123.

737
00:31:58,730 --> 00:32:00,370
Ox123.

738
00:32:00,370 --> 00:32:01,550
અને બળદની uninteresting છે.

739
00:32:01,550 --> 00:32:03,200
તે માત્ર છે અહીં અર્થ એવો થાય
હેક્સાડેસિમલ નંબર.

740
00:32:03,200 --> 00:32:06,490
પરંતુ શું કી ચોક્કો હું સ્ટોર કરેલા શું છે
X માં, જે સ્થાનિક ચલ છે.

741
00:32:06,490 --> 00:32:10,260
પરંતુ તેની માહિતી પ્રકાર, ફરી,
એક ઈન્ એક સરનામું છે.

742
00:32:10,260 --> 00:32:12,710
ઠીક છે, હું Ox123 સંગ્રહવા માટે જઈ રહ્યો છું.

743
00:32:12,710 --> 00:32:16,610
પરંતુ ફરીથી, ખૂબ છે, જો
હું સ્ક્રોલ નહિં, તો બિનજરૂરીપણે જટીલ

744
00:32:16,610 --> 00:32:21,490
પાછા, અમે આ દૂર અમૂર્ત કરી શકો છો તદ્દન
વ્યાજબી અને માત્ર કહે છે કે X છે

745
00:32:21,490 --> 00:32:23,910
મેમરી કે ચંકને માટે પોઇન્ટર.

746
00:32:23,910 --> 00:32:24,070
>> ઠીક.

747
00:32:24,070 --> 00:32:26,230
હવે હાથ પર પ્રશ્ન
નીચેના છે -

748
00:32:26,230 --> 00:32:29,910
રેખા 21, તે બહાર વળે, બગડેલ છે.

749
00:32:29,910 --> 00:32:31,160
શા માટે?

750
00:32:31,160 --> 00:32:34,890

751
00:32:34,890 --> 00:32:36,930
>> માફ કરશો?

752
00:32:36,930 --> 00:32:38,640
તે નથી -

753
00:32:38,640 --> 00:32:40,390
વધુ એક વખત કહે છે કે.

754
00:32:40,390 --> 00:32:41,240
વેલ, તે મુક્ત નથી.

755
00:32:41,240 --> 00:32:42,350
જેથી બીજા છે, પરંતુ.

756
00:32:42,350 --> 00:32:45,000
તેથી અન્ય પરંતુ ખાસ કરીને એક છે
રેખા 21 મુ.

757
00:32:45,000 --> 00:32:49,480

758
00:32:49,480 --> 00:32:50,040
>> બરાબર.

759
00:32:50,040 --> 00:32:54,980
કોડ આ સરળ વાક્ય માત્ર એક છે
બફર ઓવરફ્લો, બફર ઘેરી લીધા.

760
00:32:54,980 --> 00:32:57,050
એક બફર માત્ર મેમરી એક ચંકને થાય છે.

761
00:32:57,050 --> 00:33:01,520
પરંતુ મેમરી કે ચંકને કદ છે
10, 10 પૂર્ણાંકો, એટલે તો અમે

762
00:33:01,520 --> 00:33:05,350
જો વાકયરચનામાં ખાંડ મદદથી તેને ઇન્ડેક્સ
અરે સંકેત છે, ચોરસ

763
00:33:05,350 --> 00:33:09,220
વિભાજન છે, તમને વપરાશ હોય છે
X કૌંસ 0 X કૌંસ 1 એક્સ,

764
00:33:09,220 --> 00:33:10,390
કૌંસ પર કોઈ, કોઈ, કોઈ.

765
00:33:10,390 --> 00:33:13,270
X કૌંસ 9 સૌથી વધારે છે.

766
00:33:13,270 --> 00:33:17,680
હું X કૌંસ 10, જેથી જો જ્યાં
હું ખરેખર મેમરી જઈ રહ્યો છું?

767
00:33:17,680 --> 00:33:19,120
>> ઠીક છે, હું 10 ઈન્ હોય તો -

768
00:33:19,120 --> 00:33:21,070
ચાલો ખરેખર બધા ડ્રો
અહીં આ બહાર છે.

769
00:33:21,070 --> 00:33:22,700
જેથી પ્રથમ પાંચ હતી.

770
00:33:22,700 --> 00:33:24,660
અહીં અન્ય પાંચ ints છે.

771
00:33:24,660 --> 00:33:29,580
તેથી X કૌંસ 0 અહીં છે. X કૌંસ 1 છે
અહીં. X કૌંસ 9 અહીં છે. X કૌંસ

772
00:33:29,580 --> 00:33:37,960
10 અહીં છે, જે હું કહી રહ્યો છું એનો અર્થ એ થાય
રેખા 21 માં કમ્પ્યુટર મૂકી

773
00:33:37,960 --> 00:33:39,400
નંબર છે?

774
00:33:39,400 --> 00:33:42,010
આ નંબર 0 જ્યાં?

775
00:33:42,010 --> 00:33:43,380
વેલ, તે હા 0 છે.

776
00:33:43,380 --> 00:33:45,460
પરંતુ માત્ર એ હકીકત છે કે તેના 0
એક સંયોગ પ્રકારની છે.

777
00:33:45,460 --> 00:33:47,140
તે નંબર હોઈ શકે
50, અમે કાળજી બધા માટે.

778
00:33:47,140 --> 00:33:50,480
પરંતુ અમે X કૌંસ તે મૂકવા માટે પ્રયાસ કરી રહ્યાં છો
જ્યાં આ છે જે 10,

779
00:33:50,480 --> 00:33:53,700
પ્રશ્ન ચિહ્ન, દોરેલા છે, જે
સારી વાત નથી.

780
00:33:53,700 --> 00:33:57,070
આ કાર્યક્રમ ખૂબ જ સારી રીતે કદાચ
પરિણામે ભાંગી.

781
00:33:57,070 --> 00:33:59,400
>> હવે, ચાલો આગળ વધો અને જોવા દો આ તો
, ખરેખર, શું થાય છે.

782
00:33:59,400 --> 00:34:02,600
મેમરી કરો, ત્યારથી ફાઇલ
memory.c કહેવામાં આવે છે.

783
00:34:02,600 --> 00:34:05,950
ચાલો આગળ વધો અને સ્કોર
કાર્યક્રમ મેમરી.

784
00:34:05,950 --> 00:34:08,239
તેથી આપણે નસીબદાર મળી, ખરેખર, તે લાગે છે.

785
00:34:08,239 --> 00:34:09,340
અમે નસીબદાર મળી.

786
00:34:09,340 --> 00:34:11,060
પરંતુ હવે અમે Valgrind સ્કોર જો માતાનો જોવા દો.

787
00:34:11,060 --> 00:34:14,170
પ્રથમ નજરમાં, મારા કાર્યક્રમ કદાચ
સંપૂર્ણપણે સાચું લાગે છે.

788
00:34:14,170 --> 00:34:18,010
પરંતુ સાથે Valgrind મને સ્કોર દો
- લીક તપાસો મેમરી સંપૂર્ણ બરાબર.

789
00:34:18,010 --> 00:34:20,110
>> અને હવે હું આ ચલાવો ત્યારે -

790
00:34:20,110 --> 00:34:21,030
રસપ્રદ.

791
00:34:21,030 --> 00:34:26,800
અમાન્ય અંતે કદ 4 લખવા
memory.c લાઇન ઓફ 21.

792
00:34:26,800 --> 00:34:29,284
Memory.c લાઇન ઓફ 21 જે એક છે?

793
00:34:29,284 --> 00:34:30,340
ઓહ, રસપ્રદ.

794
00:34:30,340 --> 00:34:31,080
પરંતુ રાહ જુઓ.

795
00:34:31,080 --> 00:34:32,389
કદ 4, ઉલ્લેખ છે કે શું છે?

796
00:34:32,389 --> 00:34:34,969
હું માત્ર એક લખવા હતી
પરંતુ તે કદ 4 છે.

797
00:34:34,969 --> 00:34:36,889
તે શા માટે 4 છે?

798
00:34:36,889 --> 00:34:39,280
તે જે Int, કારણ કે તે છે
ફરીથી, ચાર બાઇટ્સ, છે.

799
00:34:39,280 --> 00:34:42,510
તેથી Valgrind ભૂલ મળી કે હું,
મારા કોડ પર glancing, ન હતી.

800
00:34:42,510 --> 00:34:45,040
અને કદાચ તમારા ટીએફ કરશે કે નથી લેતા.

801
00:34:45,040 --> 00:34:48,469
પરંતુ ખાતરી મળી છે કે શું Valgrind
અમે પણ, ત્યાં ભૂલ કરી છે

802
00:34:48,469 --> 00:34:52,719
અમે નસીબદાર મળી, અને છતાં કોમ્પ્યુટર
નક્કી કર્યું, એમ, હું તૂટી નથી જતા છું

803
00:34:52,719 --> 00:34:57,470
તમે એક બાઇટ, એક સ્પર્શ માત્ર કારણ કે
તમે ન હતી કે મેમરી ઈન્ માતાનો વર્થ

804
00:34:57,470 --> 00:34:58,550
વાસ્તવમાં પોતાના.

805
00:34:58,550 --> 00:35:00,380
>> ઠીક છે, અહીં બગડેલ બીજું શું છે.

806
00:35:00,380 --> 00:35:01,180
સરનામું -

807
00:35:01,180 --> 00:35:03,190
આ એક ક્રેઝી જોઈ સરનામું છે
હેક્સાડેસિમલ છે.

808
00:35:03,190 --> 00:35:06,890
માત્ર ક્યાંક ઢગલો છે અર્થ એ છે કે
કદ 40 બ્લોક પછી શૂન્ય બાઇટ્સ

809
00:35:06,890 --> 00:35:07,620
ફાળવવામાં આવે છે.

810
00:35:07,620 --> 00:35:10,610
મને અહીં બહાર ઝૂમ અને જોવા દો તો
આ થોડી વધુ મદદરૂપ છે.

811
00:35:10,610 --> 00:35:11,410
રસપ્રદ.

812
00:35:11,410 --> 00:35:15,600
40 બાઇટ્સ ચોક્કસપણે ખોવાઈ જાય છે
1 નુકશાન રેકોર્ડ 1 માં.

813
00:35:15,600 --> 00:35:17,840
ફરીથી, કરતાં વધુ શબ્દો અહીં ઉપયોગી છે.

814
00:35:17,840 --> 00:35:21,350
પરંતુ, પ્રકાશિત લીટીઓ પર આધારિત
જ્યાં હું કદાચ ધ્યાન કેન્દ્રિત કરવું જોઇએ મારા

815
00:35:21,350 --> 00:35:24,070
અન્ય ભૂલ માટે ધ્યાન?

816
00:35:24,070 --> 00:35:26,570
Memory.c એક લીટી 20 જેવો દેખાય છે.

817
00:35:26,570 --> 00:35:30,990
>> અમે લીટી 20 પર જાઓ, તેથી જો કે આ
તમે અગાઉ ઓળખી કે એક.

818
00:35:30,990 --> 00:35:33,030
અને તે બગડેલ હોય તે જરૂરી નથી.

819
00:35:33,030 --> 00:35:35,160
પરંતુ અમે આ તેની અસરો ઉલટાવી છે.

820
00:35:35,160 --> 00:35:38,790
તેથી હું કેવી રીતે ઓછામાં ઓછા સુધારવા નથી
તે ભૂલો એક?

821
00:35:38,790 --> 00:35:42,240
હું રેખા 21 પછી શું કરી શકે?

822
00:35:42,240 --> 00:35:47,110
હું તેથી, X મફત છે કરી શકે
કે મેમરી પાછા આપી.

823
00:35:47,110 --> 00:35:49,230
અને હું આ ભૂલ કેવી રીતે ઠીક કરું?

824
00:35:49,230 --> 00:35:52,120
હું ચોક્કસપણે જવા જોઈએ
આ બોલ પર કોઈ દૂર 0 કરતાં.

825
00:35:52,120 --> 00:35:53,670
તેથી મને પ્રયાસ કરો અને આ ફરીથી ચલાવો દો.

826
00:35:53,670 --> 00:35:56,080
માફ કરશો, ચોક્કસપણે જાઓ
આ બોલ પર કોઈ છેક 9 કરતાં.

827
00:35:56,080 --> 00:35:57,510
મેમરી બનાવો.

828
00:35:57,510 --> 00:36:00,650
Valgrind મને પુનઃ ચલાવો દો
એક મોટી વિંડોમાં.

829
00:36:00,650 --> 00:36:01,580
અને હવે જુઓ.

830
00:36:01,580 --> 00:36:02,250
સરસ.

831
00:36:02,250 --> 00:36:03,270
બધા ઢગલો બ્લોકો મુક્ત કરવામાં આવ્યા હતા.

832
00:36:03,270 --> 00:36:04,270
આ બોલ પર કોઈ લિક શક્ય છે.

833
00:36:04,270 --> 00:36:07,520
અને અહીં ઉપર, કોઈ ઉલ્લેખ નથી
આ અમાન્ય અધિકાર કોઇ વધારે.

834
00:36:07,520 --> 00:36:09,820
>> માત્ર લોભી વિચાર, અને લેટ્સ માટે
જુઓ તો બીજી નિદર્શન

835
00:36:09,820 --> 00:36:11,050
હેતુપૂર્વક જવા નથી -

836
00:36:11,050 --> 00:36:12,560
હું એક ક્ષણ પહેલા નસીબદાર મળી હતી.

837
00:36:12,560 --> 00:36:15,530
અને આ 0 છે એ હકીકત છે કે કદાચ છે
બિનજરૂરીપણે ગેરમાર્ગે.

838
00:36:15,530 --> 00:36:20,650
માત્ર 50 એક અંશે મનસ્વી કરવા દો માતાનો
નંબર, મેમરી નો સ્લેશ મેમરી બનાવો -

839
00:36:20,650 --> 00:36:21,410
હજુ નસીબદાર વિચાર.

840
00:36:21,410 --> 00:36:22,510
નથીંગ બરબાદીનું છે.

841
00:36:22,510 --> 00:36:26,150
હું માત્ર ખરેખર કંઈક ધારવું
મૂર્ખ છે, અને હું 100 નથી.

842
00:36:26,150 --> 00:36:30,360
, મને મેમરી રિમેક દો
કોઈ સ્લેશ મેમરી -

843
00:36:30,360 --> 00:36:31,075
ફરીથી નસીબદાર મળી.

844
00:36:31,075 --> 00:36:32,800
કેટલો 1,000 વિશે?

845
00:36:32,800 --> 00:36:35,370
ઉપરાંત ints, લગભગ,
જ્યાં હું પ્રયત્ન કરીશું?

846
00:36:35,370 --> 00:36:37,410
મેમરી બનાવો -

847
00:36:37,410 --> 00:36:38,570
તે ખરેખર.

848
00:36:38,570 --> 00:36:39,920
>> [હાસ્ય]

849
00:36:39,920 --> 00:36:41,270
>> ઠીક.

850
00:36:41,270 --> 00:36:43,920
માતાનો હવે આસપાસ ગડબડ ન દો.

851
00:36:43,920 --> 00:36:45,120
મેમરી પુનઃ ચલાવો.

852
00:36:45,120 --> 00:36:45,840
ત્યાં અમે જાઓ.

853
00:36:45,840 --> 00:36:46,410
બધા અધિકાર.

854
00:36:46,410 --> 00:36:52,500
તેથી દેખીતી રીતે તમે ઇન્ડેક્સ 100,000 ints
તમે જ હોવા જોઈએ જ્યાં બહાર

855
00:36:52,500 --> 00:36:54,410
મેમરી, ખરાબ વસ્તુઓ થાય છે.

856
00:36:54,410 --> 00:36:56,430
તેથી આ દેખીતી રીતે નથી
હાર્ડ, ઝડપી નિયમ.

857
00:36:56,430 --> 00:36:58,190
હું ટ્રાયલ ઉપયોગ પ્રકારની હતી
અને ભૂલ વિચાર.

858
00:36:58,190 --> 00:37:02,230
પરંતુ આ છે, કારણ કે, લાંબા વાર્તા ટૂંકી છે
તમારા કમ્પ્યુટરની મેમરી પણ વિભાજીત છે

859
00:37:02,230 --> 00:37:03,580
આ વસ્તુઓ માં સેગમેન્ટો કહેવાય છે.

860
00:37:03,580 --> 00:37:07,260
અને ક્યારેક, કમ્પ્યૂટર વાસ્તવમાં
તમે થોડી વધુ મેમરી આપવામાં આવી છે

861
00:37:07,260 --> 00:37:08,400
તમે માગી છે.

862
00:37:08,400 --> 00:37:12,170
પરંતુ કાર્યક્ષમતા માટે, તે માત્ર સરળ
વધુ મેમરી વિચાર પરંતુ માત્ર તમે જ કહો

863
00:37:12,170 --> 00:37:13,780
તમે તેને એક ભાગ મેળવી રહ્યાં છો કે.

864
00:37:13,780 --> 00:37:16,370
>> અને તમે ક્યારેક નસીબદાર વિચાર હોય, તો
તેથી, તમે સ્પર્શ કરવા માટે સક્ષમ હોઇ શકે છે

865
00:37:16,370 --> 00:37:17,795
કે મેમરી તમે ને અનુલક્ષતું નથી.

866
00:37:17,795 --> 00:37:21,860
તમારી પાસે કોઈ ગેરંટી છે કે શું કિંમત
તમે, ત્યાં ત્યાં રહેશે મૂકવામાં કારણ કે

867
00:37:21,860 --> 00:37:25,080
કમ્પ્યુટર હજુ પણ તે નથી વિચારે છે
તમારામાં છે, પરંતુ તે જરૂરી નથી જતા છે

868
00:37:25,080 --> 00:37:29,910
માં મેમરી અન્ય સેગમેન્ટમાં હિટ
કમ્પ્યુટર અને એક ભૂલ જેવા લલચાવવું

869
00:37:29,910 --> 00:37:31,710
અહીં આ એક છે.

870
00:37:31,710 --> 00:37:32,060
બધા અધિકાર.

871
00:37:32,060 --> 00:37:37,240
પછી કોઈપણ પ્રશ્નો મેમરી?

872
00:37:37,240 --> 00:37:37,590
>> બધા અધિકાર.

873
00:37:37,590 --> 00:37:40,610
અંતે, પછી માતાનો અહીં એક નજર નાંખો
અમે માટે લઈ આવી છે કંઈક

874
00:37:40,610 --> 00:37:48,361
અમુક સમય માટે શાંત મંજૂર છે, કે જે
cs50.h. કહેવાય આ ફાઈલની છે

875
00:37:48,361 --> 00:37:49,420
તેથી આ એક ફાઇલ છે.

876
00:37:49,420 --> 00:37:51,130
આ માત્ર એક આખા ટોળું છે
ઉપર ટિપ્પણીઓ છે.

877
00:37:51,130 --> 00:37:53,900
અને જો તમે આ હો તો જોવામાં છે શકે
જો તમે ઉપકરણ પર આસપાસ poked.

878
00:37:53,900 --> 00:37:57,000
પરંતુ તે છે, કે જે બધા સમય બહાર વળે
અમે એક તરીકે શબ્દમાળા વાપરવા માટે વપરાય છે ત્યારે

879
00:37:57,000 --> 00:38:01,130
સમાનાર્થી, અમે જાહેર છે કે જેના દ્વારા અર્થ
કે પર્યાય આ સાથે હતી

880
00:38:01,130 --> 00:38:03,990
પ્રકાર વ્યાખ્યા માટે typedef કીવર્ડ.

881
00:38:03,990 --> 00:38:07,500
અને અમે આવશ્યક કહી રહ્યાં છે, બનાવવા
ચાર સ્ટાર સમાનાર્થી સ્ટ્રિંગ.

882
00:38:07,500 --> 00:38:11,190
કે અર્થ છે કે જેના દ્વારા સ્ટેક
તરીકે પણ ઓળખાય છે, આ તાલીમ વ્હીલ્સ બનાવનાર

883
00:38:11,190 --> 00:38:12,040
શબ્દમાળા.

884
00:38:12,040 --> 00:38:14,830
>> હવે અહીં માત્ર એક પ્રોટોટાઇપ છે
getchar માટે.

885
00:38:14,830 --> 00:38:17,350
અમે પહેલાં તેને જોઈ હોય શકે છે, પરંતુ તે છે
ખરેખર તે શું કરે છે. getchar

886
00:38:17,350 --> 00:38:19,070
, કોઈ દલીલો લે છે એક ચાર આપે છે.

887
00:38:19,070 --> 00:38:21,340
getdouble, કોઈ દલીલો લે છે
ડબલ આપે છે.

888
00:38:21,340 --> 00:38:24,440
getfloat કોઈ દલીલો, વળતર લે છે
એક ફ્લોટ, અને તેથી આગળ.

889
00:38:24,440 --> 00:38:27,270
getint અહીં છે. getlonglong
અહીં છે.

890
00:38:27,270 --> 00:38:28,820
અને getstring અહીં છે.

891
00:38:28,820 --> 00:38:29,420
અને તે છે.

892
00:38:29,420 --> 00:38:33,080
આ જાંબલી લીટી અન્ય preprocessor છે
કારણ ડાઈરેક્ટીવ

893
00:38:33,080 --> 00:38:35,550
તે શરૂઆતમાં hashtag.

894
00:38:35,550 --> 00:38:35,870
>> બધા અધિકાર.

895
00:38:35,870 --> 00:38:38,380
તેથી હવે મને cs50.c. માં જવા દો

896
00:38:38,380 --> 00:38:40,400
અને અમે આ ખૂબ લાંબુ વાત નહીં.

897
00:38:40,400 --> 00:38:43,280
પરંતુ તમે શું એક ઝલક આપી
આ બધા પર જવા દેવામાં

898
00:38:43,280 --> 00:38:46,434
સમય, મને જવા દો -

899
00:38:46,434 --> 00:38:48,250
લેટ્સ getchar નથી.

900
00:38:48,250 --> 00:38:51,050
તેથી getchar મોટે ભાગે ટિપ્પણીઓ છે.

901
00:38:51,050 --> 00:38:52,060
પરંતુ તે આ જેમ દેખાય છે.

902
00:38:52,060 --> 00:38:54,800
તેથી આ વાસ્તવિક કાર્ય છે
અમે કરી છે કે getchar

903
00:38:54,800 --> 00:38:56,055
મંજૂર માટે લઈ અસ્તિત્વમાં છે.

904
00:38:56,055 --> 00:38:59,370
અને અમે આ વાપરો નહિં હોય છતાં પણ
ઘણીવાર તો ક્યારેય, તે ઓછામાં ઓછો છે

905
00:38:59,370 --> 00:39:00,470
પ્રમાણમાં સરળ.

906
00:39:00,470 --> 00:39:02,580
તેથી તે લઈ વર્થ છે
અહીં અંતે ઝડપી જુઓ.

907
00:39:02,580 --> 00:39:06,540
>> તેથી getchar, અનંત લૂપ છે
ઇરાદાપૂર્વક તેથી દેખીતી રીતે.

908
00:39:06,540 --> 00:39:10,050
તે પછી કહે છે - અને આ એક પ્રકારની છે
કોડ ઓફ સરસ પુનઃઉપયોગ આપણે આપણી જાતને લખ્યું.

909
00:39:10,050 --> 00:39:11,220
તે getstring કહે છે.

910
00:39:11,220 --> 00:39:12,460
તે શું કરે છે, કારણ કે
એક ચાર વિચાર અર્થ?

911
00:39:12,460 --> 00:39:14,730
વેલ, તમે પણ એક વિચાર પ્રયત્ન કરી શકો છો
સમગ્ર વપરાશકર્તા માંથી લખાણ વાક્ય અને

912
00:39:14,730 --> 00:39:16,940
પછી માત્ર એક જોવા
તે અક્ષરો.

913
00:39:16,940 --> 00:39:19,170
રેખા 60, અહીં થોડી છે
એક સેનીટી ચેક બીટ.

914
00:39:19,170 --> 00:39:21,610
Getstring નલ ફર્યો, તો
માતાનો આગળ વધવું ન જોઈએ.

915
00:39:21,610 --> 00:39:22,820
કંઈક ખોટું થયું હતું.

916
00:39:22,820 --> 00:39:28,120
>> હવે આ અંશે હેરાન કરે છે, પરંતુ
કદાચ સી ચાર મહત્તમ માં પરંપરાગત

917
00:39:28,120 --> 00:39:29,960
રજૂ શું માત્ર
તેના નામ પર આધારિત છે?

918
00:39:29,960 --> 00:39:31,670
જો તે સતત છે.

919
00:39:31,670 --> 00:39:36,040
તે ના આંકડાકીય કિંમત જેવી છે
તમારી સાથે પ્રતિનિધિત્વ કરી શકે ચાર મોટી

920
00:39:36,040 --> 00:39:40,370
કદાચ નંબર છે જે એક ડંખ,
સૌથી નંબર છે, જે તમે 255,

921
00:39:40,370 --> 00:39:42,720
આઠ બિટ્સ પ્રતિનિધિત્વ
શૂન્ય થી શરૂ.

922
00:39:42,720 --> 00:39:47,460
તેથી હું જ્યારે આ કાર્ય માં, આ ઉપયોગ કર્યા છે
કારણ કે માત્ર આ કોડ લેખિત

923
00:39:47,460 --> 00:39:51,753
કંઈક getchar માં ખોટું છે પરંતુ જો
જીવનમાં તેની હેતુ એક પાછા છે

924
00:39:51,753 --> 00:39:54,830
ચાર, તમે અચાનક આપની સમક્ષ જરૂર છે
કે વપરાશકર્તા માટે સિગ્નલ

925
00:39:54,830 --> 00:39:55,840
કંઈક ખોટું થયું હતું.

926
00:39:55,840 --> 00:39:56,970
અમે નલ પાછા ન કરી શકો છો.

927
00:39:56,970 --> 00:39:58,480
તે નલ એક નિર્દેશક છે કે કરે છે.

928
00:39:58,480 --> 00:40:01,030
અને ફરી, getchar છે
એક ચાર પરત ફરો.

929
00:40:01,030 --> 00:40:04,760
>> તેથી સંમેલન, કંઈક જાય તો
ખોટું, તમે પ્રોગ્રામર, અથવા, છે

930
00:40:04,760 --> 00:40:08,160
આ કિસ્સામાં, મને લાઇબ્રેરી સાથે, હું હતો
એક, ફક્ત જો આપખુદ નિર્ણય

931
00:40:08,160 --> 00:40:12,230
કંઈક ખોટું થાય, હું જાઉં છું
સાચી છે, કે જે નંબર 255, પાછા

932
00:40:12,230 --> 00:40:17,240
અમે, વપરાશકર્તા પ્રકાર નથી કરી શકતો નથી કરી શકે છે એનો અર્થ એ થાય
દ્વારા રજૂ અક્ષર

933
00:40:17,240 --> 00:40:21,410
અમે હતી કારણ કે નંબર 255 તેની ચોરી
એક કહેવાતા સંત્રી કિંમત તરીકે

934
00:40:21,410 --> 00:40:23,410
એક સમસ્યા પર આધારિત છે.

935
00:40:23,410 --> 00:40:27,010
હવે તે બહાર વળે કે જે અક્ષર 255
પર તમે ટાઈપ કરી શકો છો કંઈક નથી

936
00:40:27,010 --> 00:40:28,380
તમારા કીબોર્ડ છે, તેથી તેને કોઈ મોટા સોદો છે.

937
00:40:28,380 --> 00:40:30,910
વપરાશકર્તા નોટિસ નથી
હું આ પાત્ર ચોરી કરી છે.

938
00:40:30,910 --> 00:40:34,620
પરંતુ તમે ક્યારેય પર મદદ પાનાંઓમાં પણ જુઓ તો
એક કમ્પ્યુટર સિસ્ટમ કેટલાક સંદર્ભ

939
00:40:34,620 --> 00:40:38,560
કહે છે કે, સતત આ જેમ બધા કેપ્સ
ભૂલ તો આ સતત ઓફ માઇટ કિસ્સાઓમાં

940
00:40:38,560 --> 00:40:42,720
પરત કરવામાં, કે જે કર્યું બધા કેટલાક માનવ છે
વર્ષો પહેલા આપખુદ લીધી હતી

941
00:40:42,720 --> 00:40:45,680
આ ખાસ કિંમત અને પાછા
તે કિસ્સામાં સતત કૉલ

942
00:40:45,680 --> 00:40:46,840
કંઈક ખોટું થાય.

943
00:40:46,840 --> 00:40:48,580
>> હવે જાદુ અહીં નીચે થાય છે.

944
00:40:48,580 --> 00:40:52,600
પ્રથમ, હું રેખા 67 માં જાહેર છું
બે અક્ષરો, C1 અને c2.

945
00:40:52,600 --> 00:40:57,080
અને પછી વાક્ય 68 માં, ખરેખર છે
યાદ અપાવે છે કે કોડ કે જે એક લીટી

946
00:40:57,080 --> 00:41:01,140
અમારા મિત્ર printf આપવામાં તે
અવતરણ ટકા સીએસ નથી.

947
00:41:01,140 --> 00:41:06,490
પરંતુ અહીં શું થઈ રહ્યું છે તે જુઓ.
sscanf શબ્દમાળા સ્કેન અર્થ થાય છે -

948
00:41:06,490 --> 00:41:11,690
એક ફોર્મેટ સ્કૅન અર્થ એ થાય
સ્ટ્રિંગ, તેને લીધે sscanf.

949
00:41:11,690 --> 00:41:12,590
કે શું અર્થ છે?

950
00:41:12,590 --> 00:41:16,310
જો તમે શબ્દમાળા sscanf પસાર થાય છે.

951
00:41:16,310 --> 00:41:18,420
અને રેખા ગમે છે
સાઇન વપરાશકર્તા પ્રકારો

952
00:41:18,420 --> 00:41:23,520
તમે ફોર્મેટ સ્ટ્રિંગ જેવા sscanf પસાર
શું છે scanf કહે છે કે આ

953
00:41:23,520 --> 00:41:25,870
તમે વપરાશકર્તા સાઇન લખ્યો છે આશા

954
00:41:25,870 --> 00:41:29,730
પછી તમે પસાર માં બે સરનામાં
આ કિસ્સામાં મેમરી હિસ્સામાં,,

955
00:41:29,730 --> 00:41:31,150
હું બે જગ્યામાં હોય છે.

956
00:41:31,150 --> 00:41:34,610
તેથી હું તેને સરનામા આપવા જઈ રહ્યો છું
C1 અને c2 નું સરનામું.

957
00:41:34,610 --> 00:41:37,700
>> અને તમે કામગીરી આપી કે યાદ
કેટલાક ચલ ઓફ સરનામું, શું છે

958
00:41:37,700 --> 00:41:38,950
જો સૂચિતાર્થ?

959
00:41:38,950 --> 00:41:41,400

960
00:41:41,400 --> 00:41:45,050
કે કાર્ય પરિણામે શું કરી શકો
જો તે ના સરનામા આપવાની

961
00:41:45,050 --> 00:41:48,170
ચલ, તરીકે વિરોધ
જો ચલ પોતે?

962
00:41:48,170 --> 00:41:49,450
તે હક, તેને બદલી શકે છે?

963
00:41:49,450 --> 00:41:53,250
તમે કોઈને ભૌતિક એક નકશો હોય તો
સરનામું, તેઓ ત્યાં જાય છે અને શું કરી શકો છો

964
00:41:53,250 --> 00:41:54,750
તેઓ સરનામા અંતે માંગો ગમે.

965
00:41:54,750 --> 00:41:55,800
અહીં જ વિચાર.

966
00:41:55,800 --> 00:41:59,950
અમે sscanf, બે સરનામા માટે પસાર તો
પણ મેમરી હિસ્સામાં, આ નાના

967
00:41:59,950 --> 00:42:03,585
મેમરી, C1 અને c2 થોડા હિસ્સામાં, પરંતુ
અમે તેને ની સરનામા કહેવું

968
00:42:03,585 --> 00:42:05,170
sscanf તેને બદલી શકે છે.

969
00:42:05,170 --> 00:42:08,530
>> જીવન માં sscanf માતાનો હેતુ તેથી, અમે વાંચી જો
માણસ પાનું, વાંચવા માટે છે શું

970
00:42:08,530 --> 00:42:13,420
વપરાશકર્તા ટાઇપ, ધરાવતા વપરાશકર્તા માટે આશા
એક અક્ષર ટાઇપ અને કદાચ

971
00:42:13,420 --> 00:42:16,470
અન્ય પાત્ર અને ગમે તે વપરાશકર્તા
ટાઇપ, પ્રથમ અક્ષર જાય

972
00:42:16,470 --> 00:42:19,310
અહીં, બીજા અક્ષર અહીં જાય છે.

973
00:42:19,310 --> 00:42:22,470
હવે, એક કોરે તરીકે, આ, અને તમે કરશે
માત્ર, દસ્તાવેજીકરણને આ ખબર

974
00:42:22,470 --> 00:42:25,570
હું ત્યાં ખાલી જગ્યા મૂકવામાં હકીકત એ છે કે
માત્ર હું કાળજી નથી અર્થ એ થાય કે જો

975
00:42:25,570 --> 00:42:28,440
વપરાશકર્તા સ્પેસ બાર થોડા સ્કોર
તે અથવા તેણી એક લે વખત પહેલાં

976
00:42:28,440 --> 00:42:30,400
પાત્ર, હું અવગણવા માટે જઇ રહ્યો છું
કોઇપણ સફેદ જગ્યા.

977
00:42:30,400 --> 00:42:32,510
જેથી મેં ખબર
દસ્તાવેજીકરણ.

978
00:42:32,510 --> 00:42:36,570
>> બીજા% કેચ છે તે હકીકત
સફેદ જગ્યા અનુસરતા ખરેખર છે

979
00:42:36,570 --> 00:42:37,410
ઇરાદાપૂર્વકની.

980
00:42:37,410 --> 00:42:41,190
હું શોધવા માટે સક્ષમ થવા માંગતા હોય તો વપરાશકર્તા
ખરાબ અથવા સહકાર ન હતી.

981
00:42:41,190 --> 00:42:45,630
તેથી હું વપરાશકર્તા માત્ર ટાઇપ કે આશા છું
એક પાત્ર, તેથી હું આશા કરું છું

982
00:42:45,630 --> 00:42:50,640
કે sscanf માત્ર પાછા જવાનું છે
કિંમત 1 હું વાંચી હોય તો, ફરી, કારણ કે

983
00:42:50,640 --> 00:42:55,400
દસ્તાવેજીકરણ, sscanf માતાનો હેતુ માં
જીવન નંબર પર પાછા છે

984
00:42:55,400 --> 00:42:59,170
ભરવામાં આવ્યા હતા કે ચલો
વપરાશકર્તા ઈનપુટ છે.

985
00:42:59,170 --> 00:43:02,270
>> હું બે ચલો માં પસાર
સરનામાં, C1 અને c2.

986
00:43:02,270 --> 00:43:06,420
હું કે જે, જોકે, આશા છું ફક્ત એક
તેમને માર્યા નહીં કારણ કે જો sscanf

987
00:43:06,420 --> 00:43:11,130
વળતર 2, એવું માની શકાય કે શું
તાર્કિક રીતે ઉદભવે છે?

988
00:43:11,130 --> 00:43:14,600
વપરાશકર્તા માત્ર મને એક આપી ન હતી
પાત્ર જેમ હું તેમને જણાવ્યું હતું કે તેણી.

989
00:43:14,600 --> 00:43:17,860
તેઓ કદાચ અંતે ટાઇપ
ઓછામાં બે અક્ષરો.

990
00:43:17,860 --> 00:43:22,430
હું બદલે બીજા ન હતી તેથી જો
% C, હું માત્ર, એક હતી

991
00:43:22,430 --> 00:43:25,370
પ્રમાણિકપણે વધુ હશે
અભિગમ, હું પ્રથમ નજરે લાગે છે,

992
00:43:25,370 --> 00:43:30,220
તમે શોધવા માટે આપની સમક્ષ જવા નથી
વપરાશકર્તા તમે વધુ આપે છે જો

993
00:43:30,220 --> 00:43:31,780
તમે ખરેખર ઇચ્છતા કરતાં ઇનપુટ.

994
00:43:31,780 --> 00:43:34,100
તેથી આ એક ગર્ભિત સ્વરૂપ છે
ભૂલ ચકાસણી છે.

995
00:43:34,100 --> 00:43:35,640
>> પરંતુ હું અહીં શું નોટિસ.

996
00:43:35,640 --> 00:43:39,970
એકવાર હું વપરાશકર્તા મને એક આપ્યો ખાતરી કરો કે છું
પાત્ર, હું કરી લીટી મુક્ત

997
00:43:39,970 --> 00:43:44,450
getstring વિરુદ્ધની છે, કે જે વળાંક
હું પાછા પછી malloc વાપરે છે, અને

998
00:43:44,450 --> 00:43:51,030
C1, હું આશા છે કે અક્ષર
વપરાશકર્તા પૂરી પાડવામાં અને માત્ર પૂરી પાડી હતી.

999
00:43:51,030 --> 00:43:54,680
જેથી ઝડપી જ અસ્પષ્ટ છે, પરંતુ
getchar પર કોઈ પ્રશ્ન?

1000
00:43:54,680 --> 00:43:57,450

1001
00:43:57,450 --> 00:43:59,590
અમે અન્ય કેટલાક પાછા આવો પડશે.

1002
00:43:59,590 --> 00:44:03,770
>> ઠીક છે, મને આગળ વધો અને આ કરવા દો -
માત્ર ઉત્સાહિત કરવા માટે, હવે ધારવું અમારા

1003
00:44:03,770 --> 00:44:08,910
એક સપ્તાહ વત્તા સમય ચર્ચા, તો આ
structs.h નામની એક ફાઇલ છે.

1004
00:44:08,910 --> 00:44:11,440
અને ફરીથી, આ માત્ર સ્વાદ છે,
આગળ આવેલો છે કે જે કંઈક છે.

1005
00:44:11,440 --> 00:44:13,090
પરંતુ નોટિસ કે ઘણો
આ ટિપ્પણી છે.

1006
00:44:13,090 --> 00:44:17,440
તેથી મને પ્રકાશિત દો માત્ર
હવે માટે રસપ્રદ ભાગ છે.

1007
00:44:17,440 --> 00:44:18,020
typedef -

1008
00:44:18,020 --> 00:44:19,700
તે જ શબ્દ ફરીથી છે.

1009
00:44:19,700 --> 00:44:23,100
typedef અમે શબ્દમાળા જાહેર કરવા ઉપયોગ
ખાસ માહિતી પ્રકાર તરીકે.

1010
00:44:23,100 --> 00:44:27,490
તમે એકદમ નવા બનાવવા માટે typedef ઉપયોગ કરી શકો છો
જ્યારે અસ્તિત્વમાં નથી ડેટા પ્રકારો

1011
00:44:27,490 --> 00:44:28,570
સી શોધ કરવામાં આવી હતી.

1012
00:44:28,570 --> 00:44:32,520
હમણાં પૂરતું, Int સી ચાર સાથે આવે છે
સી ડબલ સી સાથે આવે છે સાથે આવે છે, પરંતુ

1013
00:44:32,520 --> 00:44:34,000
એક વિદ્યાર્થી કોઈ ખ્યાલ નથી.

1014
00:44:34,000 --> 00:44:37,230
અને હજી સુધી તે માટે ખૂબ ઉપયોગી હશે
સંગ્રહ કરે છે કે એક પ્રોગ્રામ લખવા માટે સમર્થ

1015
00:44:37,230 --> 00:44:40,440
એક ચલ, એક વિદ્યાર્થી ID નંબર,
તેમના નામ, અને તેમના મકાન છે.

1016
00:44:40,440 --> 00:44:42,890
અન્ય શબ્દોમાં, ત્રણ ટુકડાઓ
માહિતી, એક ઈન્ અને ગમે

1017
00:44:42,890 --> 00:44:44,420
સ્ટ્રિંગ અને અન્ય સ્ટ્રિંગ.

1018
00:44:44,420 --> 00:44:48,220
>> Typedef સાથે, શું ખૂબ શક્તિશાળી છે
માટે આ અને કીવર્ડ sturct વિશે

1019
00:44:48,220 --> 00:44:53,660
માળખું, તમે 2013 માં પ્રોગ્રામર,
વાસ્તવમાં તમારા પોતાના વ્યાખ્યાયિત કરી શકો છો

1020
00:44:53,660 --> 00:44:57,530
વર્ષ અસ્તિત્વમાં નથી ડેટા પ્રકારો
પહેલાં પરંતુ તે તમારા હેતુ સંતોષવા.

1021
00:44:57,530 --> 00:45:01,910
અને તેથી અહીં, 19 દ્વારા લાઇન 13,
અમે, જેમ કે નવા માહિતી પ્રકાર જાહેર કરી રહ્યા છીએ

1022
00:45:01,910 --> 00:45:04,320
એક Int, પરંતુ તે વિદ્યાર્થી ફોન.

1023
00:45:04,320 --> 00:45:09,310
અને અંદર આ ચલની ચાલે છે
એક Int, એક શબ્દમાળા - ત્રણ વસ્તુઓ હોઈ

1024
00:45:09,310 --> 00:45:09,930
અને શબ્દમાળા.

1025
00:45:09,930 --> 00:45:13,040
તેથી તમે ખરેખર શું છે તે વિચાર કરી શકો છો
આ છે, છતાં પણ અહીં થયું એક

1026
00:45:13,040 --> 00:45:17,160
આજે માટે એક સરળીકરણના બીટ,
એક વિદ્યાર્થી અનિવાર્યપણે ચાલે છે

1027
00:45:17,160 --> 00:45:19,450
આ જેમ દેખાય છે.

1028
00:45:19,450 --> 00:45:22,580
તેના એક ભાગ હશે
એક ID સાથે મેમરી, એક નામ

1029
00:45:22,580 --> 00:45:25,580
ક્ષેત્ર, અને એક ઘર ક્ષેત્ર.

1030
00:45:25,580 --> 00:45:30,670
અને અમે તે હિસ્સામાં ઉપયોગ સમક્ષ રજુ કરવાનો પ્રયત્ન કરીશું
મેમરી અને તેમને ઍક્સેસ તરીકે અનુસરે છે.

1031
00:45:30,670 --> 00:45:38,870
>> હું struct0.c જાય, તો અહીં છે
પ્રમાણમાં લાંબા છે, પરંતુ બાદ

1032
00:45:38,870 --> 00:45:42,630
કોડ ઓફ પેટર્ન, કે
આ નવી યુક્તિ ઉપયોગ કરે છે.

1033
00:45:42,630 --> 00:45:45,790
તેથી, પ્રથમ મને તમારા તરફ ધ્યાન દોરવા દો
ઉપર રસપ્રદ ભાગો છે.

1034
00:45:45,790 --> 00:45:49,670
સીધા વિદ્યાર્થીઓ 3 વ્યાખ્યાયિત કરે છે, જાહેર એક
સતત કહેવાય વિદ્યાર્થીઓ અને સોંપે

1035
00:45:49,670 --> 00:45:53,450
તે માત્ર આપખુદ નંબર 3,
તેથી હું મદદથી ત્રણ વિદ્યાર્થીઓ છે

1036
00:45:53,450 --> 00:45:54,830
હવે આ કાર્યક્રમ.

1037
00:45:54,830 --> 00:45:55,960
અહીં મુખ્ય આવે છે.

1038
00:45:55,960 --> 00:45:58,860
અને સૂચના, હું કેવી રીતે જાહેર નથી
વિદ્યાર્થીઓ એક એરે?

1039
00:45:58,860 --> 00:46:00,480
ઠીક છે, હું માત્ર એક જ વાક્યરચના વાપરે છે.

1040
00:46:00,480 --> 00:46:02,110
આ શબ્દ વિદ્યાર્થી દેખીતી રીતે નવા છે.

1041
00:46:02,110 --> 00:46:04,790
પરંતુ વિદ્યાર્થી, વર્ગ, કૌંસ વિદ્યાર્થીઓ.

1042
00:46:04,790 --> 00:46:06,720
>> તેથી કમનસીબે ઘણો છે
અહીં શબ્દો પુનઃઉપયોગ છે.

1043
00:46:06,720 --> 00:46:07,660
આ માત્ર એક નંબર છે.

1044
00:46:07,660 --> 00:46:09,040
તેથી આ ત્રણ કહીને જેવી છે.

1045
00:46:09,040 --> 00:46:11,430
વર્ગ હું માંગો છો માત્ર શું છે
જો ચલ કૉલ કરવા માટે.

1046
00:46:11,430 --> 00:46:12,840
હું તે વિદ્યાર્થીઓ કૉલ કરી શકે છે.

1047
00:46:12,840 --> 00:46:15,880
પરંતુ વર્ગ, આ એક વર્ગ છે
ઑબ્જેક્ટ લક્ષી જાવા પ્રકારની માર્ગ છે.

1048
00:46:15,880 --> 00:46:17,220
તે માત્ર વિદ્યાર્થીઓ એક વર્ગ છે.

1049
00:46:17,220 --> 00:46:20,590
અને દરેક તત્વ ની માહિતી પ્રકાર
કે એરેમાં વિદ્યાર્થી છે.

1050
00:46:20,590 --> 00:46:23,040
તેથી આ થોડું અલગ છે
અને કંઈક કહીને માંથી

1051
00:46:23,040 --> 00:46:25,250
આ જેમ, તે માત્ર છે -

1052
00:46:25,250 --> 00:46:29,500
હું મને ત્રણ વિદ્યાર્થીઓ આપવા કહી રહ્યો છું
અને તે એરે વર્ગ કૉલ કરો.

1053
00:46:29,500 --> 00:46:29,800
>> બધા અધિકાર.

1054
00:46:29,800 --> 00:46:30,680
હવે અહીં ચાર લૂપ છે.

1055
00:46:30,680 --> 00:46:33,480
આ વ્યક્તિ માતાનો પરિચિત - ફરી વળવું
આ બોલ પર શૂન્ય ત્રણ.

1056
00:46:33,480 --> 00:46:35,160
અને અહીં વાક્યરચના નવા ભાગ છે.

1057
00:46:35,160 --> 00:46:37,710
આ કાર્યક્રમ, મને પૂછવા રહ્યું
જો તે વિદ્યાર્થી આપવા માનવ,

1058
00:46:37,710 --> 00:46:39,200
એક ઈન્ છે જે ને.

1059
00:46:39,200 --> 00:46:44,650
અને અહીં તમે કરી શકો છો કે જેની સાથે વાક્યરચના છે
ખાતે આઈડી ક્ષેત્ર માં કંઈક સંગ્રહ

1060
00:46:44,650 --> 00:46:48,630
પાંચ આંકડાના US સ્થાન વર્ગ કૌંસ આઇ તેથી
આ વાક્યરચના નવી નથી.

1061
00:46:48,630 --> 00:46:51,450
આ માત્ર મને આઠમા આપવા અર્થ એ થાય
વર્ગ માં વિદ્યાર્થી.

1062
00:46:51,450 --> 00:46:52,940
પરંતુ આ પ્રતીક નવી છે.

1063
00:46:52,940 --> 00:46:56,320
ઉપર હવે ત્યાં સુધી, અમે કોઈ ઉપયોગ નથી કરી શકો છો કર્યું
આ જેમ ઓછામાં ઓછા માં કોડ.

1064
00:46:56,320 --> 00:47:01,490
આ સાધન તરીકે ઓળખાય સ્ટ્રક્ટ પર જાઓ
એક વિદ્યાર્થી અને ત્યાં કંઈક મૂકો.

1065
00:47:01,490 --> 00:47:05,670
એ જ રીતે, આ આગામી લાઇન, 31, જાઓ
આગળ અને મૂકવામાં ગમે તે વપરાશકર્તા પ્રકારો

1066
00:47:05,670 --> 00:47:10,530
અહીં એક નામ માટે અને શું તેઓ માટે શું
ઘર, આ જ વસ્તુ, આગળ વધો અને

1067
00:47:10,530 --> 00:47:13,230
. ઘરમાં મૂકી.

1068
00:47:13,230 --> 00:47:15,955
>> તેથી આ કાર્યક્રમ શું કરે છે
આખરે શું?

1069
00:47:15,955 --> 00:47:17,220
તમે ત્યાં થોડી સતામણી જોઈ શકો છો.

1070
00:47:17,220 --> 00:47:24,780
મને આગળ વધો અને સ્ટ્ર્ક્ટ્સ 0 બનાવવા દો
કોઈ સ્લેશ સ્ટ્રક્ટ 0, વિદ્યાર્થી ID ને 1,

1071
00:47:24,780 --> 00:47:28,250
ડેવિડ માથેર, વિદ્યાર્થી આઈડી 2 કહે છે.

1072
00:47:28,250 --> 00:47:32,070
રોબ કિર્કલૅંડ, વિદ્યાર્થી આઈડી 3.

1073
00:47:32,070 --> 00:47:35,010
લોરેન Leverit -

1074
00:47:35,010 --> 00:47:38,380
અને આ કાર્યક્રમ હતી જ વસ્તુ,
છે, કે જે માત્ર સંપૂર્ણપણે મનસ્વી છે

1075
00:47:38,380 --> 00:47:40,980
હું આ માહિતી સાથે કંઈક કરું તેવું ઇચ્છતાં
હું કેવી રીતે અમને શીખવવામાં કર્યું હવે તે

1076
00:47:40,980 --> 00:47:43,450
સ્ટ્ર્ક્ટ્સ ઉપયોગ, હું હમણાં જ હતી છે
અહીં આ વધારાની લૂપ.

1077
00:47:43,450 --> 00:47:45,260
હું વિદ્યાર્થીઓ એરે પર ફરી વળવું.

1078
00:47:45,260 --> 00:47:49,170
હું અમારા છે, કદાચ હવે પરિચિત મિત્ર ઉપયોગ
શબ્દમાળાને, stircomp તુલના

1079
00:47:49,170 --> 00:47:53,780
ચેક 8 વિદ્યાર્થી ઘર છે
માથેર બરાબર?

1080
00:47:53,780 --> 00:47:56,760
અને તેથી જો, માત્ર કંઈક છાપવા
આપખુદ માંગો, હા, છે.

1081
00:47:56,760 --> 00:47:59,430
પરંતુ ફરીથી, ફક્ત મારા તકો આપવી
અને ઉપયોગ અને ફરી ઉપયોગ કરવા

1082
00:47:59,430 --> 00:48:02,270
આ નવા કોઈ સંકેત પુનઃઉપયોગ.

1083
00:48:02,270 --> 00:48:03,250
>> તેથી જે અધિકાર, ધ્યાન આપતા?

1084
00:48:03,250 --> 00:48:06,270
એક વિદ્યાર્થી કાર્યક્રમ સાથે આવે છે
કંઈક મનસ્વી, પરંતુ તે બહાર વળે

1085
00:48:06,270 --> 00:48:09,800
અમે સાથે ઉપયોગી વસ્તુઓ કરી શકો છો કે જે
આ ઉદાહરણ તરીકે અનુસરે છે.

1086
00:48:09,800 --> 00:48:14,600
આ એક વધુ જટિલ સ્ટ્રક્ટ છે
સી માં તે એક ડઝન અથવા વધુ ક્ષેત્રોમાં ગોટ

1087
00:48:14,600 --> 00:48:15,880
કંઈક અંશે રહસ્યમય નામ આપ્યું હતું.

1088
00:48:15,880 --> 00:48:20,110
પરંતુ તમે ક્યારેય ગ્રાફિક્સ સાંભળ્યું હોય તો
બીટમેપ કહેવાય ફાઇલ ફોર્મેટ, BMP, તે

1089
00:48:20,110 --> 00:48:22,830
બહાર વળે કે બીટમેપ ફાઇલ ફોર્મેટ
ખૂબ ખૂબ કે આ જેમ દેખાય છે.

1090
00:48:22,830 --> 00:48:24,200
જો તે મૂર્ખ થોડી હસતો ચહેરો છે.

1091
00:48:24,200 --> 00:48:27,840
તે હું ઝૂમ કરેલું છે તે નાના છબી છે
ખૂબ મોટા પર હું દરેક જોઈ શકે છે કે જેથી

1092
00:48:27,840 --> 00:48:30,410
વ્યક્તિગત બિંદુઓ કે પિક્સેલ.

1093
00:48:30,410 --> 00:48:33,800
અમે પ્રતિનિધિત્વ કરી શકે છે હવે, તે વળે
સંખ્યા 0, કહે છે, સાથે કાળા પર કોઈ.

1094
00:48:33,800 --> 00:48:35,520
નંબર 1 અને સફેદ ટપકું.

1095
00:48:35,520 --> 00:48:39,140
>> તેથી અન્ય શબ્દોમાં, તમે ઇચ્છો તો એક ડ્રો
હસતો ચહેરો અને તે છબી સાચવો

1096
00:48:39,140 --> 00:48:42,680
કોમ્પ્યુટર, તે zeros સંગ્રહ અને કરવા માટે પૂરતા
આના જેવો કે રાશિઓ છે, જ્યાં,

1097
00:48:42,680 --> 00:48:45,250
ફરીથી, રાશિઓ સફેદ હોય છે
અને zeros કાળા છે.

1098
00:48:45,250 --> 00:48:48,290
અને સાથે, તમે અસરકારક રીતે હોય તો
રાશિઓ અને zeros ઓફ સજવું એક, તમે છે

1099
00:48:48,290 --> 00:48:51,030
પિક્સેલ ગ્રીડ, અને તમે મૂકે તો
તેમને બહાર, તમે પહોંચેલું છે

1100
00:48:51,030 --> 00:48:52,560
થોડી હસતો ચહેરો.

1101
00:48:52,560 --> 00:48:58,150
હવે, બીટમેપ ફાઇલ ફોર્મેટ, BMP છે
અસરકારક રીતે કે હૂડ નીચે,

1102
00:48:58,150 --> 00:49:00,970
પરંતુ વધુ પિક્સેલ્સ sot સાથે તમે
વાસ્તવમાં રંગો પ્રતિનિધિત્વ કરી શકે છે.

1103
00:49:00,970 --> 00:49:05,170
>> પરંતુ તમે વધુ આધુનિક હોય ત્યારે
BMP અને JPEG, GIF અને જેમ ફાઈલ બંધારણો

1104
00:49:05,170 --> 00:49:09,360
જેની સાથે તમે, તે પરિચિત હોઈ શકે છે
ડિસ્ક પર ફાઈલો સામાન્ય રીતે માત્ર

1105
00:49:09,360 --> 00:49:13,760
zeros અને પિક્સેલ માટે રાશિઓ હોય છે, પરંતુ
તેઓ તેમજ કેટલાક મેટાડેટા છે -

1106
00:49:13,760 --> 00:49:16,960
ખરેખર નથી કે અર્થમાં મેટા
માહિતી પરંતુ તે ઉપયોગી છે.

1107
00:49:16,960 --> 00:49:21,370
તેથી અહીં આ ક્ષેત્રો, જેનો અર્થ થાય છે અને
અમે પી સેટ વધુ વિગતવાર આ જોશો

1108
00:49:21,370 --> 00:49:25,810
5, કે zeros અને રાશિઓ તે પહેલાં
એક છબીમાં પિક્સેલ્સ પ્રતિનિધિત્વ

1109
00:49:25,810 --> 00:49:29,110
મેટાડેટા એક ટોળું જેમ છે
આ ઇમેજ માપ અને

1110
00:49:29,110 --> 00:49:30,250
છબી પહોળાઈ.

1111
00:49:30,250 --> 00:49:32,910
અને હું કેટલાક બંધ રહ્યો plucking નોટિસ
અહીં મનસ્વી વસ્તુઓ -

1112
00:49:32,910 --> 00:49:34,260
પહોળાઈ અને ઊંચાઈ.

1113
00:49:34,260 --> 00:49:36,160
બીટ સભ્યપદ અને કેટલાક અન્ય વસ્તુઓ.

1114
00:49:36,160 --> 00:49:37,840
તેથી ફાઇલ કેટલાક મેટાડેટા છે.

1115
00:49:37,840 --> 00:49:41,470
>> પરંતુ ફાઈલોને નાખ્યો છે તે સમજવામાં દ્વારા
આ રીતે આઉટ, તમે ખરેખર આ કરી શકો છો

1116
00:49:41,470 --> 00:49:45,890
પછી છબીઓ ચાલાકી, છબીઓ પુનઃપ્રાપ્ત
ડિસ્કમાંથી, છબીઓ માપ બદલો.

1117
00:49:45,890 --> 00:49:47,560
પરંતુ તમે તે જરૂરી નથી કરી શકો છો
તેમને વધારે છે.

1118
00:49:47,560 --> 00:49:48,480
હું એક ફોટોગ્રાફ જરૂર છે.

1119
00:49:48,480 --> 00:49:52,840
તેથી હું તમને જોયું, જે અહીં આરજે પાછા ગયા
અમુક સમય પહેલા સ્ક્રીન પર.

1120
00:49:52,840 --> 00:49:57,160
હું અહીં કીનોટ ખોલો, તો આ છે
શું તમે ઝૂમ કરવાનો પ્રયાસ કરો તો શું થાય અને

1121
00:49:57,160 --> 00:49:59,380
આરજે વધારે છે.

1122
00:49:59,380 --> 00:50:01,480
કુલ ખરેખર કોઇ વધુ સારી રીતે મળતી નથી.

1123
00:50:01,480 --> 00:50:06,240
હવે કીનોટ જો તે છેડછાડ પ્રકારની છે
થોડુંક, માત્ર ઉપર ચળકાટ માટે

1124
00:50:06,240 --> 00:50:11,040
આરજે ખાસ કરીને વિચાર નથી કે હકીકત
તમે સાઇન ઝૂમ જ્યારે ઉન્નત

1125
00:50:11,040 --> 00:50:13,310
અને તે આ રીતે કરો તો,
જો ચોરસ જુઓ?

1126
00:50:13,310 --> 00:50:15,490
અરે વાહ, તમે ચોક્કસપણે જોઈ શકો છો
એક પ્રોજેક્ટર પર સ્ક્વેર.

1127
00:50:15,490 --> 00:50:17,690
>> કે તમે વધારવા જ્યારે તમે વિચાર શું છે.

1128
00:50:17,690 --> 00:50:22,570
પરંતુ સમજણ કેવી રીતે અમારા આરજે અથવા
હસતો ચહેરો અમલમાં મૂકાયેલ છે અમને જણાવો કરશે

1129
00:50:22,570 --> 00:50:24,950
વાસ્તવમાં ચાલવે કે કોડ કે જે લખવા
આ બધી વસ્તુઓ.

1130
00:50:24,950 --> 00:50:29,970
અને હું, હું આ નોંધ પર સમાપ્ત હો વિચાર્યું
એક 55 સેકન્ડ, કે વધારવા

1131
00:50:29,970 --> 00:50:31,230
હું બદલે ગેરમાર્ગે કહે છે, હિંમત.

1132
00:50:31,230 --> 00:50:32,990
>> [વિડિઓ પ્લેબેક]

1133
00:50:32,990 --> 00:50:34,790
>> -કુલ બોલતી છે.

1134
00:50:34,790 --> 00:50:38,310
શું વિશે, મને ખબર નથી.

1135
00:50:38,310 --> 00:50:41,200
>> જેથી અમે શું ખબર નથી?

1136
00:50:41,200 --> 00:50:45,280
>> છે કે 9:15 રે Santoya ખાતે
આ એટીએમ હતો.

1137
00:50:45,280 --> 00:50:47,830
>> જેથી પ્રશ્ન શું છે
કુલ 9:16 ખાતે કરી હતી?

1138
00:50:47,830 --> 00:50:50,750
>> -શૂટીંગ નવ મિલિમીટરની
કંઈક છે.

1139
00:50:50,750 --> 00:50:52,615
કદાચ તેઓ આ સ્નાઈપર જોયું.

1140
00:50:52,615 --> 00:50:54,760
>> અથવા તેમની સાથે કામ કરતા હતા.

1141
00:50:54,760 --> 00:50:56,120
>> -પ્રતીક્ષા.

1142
00:50:56,120 --> 00:50:57,450
એક પાછા જાઓ.

1143
00:50:57,450 --> 00:50:58,700
>> -શું તમે જુઓ છો?

1144
00:50:58,700 --> 00:51:05,530

1145
00:51:05,530 --> 00:51:09,490
>> , સંપૂર્ણ સ્ક્રીન તેમના ચહેરા અપ લાવો.

1146
00:51:09,490 --> 00:51:09,790
>> -તેમના ચશ્મા.

1147
00:51:09,790 --> 00:51:11,040
>> -ત્યાં એક પ્રતિબિંબ છે.

1148
00:51:11,040 --> 00:51:21,790

1149
00:51:21,790 --> 00:51:23,520
>> , જે Neuvitas બેઝબોલ ટીમ છે.

1150
00:51:23,520 --> 00:51:24,530
કે તેમના લોગો છે.

1151
00:51:24,530 --> 00:51:27,040
>> અને તેઓ છે રહેલી વ્યકિત સાથે વાત છે
કે જેકેટ પહેર્યા.

1152
00:51:27,040 --> 00:51:27,530
>> [END વિડિઓ પ્લેબેક]

1153
00:51:27,530 --> 00:51:29,180
>> ડેવિડ જે MALAN: આ ચાલશે
સમસ્યા સમૂહ 5 છે.

1154
00:51:29,180 --> 00:51:30,720
અમે આગામી સપ્તાહમાં તમે જોશો.

1155
00:51:30,720 --> 00:51:32,330
>> MALE સ્પીકર: આગામી CS50 મુ.

1156
00:51:32,330 --> 00:51:39,240
>> [તમરાઓ CHIRPING]

1157
00:51:39,240 --> 00:51:41,270
>> [સંગીત વગાડવાનો]