1
00:00:00,000 --> 00:00:02,742

2
00:00:02,742 --> 00:00:05,680
>> 1 વક્તા: હાય દરેકને.

3
00:00:05,680 --> 00:00:07,530
અમે પ્રારંભ કરવા માટે જતા હોય છે.

4
00:00:07,530 --> 00:00:09,330
હું લોકો હજુ પણ ચાલુ છે લાગે છે
માં ગાળણ છે.

5
00:00:09,330 --> 00:00:12,840
પરંતુ સમય ના હિતમાં, અમે કરી શકો છો જેથી
સમય પર અહીં બહાર તમે ગાય્સ વિચાર,

6
00:00:12,840 --> 00:00:14,110
અમે શરૂ રહ્યા છીએ.

7
00:00:14,110 --> 00:00:18,780
તેથી CS50 ક્વિઝ 0 સમીક્ષા પર આપનું સ્વાગત છે.

8
00:00:18,780 --> 00:00:23,020
સમજાયું ન હોય તેવા તમે તે માટે
હજુ સુધી, તમે બુધવારે એક પ્રશ્ન છે.

9
00:00:23,020 --> 00:00:25,700
વુ-હુ.

10
00:00:25,700 --> 00:00:29,780
>> તમે હજુ સુધી અભ્યાસ શરૂ ન હોય તો અથવા
આ હજુ સુધી અસ્તિત્વમાં છે કે જે સમજાયું છે,

11
00:00:29,780 --> 00:00:34,070
છેલ્લા અંગેની ક્વિઝ અને લગભગ તમામ માહિતી
તમારા ક્વિઝ cs50.net/quizzes પર હોય છે.

12
00:00:34,070 --> 00:00:38,090
કેટલાક ખૂબ સારી સામગ્રી ત્યાં છે,
10 છેલ્લા માંથી છેલ્લા અંગેની ક્વિઝ

13
00:00:38,090 --> 00:00:43,760
વર્ષ તેમજ માહિતી
આ ક્વિઝ અને મુદ્દાઓ વિશે

14
00:00:43,760 --> 00:00:46,250
કે આવરી લેવામાં આવશે.

15
00:00:46,250 --> 00:00:48,980
તેથી આપણે પ્રારંભ કરીએ.

16
00:00:48,980 --> 00:00:54,240
>> તેથી જો તમે ગાય્સ, પ્રથમ યાદ શકે છે
વર્ગ દાઉદના દિવસ તે દીવા પર હતી.

17
00:00:54,240 --> 00:00:59,650
તેથી અનિવાર્યપણે, બધું જાય છે
કમ્પ્યુટર ના હૂડ છે હેઠળ પર

18
00:00:59,650 --> 00:01:00,860
બાઈનરી કરવામાં.

19
00:01:00,860 --> 00:01:04,080
બાઈનરી લાગે શું અર્થ થાય છે
જેમ, 0 અને 1 ની.

20
00:01:04,080 --> 00:01:09,290
તે બે કિંમતો છે
રજૂ કરી શકાય છે.

21
00:01:09,290 --> 00:01:14,675
>> તેથી માત્ર વિભાગ પ્રથમ દિવસે જેમ
ડેવિડ પ્રકાશ ચાલુ જ્યારે

22
00:01:14,675 --> 00:01:21,990
બલ્બ અમારા કમ્પ્યુટર પર પ્રતિનિધિત્વ કરે છે, અથવા 1 માટે
સમજે 0 તરીકે બાઈનરી અને

23
00:01:21,990 --> 00:01:24,110
1 માતાનો, અથવા બંધ.

24
00:01:24,110 --> 00:01:25,360
બાઈનરી ઓફ ઈપીએસ.

25
00:01:25,360 --> 00:01:29,440

26
00:01:29,440 --> 00:01:32,470
દરેક જગ્યાએ રજૂ થાય છે
આધાર બે.

27
00:01:32,470 --> 00:01:36,260
તેથી તમે કરવા માટે 0 થી 2 ઉમેરો
1 બધી રીતે અપ 2 છે.

28
00:01:36,260 --> 00:01:41,970
>> તમારા બાઈનરી છે તે ગણતરી કરવા માટે
બાદ, તમે માત્ર આ સમીકરણ અનુસરો

29
00:01:41,970 --> 00:01:42,840
પ્રકાર વસ્તુ.

30
00:01:42,840 --> 00:01:49,510
તમે તે સ્થળોએ કોઇ એક 1 છે,
તમારા દ્વારા વધવું ગમે

31
00:01:49,510 --> 00:01:53,820
તે છે આધાર, તે ઉમેરો, અને
તમે આ બાદ મળે છે.

32
00:01:53,820 --> 00:01:57,930
તેથી આ તમે ગણતરી કેવી રીતે
બાઈનરી માં 5 છે.

33
00:01:57,930 --> 00:02:01,400
જસ્ટ અમે પર શું કરી રહ્યા હતા જેવા
છેલ્લા સ્લાઇડ, આ તમે કેવી રીતે કરશે છે

34
00:02:01,400 --> 00:02:02,650
5 દ્વારા 1 પ્રતિનિધિત્વ કરે છે.

35
00:02:02,650 --> 00:02:05,320

36
00:02:05,320 --> 00:02:09,660
>> એ જ રીતે, માત્ર તમે ઉમેરી શકો છો ગમે છે અને
બાદ માં સબ્ટ્રેક્ટ અથવા 10 આધાર, અથવા

37
00:02:09,660 --> 00:02:13,040
ખરેખર કોઇ આધાર પર ઉમેરી શકો છો
અને બાઈનરી માં સબ્ટ્રેક્ટ.

38
00:02:13,040 --> 00:02:18,400
જ્યારે તમે અપેક્ષા અનુસાર બરાબર શું
તે વધારે બરાબર છે, બે ઉમેરો

39
00:02:18,400 --> 00:02:24,220
1 કરતાં, તમે એક 1, તે 0 બનાવવા ચાલુ,
અને માત્ર, ઉમેરા તે રીતે કરી

40
00:02:24,220 --> 00:02:29,910
જેમ તમે નિયમિત સાથે અપેક્ષા કરશે
બાદ અથવા અન્ય કોઇ આધાર.

41
00:02:29,910 --> 00:02:30,970
કૂલ.

42
00:02:30,970 --> 00:02:35,140
>> હું બધું પહેલાં જણાવ્યું હતું કે, જેમ જેથી
અમારા કોમ્પ્યુટર હૂડ હેઠળ જાય

43
00:02:35,140 --> 00:02:37,560
0 અને 1 ની, અથવા બાઈનરી કરવામાં આવે છે.

44
00:02:37,560 --> 00:02:43,470
તેથી અમે વ્યક્ત કેવી રીતે, ઉદાહરણ તરીકે,
અક્ષરો, અથવા નંબરો, અથવા અક્ષરો?

45
00:02:43,470 --> 00:02:45,560
અને તે જવાબ તે ASCII છે.

46
00:02:45,560 --> 00:02:49,380
>> ASCII અક્ષરો વચ્ચે મેપિંગ છે
અમે સામાન્ય રીતે જોવા છે કે જે

47
00:02:49,380 --> 00:02:53,360
એ, બી જેવા ઇંગલિશ ભાષા,
સી, નીચા, ડેશો અને

48
00:02:53,360 --> 00:02:54,910
કે કંઈપણ.

49
00:02:54,910 --> 00:02:57,260
અને તે એક ASCII કિંમત છે કે નકશા.

50
00:02:57,260 --> 00:03:03,080
એક ASCII કિંમત માત્ર એક નંબર છે કે
તમારા કમ્પ્યુટર દ્વારા સમજી શકાય છે.

51
00:03:03,080 --> 00:03:07,430
અને તમે ઉપરાંત કરી શકો છો જેમ જ અને
નંબરો સાથે બાદબાકી, તમે શું કરી શકો છો

52
00:03:07,430 --> 00:03:10,890
તે ASCII કિંમતો સાથે.

53
00:03:10,890 --> 00:03:14,050
>> આ ઉદાહરણમાં તેથી શું
આ છાપશે?

54
00:03:14,050 --> 00:03:26,790

55
00:03:26,790 --> 00:03:35,480
અરે વાહ, તેથી માત્ર એક જગ્યા બી જગ્યા સી જગ્યા
ડી જ્યાં મારા માઉસ ક્યાં ગયા હતા?

56
00:03:35,480 --> 00:03:39,200

57
00:03:39,200 --> 00:03:43,380
તમે 65 એક પૂર્ણાંક વ્યાખ્યાયિત કરી શકો છો જુઓ.

58
00:03:43,380 --> 00:03:47,080
અને તમે ઉપયોગ કે છાપે જ્યારે
ટકા સી, તે એક કે અર્થઘટન પડશે

59
00:03:47,080 --> 00:03:49,330
અક્ષર અને એ છાપશે

60
00:03:49,330 --> 00:03:52,800
>> એ જ રીતે, તમે જાહેર કરી શકો છો
તે ચાર રચે છે.

61
00:03:52,800 --> 00:03:56,860
અને તમે ટકા નો ઉપયોગ કરીને તેને છાપે જ્યારે
સી, તે છે કે અર્થઘટન પડશે

62
00:03:56,860 --> 00:04:05,240
ટકા ડી અને તમે ઉમેરી શકો છો જેમ
નંબર, તમે અક્ષરો છે ઉમેરી શકો છો

63
00:04:05,240 --> 00:04:06,878
આ કિસ્સામાં તે ASCII કિંમતો.

64
00:04:06,878 --> 00:04:11,370

65
00:04:11,370 --> 00:04:16,130
>> દરેકને માટે તેથી થોડો નિર્દેશક.

66
00:04:16,130 --> 00:04:19,610
5, શબ્દમાળા તરીકે, નથી
ખરેખર 5 જેટલી.

67
00:04:19,610 --> 00:04:26,610
તેથી અમે કેવી રીતે કન્વર્ટ શકે
પૂર્ણાંક 5 શબ્દમાળા 5?

68
00:04:26,610 --> 00:04:28,930
કોઈપણ વિચારો?

69
00:04:28,930 --> 00:04:31,630
અરે વાહ.

70
00:04:31,630 --> 00:04:36,720
>> તેથી અમે શબ્દમાળા તરીકે 5 હોય તો,
અમે 0 સબ્ટ્રેક્ટ કરી શકો છો.

71
00:04:36,720 --> 00:04:37,820
અને તે અમને 5 આપી શકશો.

72
00:04:37,820 --> 00:04:41,670
અને એ જ રીતે, અમે એક તરીકે 5 હોય તો
પૂર્ણાંક, શબ્દમાળા 0 કે ઉમેરો.

73
00:04:41,670 --> 00:04:43,112
અને તે અમને શબ્દમાળા 5 આપે છે.

74
00:04:43,112 --> 00:04:46,350

75
00:04:46,350 --> 00:04:48,350
કૂલ.

76
00:04:48,350 --> 00:04:52,940
>> હવે, એક જ્યાં લેક્ચર પાછા યાદ
અમે ગાણિતીક નિયમો વિશે વાત કરી.

77
00:04:52,940 --> 00:04:57,260
તેથી અમે ખરેખર કમ્પ્યુટર માંગો છો કેવી રીતે
રસપ્રદ વસ્તુઓ કરવા માટે?

78
00:04:57,260 --> 00:05:00,460
તમે માત્ર ઉમેરવા અને બાદબાકી, ખબર
નંબરો અને પ્રિન્ટીંગ વસ્તુઓ બહાર નથી

79
00:05:00,460 --> 00:05:01,730
કે આકર્ષક.

80
00:05:01,730 --> 00:05:04,620
સામાન્ય રીતે, અમે અમારી કોમ્પ્યુટર માંગો છો
અલ્ગોરિધમનો કેટલાક પ્રકારની કરે છે.

81
00:05:04,620 --> 00:05:07,820
થોડી વધુ જટિલ કંઈક
માત્ર સરળ અંકગણિત કરતાં.

82
00:05:07,820 --> 00:05:11,930
>> એક અલ્ગોરિધમનો પગલું સમૂહ દ્વારા માત્ર એક પગલું છે
કરવા માટે કેવી રીતે માટે સૂચનો

83
00:05:11,930 --> 00:05:14,640
ચોક્કસ task--

84
00:05:14,640 --> 00:05:15,660
માત્ર એક રેસીપી ગમે છે.

85
00:05:15,660 --> 00:05:19,990
તમે પ્રથમ દિવસે યાદ શકે છે
ડેવિડ અમને એક રૂમ ગણતરી હતી જ્યાં વર્ગ

86
00:05:19,990 --> 00:05:22,550
લોકો અને કેવી રીતે ઘણા લોકો
રૂમમાં હતા.

87
00:05:22,550 --> 00:05:24,480
તમે ગણતરી માટે ઉપયોગ થઈ શકે છે
એક પછી એક.

88
00:05:24,480 --> 00:05:25,860
1, 2, 3, 4.

89
00:05:25,860 --> 00:05:28,010
તે કિસ્સામાં, એક રેખીય સમય અલ્ગોરિધમનો.

90
00:05:28,010 --> 00:05:31,710
>> પરંતુ ડેવિડ માટે અલ્ગોરિધમનો રજૂ
તમે રૂમ માં લોકો ગણતરી

91
00:05:31,710 --> 00:05:37,340
દરેક રહે છે, જ્યાં તમે તમારા કહે
અન્ય વ્યક્તિ માટે નંબર, કે ઉમેરો

92
00:05:37,340 --> 00:05:39,200
નંબર ઉપર, અને એક વ્યક્તિ નીચે બેસે છે.

93
00:05:39,200 --> 00:05:40,410
અને તમે તે પુનરાવર્તન કરો.

94
00:05:40,410 --> 00:05:42,910
કે અલ્ગોરિધમનો એક પ્રકાર છે.

95
00:05:42,910 --> 00:05:47,520
અમે કેવી રીતે કાર્યક્ષમ એક વિશ્લેષણ કરી શકે છે
તે સમય ચાલે છે પર અલ્ગોરિધમનો આધારિત છે.

96
00:05:47,520 --> 00:05:49,680
પરંતુ અમે થોડો વાત કરીશું
કે પછી વિશે વધુ.

97
00:05:49,680 --> 00:05:52,740

98
00:05:52,740 --> 00:05:57,090
>> તેથી એ બધા ગાણિતીક નિયમો પણ કરી શકો છો
સ્યુડોકોડનો લખી શકાય.

99
00:05:57,090 --> 00:06:01,120
સ્યુડોકોડનો જેમ એક ઇંગલિશ છે
વાક્યરચના પ્રતિનિધિત્વ કરવા માટે વપરાય

100
00:06:01,120 --> 00:06:02,420
એક પ્રોગ્રામિંગ ભાષા.

101
00:06:02,420 --> 00:06:06,070
ઉદાહરણ તરીકે, એક વપરાશકર્તા અમે ઇચ્છતા હોય તો પૂછો
મારી પ્રિય નંબર ધારી, અમે

102
00:06:06,070 --> 00:06:08,390
જેમ કે સ્યુડોકોડનો હોય શકે છે.

103
00:06:08,390 --> 00:06:09,850
>> એક વપરાશકર્તાઓ ધારી મેળવો.

104
00:06:09,850 --> 00:06:13,570
આ અનુમાન સાચું છે, તો તેમને કહેવું
તેઓ યોગ્ય છો, બીજું તેમને કહેવું

105
00:06:13,570 --> 00:06:15,560
તેઓ યોગ્ય નથી.

106
00:06:15,560 --> 00:06:22,530
અને સ્યુડોકોડનો સરળતાથી એક માર્ગ છે
એક વિચાર કે એક અલ્ગોરિધમનો રજૂ.

107
00:06:22,530 --> 00:06:26,910
તેથી હવે અમે ખરેખર લખવા માંગો છો શકે છે
આ ભાષામાં કે કમ્પ્યુટર

108
00:06:26,910 --> 00:06:27,980
સમજ કદાચ.

109
00:06:27,980 --> 00:06:35,660
જેથી અમે અમારા સ્યુડોકોડનો લખી શકે છે અને
સ્રોત કોડ માં કે અર્થઘટન.

110
00:06:35,660 --> 00:06:41,320
>> અત્યાર સુધી, સ્ત્રોત કોડ પાલન કરવું જ જોઈએ
ચોક્કસ સિન્ટેક્ષ માટે

111
00:06:41,320 --> 00:06:42,490
એક પ્રોગ્રામિંગ ભાષા.

112
00:06:42,490 --> 00:06:45,430
અને અત્યાર સુધી, CS50 માં, અમે કર્યું
મોટે ભાગે સી નો ઉપયોગ કર્યો.

113
00:06:45,430 --> 00:06:48,320
તેથી આ કેચ માટે સ્રોત કોડ હોઈ શકે છે.

114
00:06:48,320 --> 00:06:51,440
પાછળથી દરમિયાન, તમે રાત્રે આવે
અન્ય પ્રોગ્રામિંગ સાથે સંપર્કમાં

115
00:06:51,440 --> 00:06:52,480
PHP, જેવી ભાષાઓ.

116
00:06:52,480 --> 00:06:57,540
અથવા તમે પણ, તમે અન્ય વર્ગો લેવા જો
જાવા, પાયથોન, કે OCML કરી શકે છે.

117
00:06:57,540 --> 00:07:01,570
પરંતુ અમારા સી કાર્યક્રમ ભાષામાં, આ છે
અમે સ્ત્રોત કોડ લખવા શકે છે કેવી રીતે

118
00:07:01,570 --> 00:07:04,760
સ્યુડોકોડનો અલ્ગોરિધમનો કે
હું માત્ર અગાઉ વર્ણન.

119
00:07:04,760 --> 00:07:08,630

120
00:07:08,630 --> 00:07:11,430
>> આમ કેવી રીતે ખરેખર તમારા કમ્પ્યુટર કરે છે
સમજો કે?

121
00:07:11,430 --> 00:07:14,490
હું માત્ર ખરેખર, તે પહેલાં જણાવ્યું હતું કે
zeros અને મુદ્દાઓ સમજે છે.

122
00:07:14,490 --> 00:07:17,880
આમ કેવી રીતે તે સ્ત્રોત માંથી મળી નથી
બની શકે છે કે જે કંઈક માટે કોડ

123
00:07:17,880 --> 00:07:18,960
સમજી?

124
00:07:18,960 --> 00:07:22,920
વેલ, અમે કંઈક હોય
કમ્પાઇલર કહેવામાં આવે છે.

125
00:07:22,920 --> 00:07:28,450
>> તમે મોટા ભાગના પાછા યાદ તો તમારા
psets, તમે કાર્યક્રમ માટે અમુક પ્રકારના હતી

126
00:07:28,450 --> 00:07:30,370
કોઈ સી ફાઈલમાં લખાયેલ છે.

127
00:07:30,370 --> 00:07:32,550
અને પછી તમે બનાવવા લખો કરશે.

128
00:07:32,550 --> 00:07:35,970
તેથી શું કરી કરી છે?

129
00:07:35,970 --> 00:07:39,970
>> તમે કમ્પાઇલ બનાવવા લખી શકો છો તમારા
કાર્યક્રમ someone-- કારણ કે

130
00:07:39,970 --> 00:07:42,730
રહેલી વ્યકિત તમારા પૃષ્ઠ સેટ લખ્યું;
કદાચ David--

131
00:07:42,730 --> 00:07:44,190
એક મેક ફાઈલ બનાવી છે.

132
00:07:44,190 --> 00:07:51,320
અને તે ચલાવવા માટે ખબર બનાવવા કહે છે તમારા
કમ્પાઇલર, રણકાર કહેવાય છે, કે જે ઇચ્છા

133
00:07:51,320 --> 00:07:55,560
પછી વાંધો તમારા સ્રોત કોડ કમ્પાઇલ
zeros અને મુદ્દાઓ કે જે કોડ છે,

134
00:07:55,560 --> 00:07:57,720
તમારા કમ્પ્યુટર સમજે છે.

135
00:07:57,720 --> 00:08:01,610
પરંતુ પાછળથી થોડો, અમે જશે
કમ્પાઇલરોનો વિશે ઊંડાણપૂર્વક વધુ.

136
00:08:01,610 --> 00:08:05,640

137
00:08:05,640 --> 00:08:10,800
>> તેથી યાદ 0 pset, છે જ્યાં હા,
તમે એક પ્રશ્ન છે?

138
00:08:10,800 --> 00:08:11,620
>> AUDIENCE: [અશ્રાવ્ય]?

139
00:08:11,620 --> 00:08:12,490
>> 1 વક્તા: હા.

140
00:08:12,490 --> 00:08:14,960
હું ખરેખર તેઓ લાગે છે
ઓનલાઇન પ્રયત્ન કરીશું.

141
00:08:14,960 --> 00:08:15,120
અરે વાહ.

142
00:08:15,120 --> 00:08:16,572
>> પ્રેક્ષક: તે [અશ્રાવ્ય] જેવા છે?

143
00:08:16,572 --> 00:08:19,476

144
00:08:19,476 --> 00:08:20,830
>> 1 વક્તા: તે નથી.

145
00:08:20,830 --> 00:08:25,810
આ cs50.net/quizzes પર હોય છે.

146
00:08:25,810 --> 00:08:32,900
>> પ્રેક્ષક: સ્લેશે અંગેની ક્વિઝ, 2013 સ્લેશ
0 સ્લેશ, અને માત્ર મારફતે ક્લિક કરો

147
00:08:32,900 --> 00:08:35,956
અંગેની ક્વિઝ 2013 અને 0 ક્વિઝ,
વિભાગ સ્લાઇડ્સ સમીક્ષા કરો.

148
00:08:35,956 --> 00:08:40,380
>> 1 વક્તા: અરે વાહ, જેથી તમે ગાય્સ કરવા માંગો છો
તેને ખેંચી અને તેને જોવા તમારા

149
00:08:40,380 --> 00:08:42,740
પોતાના કોમ્પ્યુટર, કે ખૂબ સરસ.

150
00:08:42,740 --> 00:08:43,130
ફરીથી કહો.

151
00:08:43,130 --> 00:08:44,546
>> AUDIENCE: [અશ્રાવ્ય].

152
00:08:44,546 --> 00:08:48,780
>> 1 વક્તા: અરે વાહ, [અશ્રાવ્ય]
આ ડમી ચલ છે.

153
00:08:48,780 --> 00:08:49,644
હા, ઓહ?

154
00:08:49,644 --> 00:08:51,372
>> AUDIENCE: [અશ્રાવ્ય]?

155
00:08:51,372 --> 00:08:54,300
>> 1 વક્તા: ના, હડતાલ
પરીક્ષા પર નથી.

156
00:08:54,300 --> 00:08:55,950
માફ કરશો, હતી તેના પ્રશ્ન હતો
પરીક્ષા પર હડતાલ.

157
00:08:55,950 --> 00:08:59,530
અને તે નથી.

158
00:08:59,530 --> 00:09:05,780
તેથી 0 pset, તમે ગાય્સ તમામ હોવા જોઈએ
શરૂઆતથી ઉપયોગ કંઈક અમલ.

159
00:09:05,780 --> 00:09:13,100
અને અમે કેટલાક મૂળભૂત પ્રોગ્રામિંગ શીખી
શરૂઆતથી ઉપયોગ રચનાત્મક.

160
00:09:13,100 --> 00:09:15,590
>> તેથી આપણે કેટલાક પર એક નજર
આ મકાન બ્લોક્સ

161
00:09:15,590 --> 00:09:18,170
એક કાર્યક્રમ છે કે બનાવે છે.

162
00:09:18,170 --> 00:09:20,570
પ્રથમ બુલિયન અભિવ્યક્તિ છે.

163
00:09:20,570 --> 00:09:24,540
બુલિયન સમીકરણો થાય છે અને
છે કે 0 કે કંઈપણ

164
00:09:24,540 --> 00:09:25,700
બે શક્ય કિંમતો.

165
00:09:25,700 --> 00:09:30,320
આ કિસ્સામાં, સાચું કે ખોટું,
પર અથવા બંધ છે, અને કોઈ અથવા હા.

166
00:09:30,320 --> 00:09:35,390
ખૂબ જ સરળ, સરળ ઉદાહરણ,
બુલિયન વાપરે છે કે કાર્યક્રમ

167
00:09:35,390 --> 00:09:39,140
અહીં અભિવ્યક્તિ છે.

168
00:09:39,140 --> 00:09:43,220
>> તેથી માટે બુલિયન સમીકરણો માટે ક્રમમાં
ઉપયોગી હોઈ શકે છે, અમે બુલિયન ઓપરેટરો છે.

169
00:09:43,220 --> 00:09:48,920
આ વાપરી શકાય છે કે ઓપરેટરો છે
ચોક્કસ કિંમતો સરખામણી.

170
00:09:48,920 --> 00:09:52,820
તેથી અમે હોય છે અને નથી અથવા સમાન, ઓછી
કરતાં અથવા કરતાં વધુ માટે સમાન અથવા

171
00:09:52,820 --> 00:09:55,130
બરાબર છે, અને કરતા ઓછી
કરતાં અથવા તેથી વધુ.

172
00:09:55,130 --> 00:09:59,060
પરંતુ આ ઓપરેટરો ખૂબ જ ઉપયોગી નથી
અમે તેમને ભેગા કરી શકો છો જ્યાં સુધી

173
00:09:59,060 --> 00:10:00,320
શરતો.

174
00:10:00,320 --> 00:10:04,370
>> તેથી જો તમે ગાય્સ શરૂઆતથી યાદ શકે છે
અને તમારા પૃષ્ઠ થી અમે તે સુયોજિત કરે છે

175
00:10:04,370 --> 00:10:05,400
શરતો હતી.

176
00:10:05,400 --> 00:10:09,710
તેઓ માં ફોર્કનો જેમ, અનિવાર્યપણે, છે
તમારા કાર્યક્રમ તર્ક છે

177
00:10:09,710 --> 00:10:12,670
તેના પર આધાર રાખીને ચલાવે છે
એક શરત મળ્યા છે.

178
00:10:12,670 --> 00:10:18,150
અમે હતી કે શરતો તેથી એક
આ કોર્સમાં અનેક વખત વપરાય છે

179
00:10:18,150 --> 00:10:21,470
બીજું, જો, અને બીજું શરતો, જો.

180
00:10:21,470 --> 00:10:24,060
>> અહીં કેવી રીતે એક ઉદાહરણ છે
તમે તે ઉપયોગ કરી શકે છે.

181
00:10:24,060 --> 00:10:28,430
કોઈને વચ્ચે તફાવત ખબર નથી
માત્ર નિવેદનો બધા જો મદદથી

182
00:10:28,430 --> 00:10:32,530
જો, બીજું છંદો નીચે જે રીતે,
જો, અને બીજું સંયુક્ત?

183
00:10:32,530 --> 00:10:33,013
હા?

184
00:10:33,013 --> 00:10:34,263
>> AUDIENCE: [અશ્રાવ્ય].

185
00:10:34,263 --> 00:10:40,741

186
00:10:40,741 --> 00:10:42,160
>> 1 વક્તા: ચોક્કસ.

187
00:10:42,160 --> 00:10:50,210
તેથી હું હોય તો જો આ નીચે બધી રીતે
આ રીતે, પણ આ સ્થિતિ વળતર જો

188
00:10:50,210 --> 00:10:52,800
સાચું છે, તે હજુ પણ ચાલુ રહેશે
આગામી બે પરીક્ષણ.

189
00:10:52,800 --> 00:11:00,120
, જ્યારે એક બીજા-તો એક બીજા સાથે
નિવેદન, એક સાચું આપે છે,

190
00:11:00,120 --> 00:11:02,640
અન્ય પરીક્ષણ નથી.

191
00:11:02,640 --> 00:11:05,955
તે વિશે કોઈ પ્રશ્ન?

192
00:11:05,955 --> 00:11:06,890
કૂલ.

193
00:11:06,890 --> 00:11:12,240
>> તેથી જો તમે એક બીજા એક જો-બીજું ઉપયોગ
તમે જાણો છો જો નિવેદન કે તે માત્ર આ કરી શકો છો

194
00:11:12,240 --> 00:11:14,470
આ કિસ્સાઓમાં એક છે.

195
00:11:14,470 --> 00:11:21,550
એક્સ કરતાં ઓછી 0 છે તેથી જો અમે તે છે, ખબર
ચોક્કસપણે નથી ચાલી રહ્યું

196
00:11:21,550 --> 00:11:22,890
0 કરતાં મોટો.

197
00:11:22,890 --> 00:11:26,940

198
00:11:26,940 --> 00:11:31,480
>> આગળ, અન્ય મકાન બ્લોક
અમે શીખ્યા કે આંટીઓ છે.

199
00:11:31,480 --> 00:11:33,310
અમે આંટીઓ ત્રણ પ્રકારના હોય છે.

200
00:11:33,310 --> 00:11:35,830
આંટીઓ માટે, આંટીઓ જ્યારે,
અને આંટીઓ જ્યારે નથી.

201
00:11:35,830 --> 00:11:38,730
અને સામાન્ય રીતે, તમે જ્યારે માટે નીચે બેસી
કંઈક લખી, તમે નક્કી કરવા માટે હોય છે

202
00:11:38,730 --> 00:11:40,060
તમે ઉપયોગ કરવા માંગો છો ત્રણ છે.

203
00:11:40,060 --> 00:11:41,900
તેથી અમે કેવી રીતે એક કે જે નક્કી કરે છે?

204
00:11:41,900 --> 00:11:44,920

205
00:11:44,920 --> 00:11:48,790
>> આપણે જાણીએ છીએ કે જો અમે સામાન્ય રીતે લૂપ માટે ઉપયોગ
કેટલી વખત અમે ભારપૂર્વક કહેવું કરવા માંગો છો

206
00:11:48,790 --> 00:11:53,650
કંઈક મારફતે અથવા કેટલી વખત
અમે એક કાર્ય કરવા માંગો છો.

207
00:11:53,650 --> 00:11:58,830
અમે કેટલાક જરૂર હોય તો અમે આંટીઓ જ્યારે ઉપયોગ
સ્થિતિ ચાલુ રાખવામાં વાત સાચી છે.

208
00:11:58,830 --> 00:12:03,730
અને અમે ખૂબ સમાન છે, જ્યારે શું ઉપયોગ
જ્યારે, પરંતુ અમે અમારી કોડ પર ચલાવવા માંગો છો

209
00:12:03,730 --> 00:12:04,880
ઓછી એક સમય.

210
00:12:04,880 --> 00:12:09,410
>> ડુ માં ગમે તેથી, જ્યારે થશે
હંમેશા ઓછામાં ઓછી એક સમય ચાલે છે.

211
00:12:09,410 --> 00:12:13,120
, જ્યારે જ્યારે સાથે, તે
બધા જો ચલાવી શકો છો

212
00:12:13,120 --> 00:12:15,490
શરત સંતુષ્ટ નથી.

213
00:12:15,490 --> 00:12:16,740
તે સાથે કોઈપણ પ્રશ્ન છે?

214
00:12:16,740 --> 00:12:20,480

215
00:12:20,480 --> 00:12:22,860
>> લૂપ માટે તેથી માળખું.

216
00:12:22,860 --> 00:12:23,620
તમે ગાય્સ આ જોવા મળે છે.

217
00:12:23,620 --> 00:12:25,320
તમે પ્રારંભ.

218
00:12:25,320 --> 00:12:26,600
તમે શરત અમુક પ્રકારના હોય છે.

219
00:12:26,600 --> 00:12:32,340
તેથી, ઉદાહરણ તરીકે, અમે પ્રારંભ કરી શકે છે
માટે હું 0 સમકક્ષ હોય છે.

220
00:12:32,340 --> 00:12:34,040
હું 10 કરતાં ઓછી છે.

221
00:12:34,040 --> 00:12:35,442
અને હું ++.

222
00:12:35,442 --> 00:12:39,010
અમે કર્યું છે કે ખૂબ જ સરળ છે.

223
00:12:39,010 --> 00:12:42,210
>> જ્યારે લૂપ માટે, એ જ રીતે, તમારી પાસે
આરંભ અમુક પ્રકારના હોય છે,

224
00:12:42,210 --> 00:12:44,980
શરત અમુક પ્રકારના છે, અને
સુધારા અમુક પ્રકારના.

225
00:12:44,980 --> 00:12:51,990
તેથી અમે પણ લૂપ માટે અમારા અમલ કરી શકે છે
જ્યારે લૂપ તરીકે આ મદદથી.

226
00:12:51,990 --> 00:12:56,000
અને એ જ રીતે ડુ જ્યારે લૂપ સાથે,
અમે કેટલાક આરંભ હોય શકે છે,

227
00:12:56,000 --> 00:12:58,640
, કંઈક ચલાવો તેને સુધારવા, અને
પછી સ્થિતિ તપાસો.

228
00:12:58,640 --> 00:13:03,500

229
00:13:03,500 --> 00:13:05,140
>> તેથી હવે કાર્ય કરે છે.

230
00:13:05,140 --> 00:13:06,460
અમે એક સાથે બધું મૂકી.

231
00:13:06,460 --> 00:13:10,140
અમે કેટલાક લખવા માંગો છો શકે છે
કાર્ય પ્રકારની.

232
00:13:10,140 --> 00:13:12,790
સામાન્ય કાર્ય કે તમે કદાચ
પહેલેથી જ જોવા મળે છે મુખ્ય છે.

233
00:13:12,790 --> 00:13:13,770
મુખ્ય કાર્ય છે.

234
00:13:13,770 --> 00:13:16,160
તે વળતર પ્રકાર, પૂર્ણાંક છે.

235
00:13:16,160 --> 00:13:18,470
તે મુખ્ય કાર્ય નામ, છે.

236
00:13:18,470 --> 00:13:20,810
અને તે દલીલો, argc અને argv છે.

237
00:13:20,810 --> 00:13:24,040
તેથી મુખ્ય માત્ર એક કાર્ય છે.

238
00:13:24,040 --> 00:13:27,230
>> તમે ઉપયોગ હોઇ શકે છે અન્ય કાર્યો,
કે, printf printf એક કાર્ય છે

239
00:13:27,230 --> 00:13:29,330
GetInt, toupper.

240
00:13:29,330 --> 00:13:32,010
પરંતુ આ હોવાનું થાય
દ્વારા અમારા માટે અમલમાં

241
00:13:32,010 --> 00:13:33,270
પુસ્તકાલય અમુક પ્રકારના.

242
00:13:33,270 --> 00:13:37,400
તમે ગાય્સ સહિત યાદ તો
આ CS50.h પુસ્તકાલય અથવા

243
00:13:37,400 --> 00:13:38,510
ધોરણ I / O લાઇબ્રેરી.

244
00:13:38,510 --> 00:13:39,200
હા, પ્રશ્ન?

245
00:13:39,200 --> 00:13:41,610
>> પ્રેક્ષક: સી માત્ર સહજ મુખ્ય છે?

246
00:13:41,610 --> 00:13:44,740
તે માત્ર પ્રકારની [અશ્રાવ્ય] છે?

247
00:13:44,740 --> 00:13:47,370
>> 1 વક્તા: આ પ્રશ્ન છે
મુખ્ય જો સી અંતર્ગત છે.

248
00:13:47,370 --> 00:13:51,460
અને હા, બધા કાર્યો
એક મુખ્ય કાર્ય છે.

249
00:13:51,460 --> 00:13:55,290
તે પ્રકારની કમ્પ્યુટર માટે જરૂરી છે
શરૂ કરવા માટે જ્યાં ખબર

250
00:13:55,290 --> 00:13:55,993
આ કોડ ચાલી રહ્યું છે.

251
00:13:55,993 --> 00:13:58,108
>> પ્રેક્ષક: તેથી તમે નથી [અશ્રાવ્ય]?

252
00:13:58,108 --> 00:13:59,480
>> 1 વક્તા: ના

253
00:13:59,480 --> 00:14:00,760
કોઈપણ અન્ય પ્રશ્નો છે?

254
00:14:00,760 --> 00:14:03,430

255
00:14:03,430 --> 00:14:04,770
કૂલ.

256
00:14:04,770 --> 00:14:08,050
તમે એક કાર્ય ઉપયોગ કરી શકો છો તેથી જેમ
કે તમારા માટે લખેલું, તમે પણ કરી શકો છો

257
00:14:08,050 --> 00:14:10,380
તમારા પોતાના કાર્ય લખો.

258
00:14:10,380 --> 00:14:17,050
આ સૂચવે છે કે કોઈ વ્યક્તિ કદાચ એક કાર્ય છે
વોલ્યુમ ગણતરી માટે લખ્યું છે

259
00:14:17,050 --> 00:14:18,395
ઉદાહરણ તરીકે એક સ, ના.

260
00:14:18,395 --> 00:14:21,300

261
00:14:21,300 --> 00:14:29,500
વળતર પ્રકાર આ કિસ્સામાં, અહીં છે
પૂર્ણાંક અમારા કાર્ય નામ સ અને અમારી

262
00:14:29,500 --> 00:14:31,360
પરિમાણો યાદી.

263
00:14:31,360 --> 00:14:34,550
>> અને તમે માહિતી લખી છે કે નોંધ
તમે કરવા માંગો છો પરિમાણ પ્રકારના

264
00:14:34,550 --> 00:14:38,660
વાપરો અથવા કાર્ય નથી બીજું
પ્રકારની શું ખબર

265
00:14:38,660 --> 00:14:41,650
પરિમાણ હું સ્વીકારી જોઈએ.

266
00:14:41,650 --> 00:14:48,110
તેથી, આ કિસ્સામાં, અમે માંગો છો
અમારા ઇનપુટ તરીકે પૂર્ણાંક.

267
00:14:48,110 --> 00:14:50,390
તેથી શા માટે અમે વિધેયો ઉપયોગ કરવા માંગો છો શકે છે?

268
00:14:50,390 --> 00:14:52,800
>> તમામ પ્રથમ, સંસ્થા માટે મહાન.

269
00:14:52,800 --> 00:14:56,350
તેઓ તમારી કોડ વિભાજન મદદ
વધુ હિસ્સામાં આયોજન અને બનાવવા

270
00:14:56,350 --> 00:14:57,960
તેને સરળ વાંચવા માટે.

271
00:14:57,960 --> 00:14:59,760
સરળતા.

272
00:14:59,760 --> 00:15:01,740
આ ડિઝાઇન માટે સારી છે.

273
00:15:01,740 --> 00:15:04,570
તમે કોડ એક ભાગ વાંચી રહ્યા છો, ત્યારે
અને મુખ્ય કાર્ય, ખરેખર છે

274
00:15:04,570 --> 00:15:07,750
ખરેખર લાંબા, તે મુશ્કેલ બની શકે છે
શું થઈ રહ્યું છે તે વિશે કારણ.

275
00:15:07,750 --> 00:15:11,710
તેથી જો તમે કાર્ય માં તોડી છે,
તે વાંચવા માટે સરળ હોઈ શકે છે.

276
00:15:11,710 --> 00:15:12,750
અને ફરી ઉપયોગ-ક્ષમતા.

277
00:15:12,750 --> 00:15:16,940
તમે કોડ એક ભાગ હોય છે કે
કહેવાય કે ઘણી વખત ચલાવો,

278
00:15:16,940 --> 00:15:20,690
તેના બદલે તે કોડ 10 વખત પુનર્લેખન ના
તમારી મુખ્ય કાર્ય, તમે કદાચ

279
00:15:20,690 --> 00:15:21,440
તે ફરી ઉપયોગ કરવા માંગો છો.

280
00:15:21,440 --> 00:15:25,740
અને પછી દર વખતે તમે કે ઉપયોગ કરવાની જરૂર
કોડ ઓફ ભાગ છે, કાર્ય ફોન કરો.

281
00:15:25,740 --> 00:15:30,550

282
00:15:30,550 --> 00:15:35,380
>> તેથી હવે અમે પાછા ખંજવાળી યાદ છે,
અમે પણ થોડા ખ્યાલો વિશે વાત કરી

283
00:15:35,380 --> 00:15:37,680
જે એક threading છે.

284
00:15:37,680 --> 00:15:41,120
થ્રેડ ઘણી ખ્યાલ છે
કોડ ક્રમ

285
00:15:41,120 --> 00:15:43,040
તે જ સમયે ચલાવવા.

286
00:15:43,040 --> 00:15:47,490
તેથી ડેવિડ હતી જ્યાં એક દિવસ પાછા લાગે
તમે ગાય્સ સંખ્યા બોલ ગણતરી

287
00:15:47,490 --> 00:15:48,440
રૂમમાં લોકો.

288
00:15:48,440 --> 00:15:50,550
>> આવશ્યકપણે, શું થવાનું હતું
તમે ગાય્સ તમામ છે હતા

289
00:15:50,550 --> 00:15:52,370
અલગ થ્રેડો ચાલી રહ્યું છે.

290
00:15:52,370 --> 00:15:55,540
અને તે થ્રેડો સાથે આવી હતી
જવાબ અમુક પ્રકારના વિચાર.

291
00:15:55,540 --> 00:15:58,890
એ જ રીતે, સ્ક્રેચ માં, તમે જ્યારે છે
બહુવિધ sprites, તમે કદાચ

292
00:15:58,890 --> 00:16:01,070
એક બિલાડી અને એક કૂતરો છે.

293
00:16:01,070 --> 00:16:08,770
અને તેઓ એક સાથે હશે
પોતાના સ્ક્રિપ્ટો ચાલી રહ્યું છે.

294
00:16:08,770 --> 00:16:10,020
કે threading એક ઉદાહરણ છે.

295
00:16:10,020 --> 00:16:12,860

296
00:16:12,860 --> 00:16:18,000
>> અને અન્ય ખ્યાલ હતો
શરૂઆતથી માં રજૂ ઘટનાઓ હતી.

297
00:16:18,000 --> 00:16:22,550
અને ઘટનાઓ જ્યારે ઘણા ભાગો છે
તમારો કોડ એકબીજા સાથે વાતચીત.

298
00:16:22,550 --> 00:16:26,840
તમે ઉપયોગ કરવામાં આવે ત્યારે સ્ક્રેચ, આ હતો
પ્રસારણ નિયંત્રણ અને જ્યારે હું

299
00:16:26,840 --> 00:16:29,500
બ્લોક્સ પ્રાપ્ત કરો.

300
00:16:29,500 --> 00:16:35,170
>> અને પણ, સમસ્યા સેટ 4, અમે જોયું
તેમજ ઘટનાઓ થોડો.

301
00:16:35,170 --> 00:16:38,250
તમે ગાય્સ ઉપયોગ છે શકે
આ Gevent પુસ્તકાલય.

302
00:16:38,250 --> 00:16:42,450
અને એક કાર્ય હતી waitForClick
જેમાં તમે રાહ જોઈ હતી

303
00:16:42,450 --> 00:16:44,300
વપરાશકર્તા ક્લિક કરો માટે.

304
00:16:44,300 --> 00:16:47,870
અને તમારા ક્લિક, આ કિસ્સામાં, હશે
ક્લિક માટે ઘટના અને રાહ જુઓ તમારા છે

305
00:16:47,870 --> 00:16:49,120
ઘટના સંભાળનાર.

306
00:16:49,120 --> 00:16:53,690

307
00:16:53,690 --> 00:16:58,630
>> અને પણ, તમારા psets સમગ્ર ચાલી
અને તમારા psets પર કામ, તમે

308
00:16:58,630 --> 00:17:01,920
સાથે સંપર્કમાં આવે છે શકે છે
આ આદેશો કેટલાક.

309
00:17:01,920 --> 00:17:05,579
આ તમને ટાઇપ છે તમારા
ટર્મિનલ વિન્ડો અથવા જે વિન્ડો

310
00:17:05,579 --> 00:17:12,119
કે, તમારા જી ફેરફાર કરો પર બતાવે છે
અનિવાર્યપણે, તમારા કમ્પ્યુટર શોધખોળ કરો.

311
00:17:12,119 --> 00:17:19,440
>> તેથી, ઉદાહરણ તરીકે, LS યાદી આપે છે આ
એક ડિરેક્ટરીના સમાવિષ્ટો.

312
00:17:19,440 --> 00:17:22,510
ડિરેક્ટરી નવું ફોલ્ડર બનાવે બનાવો.

313
00:17:22,510 --> 00:17:24,819
સીડી, ફેરફાર ડિરેક્ટરી.

314
00:17:24,819 --> 00:17:28,400
આરએમ, દૂર કરવા, ફાઈલ કાઢી નાંખે છે
અથવા અમુક ડિરેક્ટરી.

315
00:17:28,400 --> 00:17:31,050
અને પછી ડિરેક્ટરી દૂર
ડિરેક્ટરી દૂર કરે છે.

316
00:17:31,050 --> 00:17:32,300
>> AUDIENCE: [અશ્રાવ્ય]?

317
00:17:32,300 --> 00:17:36,978

318
00:17:36,978 --> 00:17:38,370
>> 1 વક્તા: અરે વાહ, તેની ખાતરી કરો.

319
00:17:38,370 --> 00:17:42,530

320
00:17:42,530 --> 00:17:46,040
માફ કરશો, આ પ્રશ્ન હતો જો તમે
આ મૂકી સૂચવે કરશે

321
00:17:46,040 --> 00:17:48,840
આ ખાણિયાઓને છેતરે છે શીટ પર.

322
00:17:48,840 --> 00:17:49,440
તે મદદ કરી શકે છે.

323
00:17:49,440 --> 00:17:51,490
તમે રૂમ હોય, તો તમે તેના પર મૂકી શકો છો.

324
00:17:51,490 --> 00:17:56,170
તે પણ પર્યાપ્ત માત્ર સામાન્ય રીતે સારી છે
તમે તેનો ઉપયોગ કારણ કે જ્યારે યાદ

325
00:17:56,170 --> 00:17:59,060
તમે કરવા માંગો છો શકે માત્ર
તે યાદ છે.

326
00:17:59,060 --> 00:18:02,750
તે તમારા જીવન ખૂબ સરળ બનાવવા પડશે.

327
00:18:02,750 --> 00:18:04,000
હું તમારા પ્રશ્નનો જવાબ છે?

328
00:18:04,000 --> 00:18:10,528

329
00:18:10,528 --> 00:18:14,290
>> તેથી હવે, અમે થોડો વાત કરી
પુસ્તકાલયો વિશે થોડા સમય.

330
00:18:14,290 --> 00:18:18,570
પરંતુ બે મુખ્ય મુદ્દાઓ અમે કરી છે કે
અત્યાર સુધી દરમિયાન છે ઉપયોગ

331
00:18:18,570 --> 00:18:20,860
પ્રમાણભૂત I / O અને CS50.

332
00:18:20,860 --> 00:18:25,410
વસ્તુઓ કેવા પ્રકારની સમાવેશ થાય છે
પ્રમાણભૂત I / O લાઇબ્રેરી છે?

333
00:18:25,410 --> 00:18:28,410
>> અરે વાહ, અત્યાર સુધી અમે printf ઉપયોગ કર્યા.

334
00:18:28,410 --> 00:18:31,150
CS50 માં, અમે GetInt ઉપયોગ કર્યો છે
અને GetString.

335
00:18:31,150 --> 00:18:37,200
અને માહિતી પ્રકાર શબ્દમાળા પણ થાય
આ CS50 પુસ્તકાલય જાહેર છે.

336
00:18:37,200 --> 00:18:40,250
અમે વિશે ઊંડાણપૂર્વક થોડી વધુ વાત કરીશું
કેવી રીતે પુસ્તકાલયો કામ કરે છે અને કેવી રીતે તેઓ

337
00:18:40,250 --> 00:18:41,870
તમારો કોડ બાકીના સાથે ક્રિયાપ્રતિક્રિયા કરે છે.

338
00:18:41,870 --> 00:18:46,220
પરંતુ તે બે મુખ્ય મુદ્દાઓ છે કે અમે
અત્યાર સુધી માં સાથે સંપર્કમાં આવે છે

339
00:18:46,220 --> 00:18:48,430
કોર્સ.

340
00:18:48,430 --> 00:18:50,050
>> પ્રકાર.

341
00:18:50,050 --> 00:18:58,120
આ કેટલી યાદ સારા છે
દરેક પ્રકાર કેવી રીતે અથવા રજૂ થાય છે

342
00:18:58,120 --> 00:19:02,840
ઘણા બાઇટ્સ પ્રકાર દરેક requires--

343
00:19:02,840 --> 00:19:04,990
પૂર્ણાંક, 4 બાઇટ્સ; ચાર, 1 બાઈટ.

344
00:19:04,990 --> 00:19:06,550
રહેલું 4 બાઇટ્સ છે.

345
00:19:06,550 --> 00:19:07,782
ડબલ શું છે?

346
00:19:07,782 --> 00:19:09,032
>> AUDIENCE: [અશ્રાવ્ય].

347
00:19:09,032 --> 00:19:11,398

348
00:19:11,398 --> 00:19:16,240
>> 1 વક્તા: અરે વાહ, તેથી ફ્લોટ
પરંતુ માપ બમણો છે.

349
00:19:16,240 --> 00:19:17,150
શું લાંબા વિશે શું?

350
00:19:17,150 --> 00:19:18,400
>> AUDIENCE: [અશ્રાવ્ય].

351
00:19:18,400 --> 00:19:21,614

352
00:19:21,614 --> 00:19:24,680
>> 1 વક્તા: ઠીક.

353
00:19:24,680 --> 00:19:25,410
લાંબા શું છે?

354
00:19:25,410 --> 00:19:26,660
>> AUDIENCE: [અશ્રાવ્ય].

355
00:19:26,660 --> 00:19:29,400

356
00:19:29,400 --> 00:19:31,450
>> 1 વક્તા: અરે વાહ, પૂર્ણાંક બમણો છે.

357
00:19:31,450 --> 00:19:34,240

358
00:19:34,240 --> 00:19:34,705
હા.

359
00:19:34,705 --> 00:19:36,100
>> AUDIENCE: [અશ્રાવ્ય].

360
00:19:36,100 --> 00:19:38,030
>> 1 વક્તા: લાંબા [અશ્રાવ્ય].

361
00:19:38,030 --> 00:19:41,860
અને પછી લાંબા લાંબા કે ડબલ છે.

362
00:19:41,860 --> 00:19:42,814
>> પ્રેક્ષક: ના, કોઈ.

363
00:19:42,814 --> 00:19:47,107
એક લાંબા માત્ર પૂર્ણાંક છે.

364
00:19:47,107 --> 00:19:50,910
તે આર્કીટેક્ચર પર આધાર રાખે છે
પહેલાં [અશ્રાવ્ય]

365
00:19:50,910 --> 00:19:52,922
અને પૂર્ણાંક જ માપ છે.

366
00:19:52,922 --> 00:19:54,172
[અશ્રાવ્ય].

367
00:19:54,172 --> 00:19:58,841

368
00:19:58,841 --> 00:20:00,920
>> 1 વક્તા: તેથી લાંબા અને
પૂર્ણાંક જ છે.

369
00:20:00,920 --> 00:20:02,943
અને પછી લાંબા લાંબા
ડબલ પૂર્ણાંક છે.

370
00:20:02,943 --> 00:20:03,910
કૂલ.

371
00:20:03,910 --> 00:20:05,550
અને પછી, છેલ્લા પ્રકાર શું છે?

372
00:20:05,550 --> 00:20:06,510
>> પ્રેક્ષક: પોઇન્ટર.

373
00:20:06,510 --> 00:20:10,350
>> 1 વક્તા: અરે વાહ, તેથી અમે શીખ્યા
પોઇન્ટર વિશે થોડુંક.

374
00:20:10,350 --> 00:20:14,015
અને અનુલક્ષીને નિર્દેશક શું છે
તે to-- પોઇન્ટ ચાર રચે સ્ટાર હોઈ શકે

375
00:20:14,015 --> 00:20:15,880
અથવા પૂર્ણાંક star--

376
00:20:15,880 --> 00:20:20,530
તે હંમેશા એક નિર્દેશક માટે 4 બાઇટ્સ છે.

377
00:20:20,530 --> 00:20:21,633
તે વિશે પ્રશ્નો?

378
00:20:21,633 --> 00:20:22,116
હા?

379
00:20:22,116 --> 00:20:24,531
>> AUDIENCE: [અશ્રાવ્ય]?

380
00:20:24,531 --> 00:20:29,530
>> 1 વક્તા: તેથી લાંબા અને પૂર્ણાંક છે
આ CS50 ઉપકરણ એ જ.

381
00:20:29,530 --> 00:20:32,302
>> પ્રેક્ષક: આ સાધન સંપૂર્ણપણે છે
વિનિમયક્ષમ.

382
00:20:32,302 --> 00:20:33,510
>> 1 વક્તા: યાહ.

383
00:20:33,510 --> 00:20:36,610
તેથી પછી લાંબા લાંબા ડબલ પૂર્ણાંક છે.

384
00:20:36,610 --> 00:20:39,250
>> પ્રેક્ષક: આ 32 બીટ છે?

385
00:20:39,250 --> 00:20:40,620
>> 1 વક્તા: 32 બીટ, હા.

386
00:20:40,620 --> 00:20:43,572
>> પ્રેક્ષક: તેથી [અશ્રાવ્ય]?

387
00:20:43,572 --> 00:20:46,790
>> 1 વક્તા: હા, તે નહી હોય તો
બાહ્ય રીતે, તમે કહી

388
00:20:46,790 --> 00:20:47,870
32 બીટ ધારે જોઈએ.

389
00:20:47,870 --> 00:20:50,040
>> પ્રેક્ષક: તે કંઈક કહે છે
એક ધારી રહ્યા છીએ જેમ

390
00:20:50,040 --> 00:20:51,498
સાધન જેમ સ્થાપત્ય.

391
00:20:51,498 --> 00:20:58,800

392
00:20:58,800 --> 00:21:01,710
64 બીટ, માત્ર વસ્તુઓ માટે કે
ફેરફાર લોન્ગ્સ અને પોઇન્ટર છે.

393
00:21:01,710 --> 00:21:05,614
તેઓ બંને [અશ્રાવ્ય].

394
00:21:05,614 --> 00:21:06,590
>> 1 વક્તા: હા?

395
00:21:06,590 --> 00:21:07,566
>> પ્રેક્ષક: પ્રશ્ન.

396
00:21:07,566 --> 00:21:10,982
આ પ્રથા અંગેની ક્વિઝ એક પર તેથી,
તે સહી થયેલ નહિં પૂર્ણાંક વિશે પૂછે છે.

397
00:21:10,982 --> 00:21:15,374
તેથી કેવી રીતે નક્કી કરી શકે છે
પૂર્ણાંક [અશ્રાવ્ય] છે?

398
00:21:15,374 --> 00:21:18,140
>> 1 વક્તા: એક સહી થયેલ નહિં
પણ 4 બાઇટ્સ છે.

399
00:21:18,140 --> 00:21:21,172
પરંતુ સહી વિશે અલગ છે
પૂર્ણાંક અને સહી થયેલ નહિં પૂર્ણાંક?

400
00:21:21,172 --> 00:21:22,422
>> AUDIENCE: [અશ્રાવ્ય].

401
00:21:22,422 --> 00:21:24,868

402
00:21:24,868 --> 00:21:25,630
>> 1 વક્તા: અધિકાર.

403
00:21:25,630 --> 00:21:27,570
એક નકારાત્મક કિંમતો પ્રતિનિધિત્વ કરી શકે છે.

404
00:21:27,570 --> 00:21:28,580
પરંતુ કેવી રીતે તે કરે છે?

405
00:21:28,580 --> 00:21:30,536
>> AUDIENCE: [અશ્રાવ્ય].

406
00:21:30,536 --> 00:21:36,370
>> 1 વક્તા: અરે વાહ, તે 1 બચાવે
બીટ સાઇન પ્રતિનિધિત્વ.

407
00:21:36,370 --> 00:21:40,910

408
00:21:40,910 --> 00:21:45,040
સહી આ એક બીટ છે
સાઇન રજૂ કરે છે.

409
00:21:45,040 --> 00:21:48,886
અને સહી થયેલ નહિં માત્ર બધા ધન છે.

410
00:21:48,886 --> 00:21:50,365
>> પ્રેક્ષક: બરાબર.

411
00:21:50,365 --> 00:21:54,230
તેથી તમે ડબલ છે કહે છે કે
ફ્લોટ ની બે વાર માપ?

412
00:21:54,230 --> 00:21:58,202
>> 1 વક્તા: ડબલ બે વાર છે
ફ્લોટ માપ, હા.

413
00:21:58,202 --> 00:22:01,639
>> પ્રેક્ષક: નિર્દેશક કરે છે કેવી રીતે
એક લાંબા સમય સુધી લાંબા [અશ્રાવ્ય]?

414
00:22:01,639 --> 00:22:06,058

415
00:22:06,058 --> 00:22:10,870
>> 1 વક્તા: કરે છે કે કેવી રીતે તેથી પ્રશ્ન છે
લાંબા લાંબા માટે નિર્દેશક

416
00:22:10,870 --> 00:22:13,800
કેવી રીતે માત્ર ચાર બાઇટ્સ જ્યારે છે
તેના 8 બાઇટ્સ લાંબા લાંબા.

417
00:22:13,800 --> 00:22:17,310
તેથી નિર્દેશક શું છે યાદ રાખો કે,
અનિવાર્યપણે, આ ખૂબ જ આધાર કિંમત પર.

418
00:22:17,310 --> 00:22:19,046
>> AUDIENCE: [અશ્રાવ્ય].

419
00:22:19,046 --> 00:22:22,670
>> 1 વક્તા: અરે વાહ, જેથી નિર્દેશક
માત્ર એક મેમરી સ્થાન છે.

420
00:22:22,670 --> 00:22:28,040
તેથી તે કેટલી જગ્યા તો કોઈ વાંધો નથી
કે નિર્દેશક પોઇન્ટ છે.

421
00:22:28,040 --> 00:22:32,060
તે માત્ર ત્યારે જ ટ્રેક રાખવા માટે 4 બાઇટ્સ જરૂર
કે મેમરી સ્થાન.

422
00:22:32,060 --> 00:22:34,760

423
00:22:34,760 --> 00:22:36,010
કોઈપણ અન્ય પ્રશ્નો છે?

424
00:22:36,010 --> 00:22:39,800

425
00:22:39,800 --> 00:22:41,050
કૂલ.

426
00:22:41,050 --> 00:22:42,920

427
00:22:42,920 --> 00:22:47,460
>> તેથી છેલ્લા વસ્તુ હું
પ્રમાણભૂત આઉટપુટ છે.

428
00:22:47,460 --> 00:22:51,020
તમે વારંવાર તેમને ઉપયોગ કરવો જોઈએ
તમે યાદ કરી શકો છો તે પર્યાપ્ત.

429
00:22:51,020 --> 00:22:54,800
અમે ઉપયોગ પરંતુ જ્યારે આ છે
printf, ઉદાહરણ તરીકે.

430
00:22:54,800 --> 00:22:59,260
અને અમે આ જગ્યામાં છે કે
બંધારણમાં કોડ કહેવાતા હતા.

431
00:22:59,260 --> 00:23:03,910
>> તેથી પૂર્ણાંક માટે ટકા સી ચાર, ટકા હું,
અને અમે પણ ટકા ડી વાપરી શકો છો.

432
00:23:03,910 --> 00:23:05,130
તે જ વાત છે.

433
00:23:05,130 --> 00:23:08,200
પરંતુ, સામાન્ય રીતે, માં CS50 અમે
ટકા હું ઉપયોગ કરવાનો પ્રયાસ કરો.

434
00:23:08,200 --> 00:23:09,860
ફ્લોટ માટે ટકા એફ.

435
00:23:09,860 --> 00:23:15,620
લાંબા લાંબા સમય માટે ટકા એલડી અને
શબ્દમાળા માટે ટકા છે.

436
00:23:15,620 --> 00:23:18,550
>> એ જ રીતે, અમે થોડા ઉપયોગ કરી રહ્યો છું
આ એસ્કેપ ક્રમાંકો.

437
00:23:18,550 --> 00:23:22,431
ઉદાહરણ તરીકે, બેકસ્લેશ માટે એ નવી લાઇન માટે.

438
00:23:22,431 --> 00:23:26,910
આ તમે ફોર્મેટિંગ કરી રહ્યા હો ત્યારે માટે માત્ર છે
પ્રિન્ટ એફ માટે તમારા કોડ.

439
00:23:26,910 --> 00:23:27,260
હા?

440
00:23:27,260 --> 00:23:28,906
>> પ્રેક્ષક: ટકા ડી શું છે?

441
00:23:28,906 --> 00:23:31,850
>> 1 વક્તા: તેથી પ્રશ્ન
ટકા ડી માટે શું છે?

442
00:23:31,850 --> 00:23:33,270
ટકા ડી ints માટે છે.

443
00:23:33,270 --> 00:23:37,392
ટકા ડી અને ટકા હું જ છે.

444
00:23:37,392 --> 00:23:41,130
>> પ્રેક્ષક: વચ્ચે તફાવત શું
બેકસ્લેશ n એ અને બેકસ્લેશ આર?

445
00:23:41,130 --> 00:23:45,300
>> 1 વક્તા: તેથી પ્રશ્ન એ શું છે
તીવ્ર નકારાત્મક પ્રતિક્રિયા એ અને વચ્ચે તફાવત

446
00:23:45,300 --> 00:23:48,615
તીવ્ર નકારાત્મક પ્રતિક્રિયા આર?

447
00:23:48,615 --> 00:23:50,906
હું બેકસ્લેશ આર લાગે ઠીક

448
00:23:50,906 --> 00:23:54,340
>> પ્રેક્ષક: તેથી બેકસ્લેશ આર ફક્ત સૂચિત
લીટી શરૂઆત આપે છે

449
00:23:54,340 --> 00:23:56,670
ખરેખર એક નવી લાઇન રહ્યા વગર.

450
00:23:56,670 --> 00:24:01,000
તેથી જો તમે એક બેકસ્લેશ આર છાપો અને તમે જો
લીટી શરૂઆત પર પાછા જાઓ

451
00:24:01,000 --> 00:24:04,005
પછી તમે પર ફરીથી લખી, વધુ સામગ્રી છાપી
પર પહેલાથી જ છે કે સામગ્રી

452
00:24:04,005 --> 00:24:04,390
[અશ્રાવ્ય].

453
00:24:04,390 --> 00:24:06,725
જ્યારે, એ ખરેખર નવી જાય
લાઇન અને [અશ્રાવ્ય] જાય છે.

454
00:24:06,725 --> 00:24:10,525

455
00:24:10,525 --> 00:24:13,915
>> 1 વક્તા: ઠીક છે, કોઈ અન્ય પ્રશ્નો છે?

456
00:24:13,915 --> 00:24:15,430
અધિકાર છે.

457
00:24:15,430 --> 00:24:18,617
હું તેને હાથ કરવા જઇ રહ્યો છું
ચાલુ રહેશે જે ડેન.

458
00:24:18,617 --> 00:24:25,078
>> [વધાવી]

459
00:24:25,078 --> 00:25:08,814

460
00:25:08,814 --> 00:25:09,720
>> DAN: બધા righty.

461
00:25:09,720 --> 00:25:18,590
તેથી હું અન્ય વિશાળ વિશે વાત કરવામાં આવશે
છે કે વર્ગ વિચારો શ્રેણી

462
00:25:18,590 --> 00:25:23,220
લગભગ સપ્તાહ બે પ્રતિનિધિ અને
સપ્તાહ ત્રણ શરૂઆત બંધ શરૂ

463
00:25:23,220 --> 00:25:28,690
માત્ર એક માર્ગ છે, જે કાસ્ટિંગ સાથે
ચોક્કસ પ્રકાર ની કિંમત તરીકે સારવાર

464
00:25:28,690 --> 00:25:30,830
એક અલગ પ્રકાર ની કિંમત.

465
00:25:30,830 --> 00:25:34,110
તેથી અમે માટે અક્ષરો સાથે કરી શકો છો
ints, ints માટે તરે, અને

466
00:25:34,110 --> 00:25:35,360
લાંબા લોન્ગ્સ ડબલ.

467
00:25:35,360 --> 00:25:38,170

468
00:25:38,170 --> 00:25:44,500
>> આ બધી બાબતો રીતે તરીકે વાપરી શકાય છે
કેટલાક આંકડાકીય કિંમત સારવાર

469
00:25:44,500 --> 00:25:48,370
કેટલાક અન્ય તરીકે ઓછા ચાર
આંકડાકીય મૂલ્ય.

470
00:25:48,370 --> 00:25:54,480
કેટલાક મુદ્દાઓ આ છે, સાથે છે તેથી
તમે પડેલા ત્યારે આવે છે, જે અલબત્ત,

471
00:25:54,480 --> 00:25:57,860
ints માટે ફ્લોટ જેવી વસ્તુઓ.

472
00:25:57,860 --> 00:26:00,500
તેથી આ થોડી વિચિત્ર છે.

473
00:26:00,500 --> 00:26:03,170
અમે 1.31 છે કે ફ્લોટ છે.

474
00:26:03,170 --> 00:26:05,220
અમે 10,000 દ્વારા વધવું.

475
00:26:05,220 --> 00:26:08,380
અને પછી અમે પૂર્ણાંક તરીકે છાપો.

476
00:26:08,380 --> 00:26:09,630
આ ઉત્પાદન શું છે?

477
00:26:09,630 --> 00:26:11,600

478
00:26:11,600 --> 00:26:14,020
10,000 વખત 1.31.

479
00:26:14,020 --> 00:26:18,761
તેથી 13,000, આ અનુમાન છે?

480
00:26:18,761 --> 00:26:20,685
>> પ્રેક્ષક: હું તે 10,000 લાગે.

481
00:26:20,685 --> 00:26:24,234
>> DAN: તેથી હું 10,000 દ્વારા ગુણાકાર છું
હું તે નિર્ણાયક છું પહેલાં.

482
00:26:24,234 --> 00:26:25,202
>> પ્રેક્ષક: ઓહ.

483
00:26:25,202 --> 00:26:27,622
ત્યાં એક 9 નહીં હોય
અને કેટલાક 0 નંબરો?

484
00:26:27,622 --> 00:26:29,270
>> DAN: તમે કેટલાક વિચિત્ર અંકો હોય છે.

485
00:26:29,270 --> 00:26:32,410

486
00:26:32,410 --> 00:26:37,670
તેથી અધિકાર, તે 1.3 વખત 10,000 છે.

487
00:26:37,670 --> 00:26:40,040
જેથી 13,000 છે.

488
00:26:40,040 --> 00:26:41,313
અને આ વધારાની weird--

489
00:26:41,313 --> 00:26:42,160
>> પ્રેક્ષક: 13.100.

490
00:26:42,160 --> 00:26:42,650
>> DAN: 13.100.

491
00:26:42,650 --> 00:26:44,910
, રોબ આભાર.

492
00:26:44,910 --> 00:26:46,610
અને આ વધારાની weirdness--

493
00:26:46,610 --> 00:26:48,060
આ 9,9--

494
00:26:48,060 --> 00:26:53,860
છે માત્ર આ કાસ્ટિંગ કારણ કે
અંત નીચે જ્યાં rounding

495
00:26:53,860 --> 00:26:55,394
તે ન હોવી જોઇએ.

496
00:26:55,394 --> 00:26:55,871
અરે વાહ.

497
00:26:55,871 --> 00:26:58,256
>> પ્રેક્ષક: આ કાસ્ટિંગ થાય
જે કંઈપણ પછી?

498
00:26:58,256 --> 00:27:03,865
>> DAN: કારણ કે તેથી હું તે મુદ્રિત આ છે
તે પહેલાં આ ગુણાકાર કરે

499
00:27:03,865 --> 00:27:05,230
આ કાસ્ટિંગ છે.

500
00:27:05,230 --> 00:27:06,140
>> AUDIENCE: [અશ્રાવ્ય].

501
00:27:06,140 --> 00:27:11,350
>> DAN: હું તે પ્રથમ ભૂમિકા લાગે
હા, 10,000 જે હશે.

502
00:27:11,350 --> 00:27:12,610
બીજું કંઈપણ?

503
00:27:12,610 --> 00:27:13,330
કૂલ.

504
00:27:13,330 --> 00:27:16,344
તેથી આ 13.099 છે.

505
00:27:16,344 --> 00:27:17,840
શા માટે બને છે?

506
00:27:17,840 --> 00:27:18,900
અશુદ્ધિ.

507
00:27:18,900 --> 00:27:21,020
>> તરે સંપૂર્ણ નથી.

508
00:27:21,020 --> 00:27:27,550
તેઓ માત્ર એક નંબરો પ્રતિનિધિત્વ કરી શકે છે
નોંધપાત્ર આધાર ચોક્કસ સંખ્યા.

509
00:27:27,550 --> 00:27:35,120
અમે 8 સિગ અંજીર છાપે તેથી જો
આ ફ્લોટ, અમે એક પ્રકારની વિચાર

510
00:27:35,120 --> 00:27:36,800
નીચ જોઈ સંખ્યા.

511
00:27:36,800 --> 00:27:45,580
અને તે છે કારણ કે 1.31 ચોક્કસ નથી કરી શકો છો
સરળ દ્વારા રજૂ કરી

512
00:27:45,580 --> 00:27:49,000
મશીન બે સત્તાઓ.

513
00:27:49,000 --> 00:27:53,530
તે નજીકના લઈ થાય તેથી
જે થાય, ધારી

514
00:27:53,530 --> 00:27:55,710
થોડી ઓછી છે.

515
00:27:55,710 --> 00:27:57,730
અર્થમાં બનાવે છે?

516
00:27:57,730 --> 00:27:59,110
બરાબર.

517
00:27:59,110 --> 00:28:05,840
>> હવે, સ્વિચ એક અલગ રીત છે
શરતી નિવેદનો જ્યાં બધા કરી

518
00:28:05,840 --> 00:28:09,900
અમે એક ચલ છે વિશે કાળજી.

519
00:28:09,900 --> 00:28:16,570
તેથી આ ચોક્કસ ઉદાહરણ, અમે છો
વપરાશકર્તા માંથી પૂર્ણાંક મેળવવામાં.

520
00:28:16,570 --> 00:28:21,070
અને પછી અમે જોઈ રહ્યા છો
કે પૂર્ણાંક શું છે.

521
00:28:21,070 --> 00:28:23,500
કદાચ, તે નંબર છે
એક અને ચાર વચ્ચે.

522
00:28:23,500 --> 00:28:24,800
કે અમે માટે કહીએ છીએ તે છે.

523
00:28:24,800 --> 00:28:28,450
>> તેથી જો તમે એક સ્વીચ કરી
ચલ નામ.

524
00:28:28,450 --> 00:28:34,290
પછી તમે શક્ય કિસ્સાઓમાં સુયોજિત
તે હોઈ શકે કિંમતો.

525
00:28:34,290 --> 00:28:37,730
તેથી એક કેસ છે, તે ઓછી છે કહે છે.

526
00:28:37,730 --> 00:28:41,080
અને પછી તમે બહાર વિચાર તોડી
સ્વીચ સ્થિતિ જેથી

527
00:28:41,080 --> 00:28:43,270
તમે ચાલુ રાખવામાં નથી.

528
00:28:43,270 --> 00:28:44,830
>> આગામી કિસ્સામાં માં

529
00:28:44,830 --> 00:28:46,940
જેથી કેસ બે અને કેસ three--

530
00:28:46,940 --> 00:28:51,920
તે કિસ્સામાં બે જો તે માત્ર નીચે નહીં
તે સાથે જુએ કોડ પ્રથમ વાક્ય

531
00:28:51,920 --> 00:28:55,400
તે વિરામ જુએ ત્યાં સુધી ત્રણ કેસ.

532
00:28:55,400 --> 00:29:00,430
તેથી કારણ તમે કેસ એક વિચાર
માત્ર પ્રિન્ટ ઓછી છે હું કારણ કે

533
00:29:00,430 --> 00:29:01,890
અહીં આ વિરામ છે.

534
00:29:01,890 --> 00:29:05,360
હું તો કહે છે, આ break-- અવગણવામાં
હું આ breakaway-- દીધો જો

535
00:29:05,360 --> 00:29:09,740
તે ઓછી છાપી શકે છે, અને પછી તે કરશે
મધ્યમ છાપો, અને પછી તેને તોડી શકે છે.

536
00:29:09,740 --> 00:29:12,200
>> આરામ એક મહત્વપૂર્ણ ભાગ છે તેથી
શરતો સ્વિચ અને

537
00:29:12,200 --> 00:29:14,340
તેઓ પ્રયત્ન કરીશું.

538
00:29:14,340 --> 00:29:20,070
બાહ્ય રીતે જણાવ્યું નથી કે કોઈપણ કેસ
મૂળભૂત દ્વારા નિયંત્રિત થાય છે

539
00:29:20,070 --> 00:29:26,645
અને સ્વીચ માં કેસ પડેલા જોઈએ.

540
00:29:26,645 --> 00:29:31,363
>> પ્રેક્ષક: તેથી 1, 2, 3,
અને 4 એ હશે?

541
00:29:31,363 --> 00:29:33,310
>> DAN: એ હોઈ શકે છે કે મૂલ્યો.

542
00:29:33,310 --> 00:29:34,654
હા.

543
00:29:34,654 --> 00:29:35,146
અરે વાહ?

544
00:29:35,146 --> 00:29:37,606
>> પ્રેક્ષક: તેથી જો તમે હોય ત્યારે
[અશ્રાવ્ય] છે?

545
00:29:37,606 --> 00:29:44,002

546
00:29:44,002 --> 00:29:46,830
>> DAN: તમે પછી નીચા છાપો, અને કરશે
તે મધ્યમ છાપો, અને કરશે

547
00:29:46,830 --> 00:29:47,400
પછી તેને તોડી શકે છે.

548
00:29:47,400 --> 00:29:50,244
>> પ્રેક્ષક: તે શા માટે છાપો કરશે
મધ્યમ જો [અશ્રાવ્ય]?

549
00:29:50,244 --> 00:29:54,036

550
00:29:54,036 --> 00:30:00,550
>> DAN: કેસ હેઠળ તેથી બધું
વિરામ હેઠળ આવે છે તે પહેલાં.

551
00:30:00,550 --> 00:30:09,390
તેથી કેસ એક પ્રિન્ટ નીચે કેસ છે
તરીકે એક આ બાદ પ્રિન્ટ છે.

552
00:30:09,390 --> 00:30:09,890
અરે વાહ?

553
00:30:09,890 --> 00:30:11,140
>> AUDIENCE: [અશ્રાવ્ય]?

554
00:30:11,140 --> 00:30:15,890

555
00:30:15,890 --> 00:30:22,170
>> DAN: તેથી આ નંબર માત્ર ચોક્કસ છે
કિંમત છે કે જે આ ચલ

556
00:30:22,170 --> 00:30:23,420
અધિકાર, લઈ શકે છે?

557
00:30:23,420 --> 00:30:26,740

558
00:30:26,740 --> 00:30:28,490
કે અર્થમાં છે?

559
00:30:28,490 --> 00:30:28,990
અરે વાહ.

560
00:30:28,990 --> 00:30:31,490
>> AUDIENCE: [અશ્રાવ્ય]?

561
00:30:31,490 --> 00:30:34,130
>> DAN: હા, કેસ બે પ્રિન્ટ કરશે
મધ્યમ અને પછી તૂટી જાય છે.

562
00:30:34,130 --> 00:30:35,380
>> AUDIENCE: [અશ્રાવ્ય]?

563
00:30:35,380 --> 00:30:37,954

564
00:30:37,954 --> 00:30:40,050
>> DAN: હું કોઈ પણ લાગે છે?

565
00:30:40,050 --> 00:30:43,855
શું અન્ય ડેટા પ્રકારો
તમે ફેરફાર કરી શકો છો?

566
00:30:43,855 --> 00:30:46,320
>> પ્રેક્ષક: તમે ફેરફાર કરી શકો છો
કોઈપણ ડેટા પ્રકારો પર.

567
00:30:46,320 --> 00:30:50,905
પરંતુ તે માત્ર અક્ષરો પર કંઈપણ અર્થ એ થાય
અને ints અને તે જેવી સામગ્રી, કારણ કે

568
00:30:50,905 --> 00:30:55,600
તમે એક નિર્દેશક પર સ્વિચ કરી રહ્યાં છો
કે ખરેખર, અર્થમાં નથી

569
00:30:55,600 --> 00:30:59,555
તે પણ માતાનો દો તો લોડ પર સ્વિચ
તમે કારણ કે ફ્લોટિંગ ચિહ્ન, તે કરવા

570
00:30:59,555 --> 00:31:02,840
ચોકસાઇ, તમે ખરેખર નથી કરશે
કોઈપણ રીતે તે કરવા માંગો છો.

571
00:31:02,840 --> 00:31:07,320
તેથી ખૂબ ખૂબ, માત્ર ints અને
કે અક્ષરો અને સામગ્રી.

572
00:31:07,320 --> 00:31:12,360
>> DAN: તમે સ્પષ્ટ હોય ત્યારે અરે વાહ, તે છે
તમે જાણો છો કે કિંમતો, મને લાગે છે, હોઈ શકે છે

573
00:31:12,360 --> 00:31:14,250
કે સ્વીચ ખરેખર ઉપયોગી છે.

574
00:31:14,250 --> 00:31:17,094

575
00:31:17,094 --> 00:31:18,990
ગુડ?

576
00:31:18,990 --> 00:31:21,370
બરાબર.

577
00:31:21,370 --> 00:31:26,180
>> અવકાશ એક જાહેર કે શ્રેણી છે
ચલ લંબાય છે.

578
00:31:26,180 --> 00:31:32,190
હું કોડ આ થોડો ભાગ તેથી,
તે ભૂલો પૂર્ણ હશે.

579
00:31:32,190 --> 00:31:41,450
અને કારણ હું આ પૂર્ણાંક જાહેર છે
હું લૂપ માટે આ તક અંદર.

580
00:31:41,450 --> 00:31:46,390
અને પછી હું કે સંદર્ભ માટે પ્રયાસ કરી રહ્યો છું
હું લૂપ અવકાશ માટે તે બહાર.

581
00:31:46,390 --> 00:31:50,330
>> તેથી મૂળભૂત રીતે, તમે અવકાશ વિશે વિચાર કરી શકો છો
તમે જાહેર જે કંઇ તરીકે

582
00:31:50,330 --> 00:31:59,750
સર્પાકાર કૌંસ સમૂહ અંદર સાથે માત્ર
તે સર્પાકાર કૌંસ અંદર અસ્તિત્વમાં છે.

583
00:31:59,750 --> 00:32:04,990
અને તમે પ્રયત્ન કરો અને તે ચલ ઉપયોગ જો
તે સર્પાકાર કૌંસ બહાર, તમે પડશે

584
00:32:04,990 --> 00:32:08,356
કમ્પાઇલર એક ભૂલ છે.

585
00:32:08,356 --> 00:32:08,812
અરે વાહ?

586
00:32:08,812 --> 00:32:09,724
>> પ્રેક્ષક: તેથી આ એક કામ કરતું નથી?

587
00:32:09,724 --> 00:32:11,790
>> DAN: આ હા, કામ કરતું નથી.

588
00:32:11,790 --> 00:32:17,190

589
00:32:17,190 --> 00:32:18,660
સ્ટ્રીંગ્સ.

590
00:32:18,660 --> 00:32:19,780
શબ્દમાળા ચાર રચે છે *.

591
00:32:19,780 --> 00:32:22,250
તેઓ બરાબર એ જ છો.

592
00:32:22,250 --> 00:32:25,540
તેઓ માત્ર અક્ષરો પોઇન્ટર છે.

593
00:32:25,540 --> 00:32:33,000
અને તમે કોઈપણ શબ્દમાળાઓ અંત જોઈએ
માત્ર છે, જે બેકસ્લેશ શૂન્ય સાથે

594
00:32:33,000 --> 00:32:34,410
એક સી સંમેલન.

595
00:32:34,410 --> 00:32:36,680
>> તે નલ ટર્મીનેટર કહેવામાં આવે છે.

596
00:32:36,680 --> 00:32:39,050
અને નલ

597
00:32:39,050 --> 00:32:41,670
મૂડી એન, મૂડી યુ, મૂડી
એલ, મૂડી L--

598
00:32:41,670 --> 00:32:44,290
તરીકે જ નથી
નલ ટર્મીનેટર.

599
00:32:44,290 --> 00:32:46,640
આ એક નિર્દેશક છે.

600
00:32:46,640 --> 00:32:48,280
આ એક પાત્ર છે.

601
00:32:48,280 --> 00:32:49,530
તેઓ ખૂબ જ અલગ છે.

602
00:32:49,530 --> 00:32:50,200
તે યાદ રાખો.

603
00:32:50,200 --> 00:32:52,320
તે કદાચ, ક્વિઝ પર રહેશે.

604
00:32:52,320 --> 00:32:54,040
હું ક્વિઝ જોઇ ન હોય.

605
00:32:54,040 --> 00:32:57,880

606
00:32:57,880 --> 00:32:58,840
અરે વાહ?

607
00:32:58,840 --> 00:33:01,232
>> પ્રેક્ષક: તેથી નલ નિર્દેશક કહે છે, છે?

608
00:33:01,232 --> 00:33:01,995
>> DAN: હા.

609
00:33:01,995 --> 00:33:05,170
>> પ્રેક્ષક: શું [અશ્રાવ્ય] છે?

610
00:33:05,170 --> 00:33:10,050
>> DAN: કહે તો malloc કહેવામાં આવે છે જ્યારે તમે
વિચાર કરવા માટે પૂરતી મેમરી નથી

611
00:33:10,050 --> 00:33:14,400
ગમે તમારા માટે પૂછી રહ્યાં છો કદ,
malloc નલ આપશે.

612
00:33:14,400 --> 00:33:19,550
એક કાર્ય છે જ્યારે તે મૂળભૂત રીતે, છે
એક નિર્દેશક પાછા રહેવા, તમે

613
00:33:19,550 --> 00:33:22,600
નલ કારણ સામે તપાસ કરવાની જરૂર છે
નલ એક સુંદર good-- છે

614
00:33:22,600 --> 00:33:25,260
તે પ્રકારની છે, જે કચરો કિંમત છે.

615
00:33:25,260 --> 00:33:27,050
તે જ્યાં સુધી પોઇન્ટર જાઓ શૂન્ય છે.

616
00:33:27,050 --> 00:33:29,630

617
00:33:29,630 --> 00:33:32,250
>> જ્યારે પણ તમે એક કાર્ય કહી,
કે નિર્દેશક આપે છે.

618
00:33:32,250 --> 00:33:35,960
તમે હોઈ ચેક કરવા માંગો છો જઈ રહ્યાં છો
કે નિર્દેશક નલ નથી ખાતરી કરો કે

619
00:33:35,960 --> 00:33:37,760
નલ ખૂબ જ સામાન્ય છે.

620
00:33:37,760 --> 00:33:40,160
તે એક કચરો વળતર જેવું છે.

621
00:33:40,160 --> 00:33:44,902
કંઈક યોગ્ય નહોતા તેથી જો,
માત્ર બદલે નલ આવો.

622
00:33:44,902 --> 00:33:45,898
>> AUDIENCE: [અશ્રાવ્ય]?

623
00:33:45,898 --> 00:33:48,922
>> DAN: હા, અને તે આ છે.

624
00:33:48,922 --> 00:33:51,750
>> AUDIENCE: [અશ્રાવ્ય]?

625
00:33:51,750 --> 00:33:52,800
>> DAN: આ તરીકે જોડણી.

626
00:33:52,800 --> 00:33:54,150
તે નલ ટર્મીનેટર છે.

627
00:33:54,150 --> 00:33:56,560
તે લોઅરકેસ એન યુ એલ એલ જો છે
તમે તેને શબ્દરચના કરી રહ્યાં છો.

628
00:33:56,560 --> 00:33:59,860
>> પ્રેક્ષક: અને હું માત્ર ગયા
અને પાછળ તે પરીક્ષણ કર્યું છે.

629
00:33:59,860 --> 00:34:03,010
અને તમે એક અપૂર્ણાંક બિંદુ મૂકવા પ્રયાસ કરો
એક સ્વીચ માં કિંમત, તે તમને કિકિયારી પડશે

630
00:34:03,010 --> 00:34:05,916
, કહે નિવેદન અભિવ્યક્તિ જરૂરી
પૂર્ણાંક પ્રકારની.

631
00:34:05,916 --> 00:34:07,166
>> DAN: ત્યાં તમે જાઓ.

632
00:34:07,166 --> 00:34:09,639

633
00:34:09,639 --> 00:34:12,246
પરંતુ હા, પ્રશ્ન ફરીથી શું હતું?

634
00:34:12,246 --> 00:34:13,496
>> AUDIENCE: [અશ્રાવ્ય]?

635
00:34:13,496 --> 00:34:16,150

636
00:34:16,150 --> 00:34:23,679
>> DAN: તેથી મૂડી એન, મૂડી યુ, મૂડી
એલ, મૂડી એલ એક વાસ્તવિક સી વસ્તુ છે.

637
00:34:23,679 --> 00:34:29,719
તે NULL નિર્દેશક છે અને ચાલશે
માત્ર જેમ કે સારવાર કરી.

638
00:34:29,719 --> 00:34:33,530
તમે ક્યારેય પ્રયાસ કરો અને જોડણી નહીં
નલ અક્ષર અને કોઈપણ જુઓ

639
00:34:33,530 --> 00:34:35,630
આ કરતાં અન્ય રીતે.

640
00:34:35,630 --> 00:34:36,610
અરે વાહ?

641
00:34:36,610 --> 00:34:42,490
>> પ્રેક્ષક: તેથી મહત્તમ ઘરનાં પરચૂરણ કામો પરત અથવા
નોંધો કંઈક, તે કરશે

642
00:34:42,490 --> 00:34:43,960
એ જ કાર્ય સમાવિષ્ટ કરવું
[અશ્રાવ્ય] છે?

643
00:34:43,960 --> 00:34:50,655

644
00:34:50,655 --> 00:34:54,949
>> પ્રેક્ષક: તેથી જો તમે ઉલ્લેખ કરવામાં આવે છે
GetChar થી ચાર મહત્તમ પરત, અથવા

645
00:34:54,949 --> 00:34:55,444
ગમે છે?

646
00:34:55,444 --> 00:34:55,940
>> પ્રેક્ષક: યાહ.

647
00:34:55,940 --> 00:34:58,620
>> પ્રેક્ષક: અરે વાહ, સામાન્ય જેથી
તે તમામ બાબતો માટે શબ્દ

648
00:34:58,620 --> 00:34:59,920
સંત્રી કિંમતો છે.

649
00:34:59,920 --> 00:35:03,640
તેથી GetInt માંથી પૂર્ણાંક મહત્તમ પરત જેવા
અને GetChar થી ચાર મહત્તમ, તે છે

650
00:35:03,640 --> 00:35:06,010
જો, બધા અધિકાર, જેમ હોઈ રહેવા
આ બધી વસ્તુઓ અમને પરત ફરી રહ્યા છે

651
00:35:06,010 --> 00:35:07,210
કંઈક ખોટું થયું હતું.

652
00:35:07,210 --> 00:35:09,950
>> પોઇન્ટર માટે, અમે માત્ર હોય થાય
આ સંત્રી કિંમત છે કે દરેક વ્યક્તિ

653
00:35:09,950 --> 00:35:10,750
પર સંમત થાય છે.

654
00:35:10,750 --> 00:35:13,210
અને આ તમે પાછા આ વસ્તુ છે
વસ્તુઓ ખોટી જઈ છે.

655
00:35:13,210 --> 00:35:15,910
તેથી ચાર મહત્તમ અમે ઉપયોગ કરી રહ્યાં છો શું છે
કંઈક પ્રતિનિધિત્વ

656
00:35:15,910 --> 00:35:18,100
નલ કે GetChar ગમે છે.

657
00:35:18,100 --> 00:35:23,420
>> પ્રેક્ષક: તમે GetChar પરીક્ષણ કરી રહ્યાં છો તેથી,
તમે માત્ર નલ મૂકી શકે?

658
00:35:23,420 --> 00:35:23,910
કે એક ફરક છે?

659
00:35:23,910 --> 00:35:25,400
>> DAN: તમે માત્ર નલ તપાસ કરી શકે છે.

660
00:35:25,400 --> 00:35:30,130
તમે કારણ કે ચાર રચે મહત્તમ તપાસો છો
કાર્ય થી પરત કિંમત છે

661
00:35:30,130 --> 00:35:35,416
એક અક્ષર નથી નિર્દેશક.

662
00:35:35,416 --> 00:35:35,888
અરે વાહ?

663
00:35:35,888 --> 00:35:38,248
>> પ્રેક્ષક: આ પ્રશ્ન પૂછે છે
શબ્દમાળા લંબાઈ માટે.

664
00:35:38,248 --> 00:35:40,136
આ નલ પાત્ર સમાવેશ થાય છે?

665
00:35:40,136 --> 00:35:41,000
>> DAN: ના

666
00:35:41,000 --> 00:35:45,930
અને તે કેવી રીતે શબ્દમાળા લંબાઈ ખરેખર છે
તે મારફતે જાય છે રોકવા જાણે

667
00:35:45,930 --> 00:35:49,070
અક્ષરો તમારા એરે સુધી
તે નલ પાત્ર જુએ છે.

668
00:35:49,070 --> 00:35:51,030
અને પછી તે બધા, જેવું છે
અધિકાર, હું કરી રહ્યો છું.

669
00:35:51,030 --> 00:35:52,130
>> AUDIENCE: [અશ્રાવ્ય] પાંચ?

670
00:35:52,130 --> 00:35:53,990
>> DAN: હેલો પાંચ છે.

671
00:35:53,990 --> 00:35:55,240
હા.

672
00:35:55,240 --> 00:35:59,580

673
00:35:59,580 --> 00:36:02,880
તેથી એરે સતત છે
મેમરી બ્લોકો.

674
00:36:02,880 --> 00:36:08,480
તેઓ કહેતા ઝટપટ ઍક્સેસ છે
સર્પાકાર માં, એરે નામ છે અને પછી

675
00:36:08,480 --> 00:36:16,720
તમે જવા માટે કરવા માંગો છો ઇન્ડેક્સ કૌંસ,
, તેઓ દ્વારા શૂન્ય માંથી અનુક્રમિત રહ્યાં છો માટે

676
00:36:16,720 --> 00:36:20,100
1 ઓછા એરે લંબાઈ.

677
00:36:20,100 --> 00:36:23,070
>> અને તેઓ પ્રકાર દ્વારા જાહેર કરી રહ્યાં છો
તમે માં સ્ટોર કરી રહ્યાં છે કે વસ્તુ

678
00:36:23,070 --> 00:36:29,750
એરે, એરે નામ, અને પછી
ગમે કદ કે એરે છે.

679
00:36:29,750 --> 00:36:36,660
તેથી આ લંબાઈ એક કોલસો બનાવો એરે છે
આ કિંમતો છે કે છ.

680
00:36:36,660 --> 00:36:42,050

681
00:36:42,050 --> 00:36:42,700
અરે વાહ?

682
00:36:42,700 --> 00:36:43,950
>> AUDIENCE: [અશ્રાવ્ય]?

683
00:36:43,950 --> 00:36:47,980

684
00:36:47,980 --> 00:36:48,460
>> DAN: અરે વાહ.

685
00:36:48,460 --> 00:36:51,340
>> AUDIENCE: [અશ્રાવ્ય]?

686
00:36:51,340 --> 00:36:56,700
>> DAN: તમે ચાલે છે તે છે
એરે માં પહેલેથી જ હતી.

687
00:36:56,700 --> 00:37:02,260
તેથી જો તમે તેના બદલે આ સ્પષ્ટ કરી શકે છે,
ના કહે છે, ચાર રચે છે, ગમે તે નામ તમારા

688
00:37:02,260 --> 00:37:12,200
એરે ખાલી કૌંસ સર્પાકાર બરાબર છે
એચ અલ્પવિરામ ઇ અલ્પવિરામ એલ અલ્પવિરામ એલ અલ્પવિરામ સબળ

689
00:37:12,200 --> 00:37:16,290
ઓ અલ્પવિરામ નલ પાત્ર
અને સર્પાકાર તાણવું.

690
00:37:16,290 --> 00:37:18,180
તે પણ એક જાહેરાત તરીકે કામ કરશે.

691
00:37:18,180 --> 00:37:20,886
>> AUDIENCE: [અશ્રાવ્ય]?

692
00:37:20,886 --> 00:37:23,110
>> DAN: પછી તમે કરવાની જરૂર છે
માપ પહેલાથી જ કરી હતી.

693
00:37:23,110 --> 00:37:23,896
>> AUDIENCE: [અશ્રાવ્ય]?

694
00:37:23,896 --> 00:37:25,146
>> DAN: હા.

695
00:37:25,146 --> 00:37:30,114

696
00:37:30,114 --> 00:37:32,420
બધા righty.

697
00:37:32,420 --> 00:37:36,430
આદેશ વાક્ય દલીલો એક માર્ગ છે
વપરાશકર્તા તરીકે ઇનપુટ મેળવવામાં

698
00:37:36,430 --> 00:37:39,380
મુખ્ય માટે દલીલો.

699
00:37:39,380 --> 00:37:40,600
મુખ્ય બે દલીલો લે છે.

700
00:37:40,600 --> 00:37:47,680
કરવામાં આવી રહી છે કે દલીલો સંખ્યા
આદેશ વાક્ય અને સાથે પસાર

701
00:37:47,680 --> 00:37:55,340
શબ્દમાળા વેક્ટર અથવા સ્ટ્રિંગ એરે
દલીલો તમામ.

702
00:37:55,340 --> 00:38:07,840
>> તેથી હું કહે છે, જેમ કે એક કાર્ય કહેવાય જો
1 જગ્યા, 2 જગ્યા, ત્રણ બહાર કોઈ,

703
00:38:07,840 --> 00:38:10,110
argc 4 છે.

704
00:38:10,110 --> 00:38:17,370
અને argv 0 બહાર કોઈ છે.

705
00:38:17,370 --> 00:38:19,130
Argv1 1 હશે.

706
00:38:19,130 --> 00:38:23,030
argv2 2 argv3 હશે હશે
3, ચોક્કસ કિસ્સામાં.

707
00:38:23,030 --> 00:38:23,310
અરે વાહ?

708
00:38:23,310 --> 00:38:25,400
>> AUDIENCE: [અશ્રાવ્ય]?

709
00:38:25,400 --> 00:38:34,010
>> DAN: એરે માં છેલ્લા તત્વ
એરે લંબાઈ argc છે કારણ કે વત્તા

710
00:38:34,010 --> 00:38:41,050
argb છે, છેલ્લા તત્વ
આ NULL નિર્દેશક છે.

711
00:38:41,050 --> 00:38:42,580
તે argc વત્તા 1 છે.

712
00:38:42,580 --> 00:38:46,210

713
00:38:46,210 --> 00:38:52,150
હું માત્ર, તે જણાવ્યું હતું કે આ કેસમાં તેથી
0 argv આવશે બહાર કોઈ છે.

714
00:38:52,150 --> 00:38:56,330
argv 1 1 argv2 3 3 છે 2 argv છે.

715
00:38:56,330 --> 00:39:03,490
એક મોટા કે જે argv 4,
argc કરતાં નલ હશે.

716
00:39:03,490 --> 00:39:04,870
>> અને તે NULL નિર્દેશક છે.

717
00:39:04,870 --> 00:39:06,590
હા.

718
00:39:06,590 --> 00:39:11,250
શબ્દમાળા છે કારણ કે અને તે છે
ચાર રચે સ્ટાર નિર્દેશક છે.

719
00:39:11,250 --> 00:39:14,102
તેથી તે જ પ્રકાર હોઈ શકે છે.

720
00:39:14,102 --> 00:39:14,595
અરે વાહ?

721
00:39:14,595 --> 00:39:16,074
>> પ્રેક્ષક: બે પ્રશ્નો.

722
00:39:16,074 --> 00:39:21,004
તેથી એક, તફાવત વચ્ચે શું છે
એક પ્રકાર કરતાં અન્ય આ અને GetString

723
00:39:21,004 --> 00:39:22,483
વપરાશકર્તા એન્જિન?

724
00:39:22,483 --> 00:39:25,934
અને બે, તે અંદર સંગ્રહાય છે
તમારી તાજેતરની મેમરી?

725
00:39:25,934 --> 00:39:28,399
તેથી, જેમ કે GetString કરશે
[અશ્રાવ્ય] કરી?

726
00:39:28,399 --> 00:39:31,357

727
00:39:31,357 --> 00:39:33,650
>> DAN: જ્યાં તે સંગ્રહ કરવામાં આવે છે?

728
00:39:33,650 --> 00:39:34,905
તે સંગ્રહિત છે કે જ્યાં મને ખબર નથી.

729
00:39:34,905 --> 00:39:40,000
>> પ્રેક્ષક: તેથી, ખરેખર, તમે કેવી રીતે કોઇ ખબર
તમે તેને દલીલો છે કૉલ કાર્ય

730
00:39:40,000 --> 00:39:42,170
સ્ટેક માં સંગ્રહિત થાય છે?

731
00:39:42,170 --> 00:39:46,610
તેથી argc અને argv દલીલો મુખ્ય છે
અને તેઓ સ્ટેક પર છે, અથવા ખરેખર

732
00:39:46,610 --> 00:39:49,131
માત્ર તમે શું વિચારો ઉપર
સ્ટેક શરૂઆત.

733
00:39:49,131 --> 00:39:53,490
અન્ય ભાગ શું હતું
પ્રશ્ન?

734
00:39:53,490 --> 00:39:56,821
>> પ્રેક્ષક: તેથી શું [અશ્રાવ્ય]?

735
00:39:56,821 --> 00:40:00,990
>> DAN: અરે વાહ, તે માત્ર એક અલગ રીત છે
ના વપરાશકર્તા તરફથી ઇનપુટ મેળવવામાં.

736
00:40:00,990 --> 00:40:06,030
આ એક થોડી વધારે કાર્યક્ષમ અને
તે સ્ક્રિપ્ટો માટે handier છે તમે કારણ કે

737
00:40:06,030 --> 00:40:10,070
ફક્ત તમારા મુખ્ય માટે દલીલો પસાર કરી શકો છો
કાર્ય બદલે રાહ કર્યા કરતાં

738
00:40:10,070 --> 00:40:13,400
વપરાશકર્તાઓ માટે તમે કોઈપણ વપરાશકર્તાઓ ન હોય તો.

739
00:40:13,400 --> 00:40:16,280
>> પ્રેક્ષક: અને હા, શબ્દમાળાઓ વિચાર
[અશ્રાવ્ય] છે.

740
00:40:16,280 --> 00:40:17,922
તે તમને જરૂર છે તે સામગ્રી સ્ટોર છે.

741
00:40:17,922 --> 00:40:18,834
>> DAN: અરે વાહ?

742
00:40:18,834 --> 00:40:21,114
>> AUDIENCE: [અશ્રાવ્ય]?

743
00:40:21,114 --> 00:40:27,545
>> DAN: હા, argv 0 હંમેશા સમાવેશ થાય છે
કોઈ કાર્ય કૉલ સ્લેશ.

744
00:40:27,545 --> 00:40:28,042
અરે વાહ?

745
00:40:28,042 --> 00:40:29,292
>> AUDIENCE: [અશ્રાવ્ય]?

746
00:40:29,292 --> 00:40:33,509

747
00:40:33,509 --> 00:40:37,310
>> DAN: હા, આ દલીલો દરેક છે
નલ અક્ષર માં અંત આવ્યો હતો કારણ કે તેઓ

748
00:40:37,310 --> 00:40:38,310
શબ્દમાળાઓ છે.

749
00:40:38,310 --> 00:40:40,892
>> AUDIENCE: [અશ્રાવ્ય]?

750
00:40:40,892 --> 00:40:44,116
>> DAN: હા, argv argc એક NULL નિર્દેશક છે.

751
00:40:44,116 --> 00:40:45,112
>> AUDIENCE: [અશ્રાવ્ય]?

752
00:40:45,112 --> 00:40:47,104
>> DAN: ઓહ હા.

753
00:40:47,104 --> 00:40:48,100
અરે વાહ, માફ કરશો.

754
00:40:48,100 --> 00:40:49,594
>> પ્રેક્ષક: તેથી [અશ્રાવ્ય]?

755
00:40:49,594 --> 00:41:08,518

756
00:41:08,518 --> 00:41:16,340
>> DAN: જો તમે હોય તો પ્રશ્ન એ છે કે તેથી
આદેશ વાક્ય ડોટ, 2, 1 બહાર કોઈ સ્લેશ

757
00:41:16,340 --> 00:41:20,410
કરશે આદેશ વાક્ય સંખ્યા
દલીલો બે અથવા ત્રણ હશે?

758
00:41:20,410 --> 00:41:24,420

759
00:41:24,420 --> 00:41:28,240
>> પ્રેક્ષક: હું તે ન કરે છે
ખરેખર તો કોઈ વાંધો.

760
00:41:28,240 --> 00:41:31,370
હું ઓહ, તમે નથી પસાર કરી હતી, કહે છે વલણ ધરાવે છે
જ્યારે કોઈપણ આદેશ વાક્ય દલીલો,

761
00:41:31,370 --> 00:41:32,730
દેખીતી રીતે, તમે કાર્ય કહેવાય છે.

762
00:41:32,730 --> 00:41:37,950
તેથી હું છૂટથી ટીકા આ બાકાત કરે છે
આદેશ વાક્યમાંથી કાર્ય

763
00:41:37,950 --> 00:41:40,350
તે છે, તેમ છતાં દલીલો
argv માં સમાવેશ થાય છે.

764
00:41:40,350 --> 00:41:42,600
>> DAN: પરંતુ તે test-- પર તો

765
00:41:42,600 --> 00:41:46,550
yeah-- અને તમને કંઈક કહે તો
argc 3 બરાબર જેમ,

766
00:41:46,550 --> 00:41:48,512
તમે સલામત સમયથી છો.

767
00:41:48,512 --> 00:41:49,416
અરે વાહ?

768
00:41:49,416 --> 00:41:50,666
>> AUDIENCE: [અશ્રાવ્ય]?

769
00:41:50,666 --> 00:42:00,990

770
00:42:00,990 --> 00:42:09,510
>> DAN: હું તો તેના બદલે આ ફોન લાગે
argc અને શબ્દમાળા argv કૌંસમાં

771
00:42:09,510 --> 00:42:14,350
પરંતુ તે જ પ્રકારના રાખવામાં અને માત્ર કહેવાય
એક જેવા વિવિધ તેમને કંઈક

772
00:42:14,350 --> 00:42:16,640
અને b, તે હજુ પણ કામ કરશે?

773
00:42:16,640 --> 00:42:18,790
અને તે હજુ પણ કામ કરશે,
તમે just-- કરશે

774
00:42:18,790 --> 00:42:21,520
બદલે argc-- ઉપયોગ
તમે a અને b ઉપયોગ કરશો.

775
00:42:21,520 --> 00:42:24,436

776
00:42:24,436 --> 00:42:25,408
અરે વાહ?

777
00:42:25,408 --> 00:42:26,658
>> AUDIENCE: [અશ્રાવ્ય]?

778
00:42:26,658 --> 00:42:34,642

779
00:42:34,642 --> 00:42:38,850
>> DAN: તેથી પ્રશ્ન GetString છે
ઢગલો મેમરી સંગ્રહવા જઈ

780
00:42:38,850 --> 00:42:42,280
GetString ચાર છે, કારણ કે *.

781
00:42:42,280 --> 00:42:47,530
તે કારણ કે ઢગલો મેમરી સંગ્રહ
વાસ્તવિક અંદર હવે malloc કહે

782
00:42:47,530 --> 00:42:49,258
GetString અમલીકરણ.

783
00:42:49,258 --> 00:42:53,210

784
00:42:53,210 --> 00:42:55,090
ઠીક છે, પર જતાં.

785
00:42:55,090 --> 00:42:55,950
>> સુરક્ષા.

786
00:42:55,950 --> 00:43:01,090
તેથી ખરેખર સુરક્ષિત હોઇ શકે છે, તમે કોઈ પર આધાર રાખે છે
એક અને તમે કોઈપણ આ બોલ પર કોઈ એક વપરાશ પરવાનગી આપે છે

787
00:43:01,090 --> 00:43:04,540
તમારી માહિતી, જે શા માટે છે
દરેકને, તેમના પોતાના મશીનો બનાવે છે

788
00:43:04,540 --> 00:43:09,580
પોતાના ઓપરેટિંગ સિસ્ટમો, તેમના તમામ
શરૂઆતથી કાર્યક્રમો, અને દેખીતી રીતે

789
00:43:09,580 --> 00:43:13,410
અન્ય કોઇ મશીનો સાથે જોડાવા નથી
ઇન્ટરનેટ મારફતે.

790
00:43:13,410 --> 00:43:17,350
તેથી કમ્પ્યુટર્સ અસુરક્ષિત છે.

791
00:43:17,350 --> 00:43:19,200
તેઓ ખરેખર છે.

792
00:43:19,200 --> 00:43:20,940
અમે અન્ય લોકો પર વિશ્વાસ હોય છે.

793
00:43:20,940 --> 00:43:26,500
>> અને સુરક્ષા ના વિચાર તમે છો છે
જથ્થો મર્યાદિત કરવા પ્રયાસ

794
00:43:26,500 --> 00:43:27,540
તમને જરૂર છે કે વિશ્વાસ.

795
00:43:27,540 --> 00:43:32,080
અને અર્થ એક તમે આ કરી
સંકેતલિપી દ્વારા છે.

796
00:43:32,080 --> 00:43:34,950
ક્રિપ્ટોગ્રાફી, અનિવાર્યપણે, છે
અમે રહસ્યો છે.

797
00:43:34,950 --> 00:43:38,880
>> ક્યારેક અમે અમારા રહસ્યો પસાર હોય છે
સાથે મારફતે, જેમ કે, ઇન્ટરનેટ અથવા

798
00:43:38,880 --> 00:43:39,980
અન્ય વસ્તુઓ.

799
00:43:39,980 --> 00:43:43,180
અને અમે લોકો નથી માંગતા
આ રહસ્યો જાણવા.

800
00:43:43,180 --> 00:43:50,100
તેથી અમે એક માર્ગ માં અમારી રહસ્યો એનક્રિપ્ટ
કે અમે કોઈ એક બહાર આકૃતિ કરી શકો છો આશા.

801
00:43:50,100 --> 00:43:51,600
>> તેથી અમે used--

802
00:43:51,600 --> 00:43:54,340
આ વર્ગ ના કોર્સ દ્વારા

803
00:43:54,340 --> 00:44:00,750
સીઝર સાઇફર જેવી વસ્તુઓ અને
બંને ખૂબ, ખૂબ છે જે [અશ્રાવ્ય],

804
00:44:00,750 --> 00:44:03,200
વસ્તુઓ એનક્રિપ્ટ ના અસુરક્ષિત રીતે.

805
00:44:03,200 --> 00:44:07,930
તેઓ બહાર આકૃતિ સરળ છો શું તેઓ
છે અને તમારા રહસ્યો શું છે.

806
00:44:07,930 --> 00:44:12,130
આ વાસ્તવિક વિશ્વમાં વધુ વાપરે
જટિલ એનક્રિપ્શન યોજનાઓ.

807
00:44:12,130 --> 00:44:13,880
અને અમે માં મળશે નહીં
કરતાં વધુ.

808
00:44:13,880 --> 00:44:18,280

809
00:44:18,280 --> 00:44:19,430
>> ડિબગીંગ.

810
00:44:19,430 --> 00:44:20,785
GDB શ્રેષ્ઠ છે.

811
00:44:20,785 --> 00:44:24,014

812
00:44:24,014 --> 00:44:25,810
હું ફરીથી આ ભાર જાઉં છું.

813
00:44:25,810 --> 00:44:30,920
GDB બધા સમય દરેક ઉપયોગ કરો
સમય તમે સમસ્યા હોય છે.

814
00:44:30,920 --> 00:44:36,030
GDB માં ઉપયોગી છે કે આદેશો છે
તમે એક લીટી ક્યાં પસાર છે, કે જે ભંગ

815
00:44:36,030 --> 00:44:41,330
નંબર, એક કાર્ય નામ, અનિવાર્યપણે
જ્યાં તમારો કોડ માં તમે બંધ કરવા માંગો છો,

816
00:44:41,330 --> 00:44:45,600
અને નિયંત્રણ લેવા માટે સમર્થ છે.

817
00:44:45,600 --> 00:44:54,140
>> પ્રિંટ ચલ લે છે અને છાપે
તે ચલ છે કે જે પર છે ગમે

818
00:44:54,140 --> 00:44:55,990
તમારા અમલ માં બિંદુ.

819
00:44:55,990 --> 00:45:00,130
આગળ તમારા અમલ ફરે
એક પગલું સાથે.

820
00:45:00,130 --> 00:45:05,050
અને એક કાર્ય અંદર પગલાં પગલું
તમારા અમલ માં.

821
00:45:05,050 --> 00:45:10,480
>> અન્ય વસ્તુઓ કેવી રીતે છે, કે જે ચલાવવામાં આવે છે
તમે ખરેખર તમારો કોડ ચલાવો.

822
00:45:10,480 --> 00:45:16,630
ચાલુ રાખો જરૂરી બધા પગલાંઓ લે
આગામી વિરામ બિંદુ વિચાર.

823
00:45:16,630 --> 00:45:18,300
અને ઘણા, ઘણા લોકો છે.

824
00:45:18,300 --> 00:45:19,040
તેમને જુઓ.

825
00:45:19,040 --> 00:45:19,901
તેઓ મહાન છો.

826
00:45:19,901 --> 00:45:20,863
અરે વાહ?

827
00:45:20,863 --> 00:45:22,113
>> AUDIENCE: [અશ્રાવ્ય]?

828
00:45:22,113 --> 00:45:26,635

829
00:45:26,635 --> 00:45:28,200
>> DAN: હા, એક ડીબગર છે.

830
00:45:28,200 --> 00:45:34,230
તેથી એક ડીબગર એક કાર્યક્રમ છે કે
તમે તમારા કાર્યક્રમ ડિબગ કરી શકો છો.

831
00:45:34,230 --> 00:45:39,931
તે માટે ભૂલો શોધે છે એક કાર્યક્રમ છે કે નથી
તમે, જોકે તે મહાન છે.

832
00:45:39,931 --> 00:45:43,020

833
00:45:43,020 --> 00:45:46,040
>> અને શોધ મારા માટે છેલ્લા છે.

834
00:45:46,040 --> 00:45:51,470
અમે વાત કરી શોધ પ્રકારો તેથી
આ વર્ગ વિશે રેખીય શોધ છે,

835
00:45:51,470 --> 00:45:55,960
જે તમે દરેક મારફતે જોવા કે માત્ર છે
શોધ જગ્યા તત્વ, એક

836
00:45:55,960 --> 00:46:00,410
એક સમયે તત્વ, તમે તે મેળવી ત્યાં સુધી
તમારા માટે અથવા તમે સુધી પહોંચવા ત્યાં સુધી જોઈ રહ્યા છો

837
00:46:00,410 --> 00:46:03,350
તમારી શોધ જગ્યા ઓવરને કે
તમે શોધી શકે છે કે જે કહે નિર્દેશ

838
00:46:03,350 --> 00:46:06,360
તમે શોધી રહ્યા છો કે જે તત્વ.

839
00:46:06,360 --> 00:46:13,450
અને આ શ્રેષ્ઠ સતત સમય લે છે
જે 1 0 છે અને સૌથી ખરાબ રેખીય પર

840
00:46:13,450 --> 00:46:16,070
n ના 0 છે, જે સમય.

841
00:46:16,070 --> 00:46:19,250
>> જરૂર છે કે જે બાઈનરી શોધ,
sordid તત્વો છે.

842
00:46:19,250 --> 00:46:24,230
તમે તમારા ઘટકો મધ્યમાં પર જાઓ,
જુઓ તો તમે શોધી રહ્યાં છો તે તત્વ

843
00:46:24,230 --> 00:46:30,120
તત્વ કરતાં મોટા કે નાના છે
તમે મધ્યમાં પર છો છે.

844
00:46:30,120 --> 00:46:36,510
તે મોટા છે, તો તમે નીચે કહે છે કે
તમારા શોધ જગ્યા તમારી છે

845
00:46:36,510 --> 00:46:41,550
વર્તમાન સ્થાન, મધ્યમ,
અને તમે પ્રક્રિયા પુન: શરૂ કરો.

846
00:46:41,550 --> 00:46:46,150
તે નાની છે, તો તમે કહી જુઓ
હા, અપ શું કરવું છે?

847
00:46:46,150 --> 00:46:47,400
>> AUDIENCE: [અશ્રાવ્ય]?

848
00:46:47,400 --> 00:46:51,000

849
00:46:51,000 --> 00:46:54,260
>> DAN: હા.

850
00:46:54,260 --> 00:46:58,360
શીખવવામાં આવ્યું છે કે આનાથી સૉર્ટ કરો કોઇ પણ પ્રકારની
વર્ગ પરીક્ષણ માટે યોગ્ય રમત છે.

851
00:46:58,360 --> 00:47:01,504

852
00:47:01,504 --> 00:47:04,920
>> [હાસ્ય]

853
00:47:04,920 --> 00:47:10,260
>> DAN: અને તમે થયું નથી હકીકત એ છે કે
સમસ્યા સમૂહ માટે તેને કરવા માટે, તે યોગ્ય છે

854
00:47:10,260 --> 00:47:12,420
પરીક્ષણ માટે રમત.

855
00:47:12,420 --> 00:47:15,186
>> પ્રેક્ષક: અમે તેની પર જઈ શકો છો કેવી રીતે to--

856
00:47:15,186 --> 00:47:17,052
>> DAN: તે પર ચાલ્યા આવશે.

857
00:47:17,052 --> 00:47:20,496
>> 2 વક્તા: માટે આ વાસ્તવિક કોડ
[અશ્રાવ્ય] study.cs50.net પર છે.

858
00:47:20,496 --> 00:47:25,910

859
00:47:25,910 --> 00:47:32,680
તમે આ પ્રથા સમસ્યા જોવા તેથી જો
ના મર્જ સૉર્ટ પાનાંમાં

860
00:47:32,680 --> 00:47:35,880
study.cs50.net, આ કોડ છે
સૉર્ટ મર્જ અમલીકરણ માટે.

861
00:47:35,880 --> 00:47:38,550
તેથી તમે અમલ કરવાની જરૂર નથી
તે જાતે આજની રાત કે સાંજ.

862
00:47:38,550 --> 00:47:42,090
પરંતુ ખાતરી કરો કે તમે તેના બદલે તે સમજી કરો
કરતાં માત્ર તેને યાદ.

863
00:47:42,090 --> 00:47:45,035
>> AUDIENCE: [અશ્રાવ્ય]?

864
00:47:45,035 --> 00:47:49,720
>> 2 વક્તા: પર મર્જ સૉર્ટ પાનું
study.cs50.net, એક પ્રથા છે

865
00:47:49,720 --> 00:47:53,570
તમે મારફતે ક્લિક કરો કે, સમસ્યા
સમસ્યા ખૂબ જ ઓવરને અંતે છે એક

866
00:47:53,570 --> 00:47:56,280
મર્જ છે ઉકેલ,
સૉર્ટ અમલ.

867
00:47:56,280 --> 00:47:58,510
પરંતુ ખાતરી કરો કે તમે તેને સમજી
તેના બદલે માત્ર તે યાદ કરતાં

868
00:47:58,510 --> 00:47:59,760
અથવા તે નીચે નકલ.

869
00:47:59,760 --> 00:48:02,870

870
00:48:02,870 --> 00:48:06,340
>> પ્રેક્ષક: અને એક સંપૂર્ણપણે માન્ય
આ પરીક્ષા માટે સમસ્યા હશે

871
00:48:06,340 --> 00:48:07,990
અહીં કંઈક યાદી છે.

872
00:48:07,990 --> 00:48:12,100
આ યાદી પછી જેમ દેખાય છે શું
પસંદગીઓ જેવું એક પગલું અથવા

873
00:48:12,100 --> 00:48:13,330
દાખલ સૉર્ટ અથવા જે.

874
00:48:13,330 --> 00:48:14,940
યાદીમાં એક સંપૂર્ણ પુનરાવૃત્તિ.

875
00:48:14,940 --> 00:48:18,530
તમે જરૂર અંત નથી તેથી તો પણ
તે માટે કોડ છે, તો તમે તેને સમજવા જરૂરી

876
00:48:18,530 --> 00:48:20,440
તે ચાલી રહ્યું છે ખબર કેવી રીતે કરવા માટે પૂરતી
આ એરે બદલવા છે.

877
00:48:20,440 --> 00:48:24,144

878
00:48:24,144 --> 00:48:25,394
>> DAN: તે મારા માટે તે છે.

879
00:48:25,394 --> 00:48:30,604

880
00:48:30,604 --> 00:48:32,588
>> [વધાવી]

881
00:48:32,588 --> 00:49:06,316

882
00:49:06,316 --> 00:49:07,410
>> LUCAS: અરે દરેક.

883
00:49:07,410 --> 00:49:08,390
મારું નામ લુકાસ છે.

884
00:49:08,390 --> 00:49:16,840
હું બધા, રિકર્ઝન વિશે વાત કરવા જઈ રહ્યો છું
આ અમે શીખ્યા છે કે પ્રકારના, અને

885
00:49:16,840 --> 00:49:18,050
બધા પોઇંટરો થોડો.

886
00:49:18,050 --> 00:49:18,740
બરાબર?

887
00:49:18,740 --> 00:49:20,340
તેથી સૌ પ્રથમ, રિકર્ઝન.

888
00:49:20,340 --> 00:49:22,951
તે કહે છે કે શું અર્થ છે
એક કાર્ય ફરી યાદ આવવું છે?

889
00:49:22,951 --> 00:49:24,675
>> પ્રેક્ષક: પોતે કહે.

890
00:49:24,675 --> 00:49:26,500
>> LUCAS: ઠીક છે, હા, પોતે કહે છે.

891
00:49:26,500 --> 00:49:27,700
તેથી, ઉદાહરણ તરીકે આ ચિત્ર, ગમે છે.

892
00:49:27,700 --> 00:49:30,280
તે અંદર ચિત્ર જેવું છે
એક ચિત્ર અને તેથી પર.

893
00:49:30,280 --> 00:49:35,740
તેથી, ઉદાહરણ તરીકે, તમે ડેન તરીકે હોય શકે
કે બાઈનરી શોધ અંગે વાત કરી હતી.

894
00:49:35,740 --> 00:49:41,840
એક રીતે જેમાં બાઈનરી શોધ છે
ફરી યાદ આવવું તમે છો કે હકીકત એ છે

895
00:49:41,840 --> 00:49:43,130
એક નંબર શોધવા પ્રયાસ કરે છે.

896
00:49:43,130 --> 00:49:44,250
તેથી તમે મધ્યમ પર જાઓ.

897
00:49:44,250 --> 00:49:47,130
ત્યાં નંબરો તો પછી તમે તપાસ
ડાબી અને જમણી.

898
00:49:47,130 --> 00:49:49,650
>> અને પછી તમે સંખ્યા છે તે શોધવા જો
ડાબી પર પ્રયત્ન રહ્યું છે, તે જ છે

899
00:49:49,650 --> 00:49:53,340
ફરી શોધ કરી તરીકે વસ્તુ પરંતુ
ફક્ત યાદી ડાબી પર.

900
00:49:53,340 --> 00:49:57,350
લાગે છે કે કેવી રીતે જેથી છે
જેમ તે ફરી યાદ આવવું છે.

901
00:49:57,350 --> 00:50:01,870
તમે ગાય્સ યાદ આવવું છે તેથી કે શા માટે છે
મર્જ સૉર્ટ માટે ઉકેલ.

902
00:50:01,870 --> 00:50:04,270
>> ઠીક છે, તેથી અહીં એક ઉદાહરણ છે.

903
00:50:04,270 --> 00:50:07,280
તેથી આપણે હું પસંદ કરો માંગો છો કહે છે કે દો
1 થી n એ માટે બધી સંખ્યાઓ.

904
00:50:07,280 --> 00:50:13,790
હું ખ્યાલ છે કે એ સરવાળા
નંબર એ વત્તા એ ઓછા 1 1 પર છે.

905
00:50:13,790 --> 00:50:17,810
પરંતુ તે પછી, હું એ ઓછા 1 જોવા વત્તા
એ ઓછા 2 વત્તા 1, તે જ છે

906
00:50:17,810 --> 00:50:20,680
એકત્ર નંબરો તરીકે વસ્તુ
માટે એ ઓછા 1 અપ.

907
00:50:20,680 --> 00:50:25,890
તેથી હું એક સમાન રકમ ની રકમ કહી શકો છો
એ ઓછા 1 ના એ વત્તા રકમ સમકક્ષ હોય છે.

908
00:50:25,890 --> 00:50:28,010
કે અર્થમાં છે?

909
00:50:28,010 --> 00:50:32,630
>> અને હું પણ કંઈક બીજું હશે
છે, કે જે આધાર કેસ કહેવાય

910
00:50:32,630 --> 00:50:37,440
અપ નંબરો સરવાળા
શૂન્ય શૂન્ય છે.

911
00:50:37,440 --> 00:50:42,770
તેથી જલદી હું સંખ્યા પર વિચાર
શૂન્ય, હું ગણતરી અટકાવો.

912
00:50:42,770 --> 00:50:45,330
કે અર્થમાં છે?

913
00:50:45,330 --> 00:50:48,120
>> અહીં કેવી રીતે એક ઉદાહરણ છે
હું કે અમલ કરી શકે છે.

914
00:50:48,120 --> 00:50:49,860
તેથી હું કેટલાક આ કાર્ય છે.

915
00:50:49,860 --> 00:50:51,700
તે પૂર્ણાંક n એ લઈ જાય છે.

916
00:50:51,700 --> 00:50:56,300
એ છે જો અહીં હું પ્રથમ તપાસ
ઓછી અથવા શૂન્ય સમકક્ષ હોય છે.

917
00:50:56,300 --> 00:51:00,310
તેથી તે, શૂન્ય ઓછી અથવા સમાન છે તો હું
અમારા આધાર કેસ છે, કે જે શૂન્ય આવો.

918
00:51:00,310 --> 00:51:05,690
નહિંતર, હું હમણાં જ પાછા આવી શકો છો એ વત્તા
નંબરો સરવાળા થી

919
00:51:05,690 --> 00:51:07,190
એ ઓછા એક માટે એક.

920
00:51:07,190 --> 00:51:09,360
અર્થમાં બનાવે છે?

921
00:51:09,360 --> 00:51:10,100
બરાબર.

922
00:51:10,100 --> 00:51:11,610
>> અહીં તે શું લાગે છે.

923
00:51:11,610 --> 00:51:15,260
તમે 2 સમકક્ષ ની રકમ છે
2 વત્તા 1 ની રકમ.

924
00:51:15,260 --> 00:51:18,930
અને 1 કેટલાક વત્તા 1 છે
0 છે, જે 0 રકમ પોસ્ટેડ,.

925
00:51:18,930 --> 00:51:20,216
અર્થમાં બનાવે છે?

926
00:51:20,216 --> 00:51:25,342
અમે સ્ટેક જોવા તેથી જો તમારા
કાર્યક્રમ, આ તે શું લાગે છે.

927
00:51:25,342 --> 00:51:26,820
>> પ્રથમ, અમે મુખ્ય કાર્ય છે.

928
00:51:26,820 --> 00:51:30,320
અને પછી મુખ્ય કાર્ય
રકમ 2 કહેવાય છે.

929
00:51:30,320 --> 00:51:36,690
અને પછી રકમ 2 ઓહ, કહે રહ્યું છે, રકમ
2 2 વત્તા એક સરવાળો સમકક્ષ હોય છે.

930
00:51:36,690 --> 00:51:39,460
તેથી હું સ્ટેક માટે 1 રકમ ઉમેરો.

931
00:51:39,460 --> 00:51:43,860
અને 1 ની રકમ ની રકમ કહી રહ્યા છે
0, જે પણ ઉમેરી શકાય રહ્યું છે

932
00:51:43,860 --> 00:51:44,630
સ્ટેક છે.

933
00:51:44,630 --> 00:51:49,240
અને છે કે આ મુદ્દાઓ પછી દરેક
બીજા ઉપર પાછા છે

934
00:51:49,240 --> 00:51:52,020
અન્ય મુદ્દાઓ ચાલુ રાખવામાં પહેલાં.

935
00:51:52,020 --> 00:51:56,240
>> તેથી, ઉદાહરણ તરીકે, અહીં, 0 ની રકમ પોસ્ટેડ,
પ્રથમ, 0 પાછા જઈ રહ્યું છે.

936
00:51:56,240 --> 00:51:58,320
અને પછી 1 રકમ પસંદ કરો.

937
00:51:58,320 --> 00:52:00,850
પછી 1 રકમ રહ્યું છે
2 સરવાળો 1 આવો.

938
00:52:00,850 --> 00:52:03,900
અને છેલ્લે, 2 રકમ રહ્યું છે
મુખ્ય 3 પાછા.

939
00:52:03,900 --> 00:52:05,320
કે અર્થમાં છે?

940
00:52:05,320 --> 00:52:09,496
>> તે કેવી રીતે સમજવા માટે ખરેખર મહત્વનું છે
સ્ટેક કામ કરે છે અને પ્રયાસ કરો છે

941
00:52:09,496 --> 00:52:11,980
તે અર્થમાં બનાવે છે તે જોવા.

942
00:52:11,980 --> 00:52:13,260
ઠીક છે, તેથી સૉર્ટ.

943
00:52:13,260 --> 00:52:16,170
તેથી શા માટે મહત્વપૂર્ણ સૉર્ટ છે
સૌ પ્રથમ?

944
00:52:16,170 --> 00:52:18,260
આપણે શા માટે ચિંતા કરવી જોઈએ?

945
00:52:18,260 --> 00:52:20,310
કોઈપણ?

946
00:52:20,310 --> 00:52:20,695
મને એક ઉદાહરણ આપો?

947
00:52:20,695 --> 00:52:21,040
અરે વાહ?

948
00:52:21,040 --> 00:52:22,968
>> AUDIENCE: [અશ્રાવ્ય].

949
00:52:22,968 --> 00:52:24,700
>> LUCAS: બરાબર, હા.

950
00:52:24,700 --> 00:52:26,090
તેથી તમે વધુ અસરકારક રીતે શોધ કરી શકો છો.

951
00:52:26,090 --> 00:52:28,580
તે એક સારો માર્ગ છે.

952
00:52:28,580 --> 00:52:32,462
તેથી, ઉદાહરણ તરીકે, અમે ઘણો છે
વસ્તુઓ ખરેખર, અમારા જીવન કે

953
00:52:32,462 --> 00:52:32,920
અલગ પાડવામાં આવે છે.

954
00:52:32,920 --> 00:52:34,830
ઉદાહરણ તરીકે, શબ્દકોશ.

955
00:52:34,830 --> 00:52:39,210
>> તે બધા છે કરવા માટે ખૂબ જ મહત્વપૂર્ણ છે
માટે અમુક પ્રકારના શબ્દો કે અમે

956
00:52:39,210 --> 00:52:41,970
સરળતાથી ઍક્સેસ કરી શકો છો.

957
00:52:41,970 --> 00:52:43,280
જેથી તેઓ કહેતા કરવામાં આવી છે તે છે.

958
00:52:43,280 --> 00:52:45,530
તમે વધુ અસરકારક રીતે શોધ કરી શકો છો.

959
00:52:45,530 --> 00:52:48,740
તે હોય છે કેવી રીતે હાર્ડ વિચારો
શબ્દો છે કે જેમાં શબ્દકોશ

960
00:52:48,740 --> 00:52:49,500
ગમે તે.

961
00:52:49,500 --> 00:52:53,120
તમે ખૂબ ખૂબ, જુઓ પડશે
દરેક એક શબ્દ તમે શોધી સુધી

962
00:52:53,120 --> 00:52:54,720
તમે શોધી રહ્યા છો કે શબ્દ.

963
00:52:54,720 --> 00:52:58,710
>> તમે પણ ફેસબુક ઉપયોગ કરી રહ્યાં છો, જ્યારે
તમે તમારા મિત્રો પર શોધી રહ્યાં છો, તમે છો

964
00:52:58,710 --> 00:53:03,540
ફેસબુક મૂકી કે જોવા જઈ તમારા
નજીક મિત્ર રાશિઓ ટોચ પર છે

965
00:53:03,540 --> 00:53:05,470
તમે ખૂબ કે સાથે વાત નથી.

966
00:53:05,470 --> 00:53:08,080
તમે નીચે બધી રીતે જાઓ
તમારા મિત્ર યાદી, તમે જોઈ રહ્યા છીએ

967
00:53:08,080 --> 00:53:11,250
તમે કદાચ પણ નથી કે લોકો
તમારી સાથે મિત્રો છો યાદ રાખો કે.

968
00:53:11,250 --> 00:53:14,590
અને તે ફેસબુક પ્રકારના કારણ છે
કેવી રીતે પર આધારિત છે તમારા મિત્રો

969
00:53:14,590 --> 00:53:16,472
તમે તેમને છે બંધ કરો.

970
00:53:16,472 --> 00:53:17,930
>> તેથી માહિતી આયોજન.

971
00:53:17,930 --> 00:53:18,450
પણ પોકેમોન.

972
00:53:18,450 --> 00:53:21,400
તેથી તમે બધા Pokemons જુઓ કે
હોય છે.

973
00:53:21,400 --> 00:53:27,210
અને તે એક સરળ જેવું છે
માહિતી ઍક્સેસ માર્ગ.

974
00:53:27,210 --> 00:53:29,050
>> પ્રેક્ષક: પોકેમોન ઍક્સેસ.

975
00:53:29,050 --> 00:53:29,890
>> LUCAS: અરે વાહ.

976
00:53:29,890 --> 00:53:32,395
>> AUDIENCE: [અશ્રાવ્ય].

977
00:53:32,395 --> 00:53:33,460
>> LUCAS: હા.

978
00:53:33,460 --> 00:53:35,140
ઠીક છે, તેથી પસંદગી સૉર્ટ.

979
00:53:35,140 --> 00:53:41,610
પસંદગી સૉર્ટ પસંદ રહ્યું છે
યાદી નાના ક્રમમાંગોઠવાયેલનથી કિંમત દરેક

980
00:53:41,610 --> 00:53:43,300
દરેક ઇટરેશન સમય.

981
00:53:43,300 --> 00:53:46,800
તે પ્રકારની તમે શું છે કે જે પ્રકારની જેવું છે
તમારા માથા માં તમે પ્રયાસ કરી રહ્યા છો ત્યારે

982
00:53:46,800 --> 00:53:48,430
બાજુ યાદી સૉર્ટ.

983
00:53:48,430 --> 00:53:51,990
>> મૂળભૂત રીતે, તમે શું બધા તમે જોવા છે
નાના નંબર માટે.

984
00:53:51,990 --> 00:53:54,280
તમે છટણી યાદી માં મૂકી.

985
00:53:54,280 --> 00:53:56,230
અને પછી તમે જોવા
આગામી નાના સંખ્યા.

986
00:53:56,230 --> 00:54:00,080
અને પછી તમે કરી રાખવા
કે અને તેથી પર.

987
00:54:00,080 --> 00:54:04,600
>> તેથી પસંદગી સૉર્ટ તમે મૂળભૂત છે
દર વખતે નાના પસંદ

988
00:54:04,600 --> 00:54:05,750
ક્રમમાંગોઠવાયેલનથી મૂલ્ય.

989
00:54:05,750 --> 00:54:10,840
છટણી ઓવરને અંતે મૂકો
યાદી ભાગ છે.

990
00:54:10,840 --> 00:54:12,370
અને તે કરી રાખો.

991
00:54:12,370 --> 00:54:15,890
તેથી આપણે ઝડપથી જુઓ શું
આ જેવો દેખાય છે.

992
00:54:15,890 --> 00:54:19,340
અહીં છટણી છે
અને ક્રમમાંગોઠવાયેલનથી યાદી.

993
00:54:19,340 --> 00:54:23,350
>> યાદીમાં સૉર્ટ માટે તેથી,
તે શરૂઆતમાં ખાલી છે.

994
00:54:23,350 --> 00:54:26,760
અને પછી હું પસંદ કરવા માટે જઇ રહ્યો છું
2 છે, જે અહીં નાના નંબર,.

995
00:54:26,760 --> 00:54:30,650
તેથી હું 2 નંબર વિચાર અને હું મૂકી
યાદીમાં સામે.

996
00:54:30,650 --> 00:54:34,910
અને પછી હું આગામી નાના જોવા
3 છે, જે તત્વ,.

997
00:54:34,910 --> 00:54:37,050
તેથી હું ઓવરને અંતે મૂકો
છટણી યાદી.

998
00:54:37,050 --> 00:54:38,140
અને પછી હું તે કરી રાખો.

999
00:54:38,140 --> 00:54:40,040
હું 4 શોધી અને ઓવરને અંતે મૂકો.

1000
00:54:40,040 --> 00:54:41,360
5 શોધો અને ઓવરને અંતે મૂકો.

1001
00:54:41,360 --> 00:54:44,830
>> અને તે વખત કેવી રીતે બધા જુઓ કે
હું અંત છે પર મૂકવામાં કહી રહ્યો છું

1002
00:54:44,830 --> 00:54:46,850
મૂળભૂત રીતે, બે કિંમતો જેઓ.

1003
00:54:46,850 --> 00:54:48,100
બરાબર?

1004
00:54:48,100 --> 00:54:50,140

1005
00:54:50,140 --> 00:54:52,825
અને પછી છેલ્લા એક, તમે માત્ર
વધુ એક તત્વ છે.

1006
00:54:52,825 --> 00:54:55,870
તેથી તે પહેલાથી જ છટણી છે.

1007
00:54:55,870 --> 00:54:57,800
>> ઠીક છે, તેથી દાખલ સૉર્ટ.

1008
00:54:57,800 --> 00:55:03,180
નિવેશ સૉર્ટ તમે પણ હોય રહ્યા છીએ
એક સૉર્ટ કર્યા કે વસ્તુ અને

1009
00:55:03,180 --> 00:55:04,690
એક ક્રમમાંગોઠવાયેલનથી યાદી.

1010
00:55:04,690 --> 00:55:14,540
આ જ વસ્તુ છે દર વખતે કે
તમે સૉર્ટ કરવા માટે એક તત્વ ઉમેરી રહ્યાં છીએ

1011
00:55:14,540 --> 00:55:18,170
યાદી, તમે માત્ર તત્વ પસંદ કે
ક્રમમાંગોઠવાયેલનથી યાદી સામે છે.

1012
00:55:18,170 --> 00:55:20,880
અને પછી તમે શું શોધી રહ્યા છીએ
સ્થિતિ તે છટણી હોવી જોઈએ

1013
00:55:20,880 --> 00:55:22,300
યાદી ભાગ છે.

1014
00:55:22,300 --> 00:55:25,840
>> ચાલો આ તેથી શું છે તે જોવા દો
આ વધુ અર્થમાં બનાવે છે.

1015
00:55:25,840 --> 00:55:29,360
તેથી શરૂઆતમાં, ઉદાહરણ તરીકે, હું પ્રયાસ કરી રહ્યો છું
આ નંબર ત્રણ દાખલ કરવા માટે

1016
00:55:29,360 --> 00:55:30,680
યાદીમાં છટણી ભાગ છે.

1017
00:55:30,680 --> 00:55:31,800
તેથી યાદી કંઈપણ નથી.

1018
00:55:31,800 --> 00:55:34,160
તેથી હું માત્ર સંખ્યા 3 મૂકી શકો છો.

1019
00:55:34,160 --> 00:55:37,480
>> હવે, હું 5 નંબર ઍડ કરવા માંગો છો
યાદીમાં છટણી ભાગ છે.

1020
00:55:37,480 --> 00:55:38,900
તેથી હું 5 નંબર જુઓ.

1021
00:55:38,900 --> 00:55:40,450
હું તેને 3 કરતાં વધુ છે કે નોટિસ.

1022
00:55:40,450 --> 00:55:41,980
તેથી હું તેને 3 પછી હોઈ શકે છે કે જે ખબર.

1023
00:55:41,980 --> 00:55:44,100
તેથી હું 3 અને 5 મૂકો.

1024
00:55:44,100 --> 00:55:45,940
>> પછી હું 2 નંબર દાખલ કરવા માંગો છો.

1025
00:55:45,940 --> 00:55:51,630
હું 2 નંબર ખરેખર છે કે નોટિસ
પછી 3 અને 5 બંને રહે.

1026
00:55:51,630 --> 00:55:54,580
તેથી હું ખરેખર તે બધા મૂકવો પડશે
યાદીમાં શરૂઆતમાં રીતે.

1027
00:55:54,580 --> 00:55:59,030
તેથી હું પ્રકારની તમામ પાળી છે
છટણી યાદી જેથી હું કરી શકો છો માં તત્વો

1028
00:55:59,030 --> 00:56:01,970
2 નંબર માટે જગ્યા બનાવે છે.

1029
00:56:01,970 --> 00:56:03,160
>> પછી હું નંબર 6 જુઓ.

1030
00:56:03,160 --> 00:56:05,450
હું તે 5 પછી પ્રયત્ન કરીશું કે જુઓ.

1031
00:56:05,450 --> 00:56:06,240
તેથી હું તેને ત્યાં મૂકી.

1032
00:56:06,240 --> 00:56:07,965
અને છેલ્લે, હું નંબર 4 જુઓ.

1033
00:56:07,965 --> 00:56:11,030
અને હું તે જોઇએ નોટિસ
3 અને 5 વચ્ચે છે.

1034
00:56:11,030 --> 00:56:14,870
અને પછી હું તેને ત્યાં મૂકી અને પાળી
બીજા બધા તત્વો છે.

1035
00:56:14,870 --> 00:56:16,120
અર્થમાં બનાવે છે?

1036
00:56:16,120 --> 00:56:17,880

1037
00:56:17,880 --> 00:56:19,150
>> બબલ સૉર્ટ.

1038
00:56:19,150 --> 00:56:25,730
તેથી બબલ સૉર્ટ તમે છો શું મૂળભૂત છે
જઈને અમે બબલ કૉલ કરવું

1039
00:56:25,730 --> 00:56:30,113
તમે યાદી મારફતે જાઓ પ્રકારની કારણ કે
હું માત્ર બતાવવા જો તે ખરેખર સારી છે

1040
00:56:30,113 --> 00:56:32,300
તમે આ ગમે છે

1041
00:56:32,300 --> 00:56:35,030
અને તમે સરખામણી રહ્યા છીએ
અડીને નંબરો.

1042
00:56:35,030 --> 00:56:38,410
અને તમે સ્વેપ રહ્યા છીએ તેમના
સ્થિતિ તેઓ જાણતા ન હો તો

1043
00:56:38,410 --> 00:56:39,190
યોગ્ય ક્રમમાં.

1044
00:56:39,190 --> 00:56:42,570
>> તેથી મૂળભૂત રીતે, શું ચાલે છે
અહીં છે શું, ઉદાહરણ તરીકે,

1045
00:56:42,570 --> 00:56:44,160
તમે 8 અને 6 છે.

1046
00:56:44,160 --> 00:56:47,270
તમે કે ક્રમમાં કરશે ખબર
ખરેખર અધિકાર 6 અને 5, કરી?

1047
00:56:47,270 --> 00:56:49,540
તેથી તમે ઓર્ડર સ્વેપ રહ્યા છીએ.

1048
00:56:49,540 --> 00:56:51,370
પછી હું અહીં 8 અને 4 જુઓ.

1049
00:56:51,370 --> 00:56:52,250
અને હું આ જ વાત કરી.

1050
00:56:52,250 --> 00:56:53,400
હું ફરીથી સ્વેપ.

1051
00:56:53,400 --> 00:56:55,070
અને છેલ્લે, 2 અને 8.

1052
00:56:55,070 --> 00:56:56,670
હું પણ તેમને સ્વેપ.

1053
00:56:56,670 --> 00:57:01,690
>> તે બબલ સૉર્ટ કરો, કારણ કે પછી કહેવાય છે
આ iterations દરેક, ખરેખર,

1054
00:57:01,690 --> 00:57:05,910
યાદીમાં તો સૌથી મોટી સંખ્યામાં તમામ નહીં
આ યાદી ઓવરને માર્ગ.

1055
00:57:05,910 --> 00:57:06,940
કે અર્થમાં છે?

1056
00:57:06,940 --> 00:57:11,880
તે જેઓ રાખે છે
અને જમણી તે ખસેડવાની.

1057
00:57:11,880 --> 00:57:14,440
>> ઠીક છે, તેથી આ બીજા પુનરાવૃત્તિ છે.

1058
00:57:14,440 --> 00:57:17,200
તે જ વાત છે.

1059
00:57:17,200 --> 00:57:20,190
હું એક સ્વેપ કરીશ અને
પછી છેલ્લા એક.

1060
00:57:20,190 --> 00:57:23,290
કોઈ અદલબદલ છે હું
અને યાદી સૉર્ટ થાય છે.

1061
00:57:23,290 --> 00:57:27,460
બબલ સૉર્ટ તેથી, અમે મૂળભૂત રીતે રાખવા
આ યાદી મારફતે જવું અને જેઓ

1062
00:57:27,460 --> 00:57:32,310
વસ્તુઓ હું ન કર્યું કે નોટિસ સુધી
કે પુનરાવૃત્તિ કરી કોઈપણ અદલબદલ, જે

1063
00:57:32,310 --> 00:57:34,270
યાદી પહેલેથી સૉર્ટ થાય છે કે જે થાય છે.

1064
00:57:34,270 --> 00:57:35,520
અર્થમાં બનાવે છે?

1065
00:57:35,520 --> 00:57:38,400

1066
00:57:38,400 --> 00:57:40,870
>> માતાનો થોડો વાત કરો
સમય ચાલી વિશે.

1067
00:57:40,870 --> 00:57:45,165
તેથી જો તમે ગાય્સ મોટા યાદ છે
ઓ, ઓમેગા, અને થીટા?

1068
00:57:45,165 --> 00:57:49,290

1069
00:57:49,290 --> 00:57:50,990
અરે વાહ?

1070
00:57:50,990 --> 00:57:53,070
ઠીક છે, મોટા ઓ સૌ પ્રથમ, તે છે?

1071
00:57:53,070 --> 00:57:54,315
>> AUDIENCE: [અશ્રાવ્ય].

1072
00:57:54,315 --> 00:57:59,070
>> LUCAS: અરે વાહ, તે એક ખરાબ કિસ્સામાં કહેવાય છે
માત્ર તે છે કે જે થાય છે કે જે રનટાઇમ,

1073
00:57:59,070 --> 00:58:03,470
કેટલી તમે કાર્યક્રમ અપેક્ષા
ચલાવવા માટે લે છે.

1074
00:58:03,470 --> 00:58:04,910
જેમ, દ્રષ્ટિએ of--

1075
00:58:04,910 --> 00:58:06,660
આ કિસ્સામાં એ છે.

1076
00:58:06,660 --> 00:58:09,150
આ તત્વો સંખ્યા
સૌથી ખરાબ કિસ્સામાં યાદી.

1077
00:58:09,150 --> 00:58:12,520
જેમ, સૌથી ખરાબ શક્ય કિસ્સામાં.

1078
00:58:12,520 --> 00:58:17,100
>> બબલ સૉર્ટ તેથી, ઉદાહરણ તરીકે,
અમે n ચોરસ મોટા ઓ છે.

1079
00:58:17,100 --> 00:58:20,580
શા માટે અમે તે છે?

1080
00:58:20,580 --> 00:58:24,716
શા બબલ મોટા ઓ એન ચોરસ સૉર્ટ છે?

1081
00:58:24,716 --> 00:58:27,614
>> AUDIENCE: [અશ્રાવ્ય].

1082
00:58:27,614 --> 00:58:35,670
>> LUCAS: અરે વાહ, તેથી સૌથી ખરાબ કિસ્સામાં હશે
કે હું એ iterations કરવું પડશે.

1083
00:58:35,670 --> 00:58:39,260
તેથી iterations દરેક રહ્યું છે
અંતે સૌથી તત્વ લાવે છે

1084
00:58:39,260 --> 00:58:40,290
યાદીમાં.

1085
00:58:40,290 --> 00:58:44,230
તેથી સૌથી ખરાબ કિસ્સામાં હું હોય છે
કે વસ્તુ n વખત કરવું.

1086
00:58:44,230 --> 00:58:48,550
અને તે સમયે દરેક માટે, હું હોય છે
હું સરખાવવા માટે છે કારણ કે એ અદલબદલ કરી

1087
00:58:48,550 --> 00:58:49,870
દરેક બે તત્વો છે.

1088
00:58:49,870 --> 00:58:53,730
તે સ્ક્વેર્ડ n છે તેથી કે શા માટે છે
તે n વખત એ છે કારણ કે.

1089
00:58:53,730 --> 00:59:00,120
>> પછી, પસંદગી સૉર્ટ પણ એ ચોરસ છે
કારણ કે, દરેક ઇટરેશન માટે, હું હોય છે

1090
00:59:00,120 --> 00:59:02,650
દરેક એક તત્વ જોવા
યાદીમાં.

1091
00:59:02,650 --> 00:59:04,980
અને પછી, નાના શોધવા
જે હું હોય છે કે જે થાય છે

1092
00:59:04,980 --> 00:59:06,130
n તત્વોના મારફતે જુઓ.

1093
00:59:06,130 --> 00:59:11,750
અને હું કારણ કે n વખત કરી છે
હું તમામ n તત્વોના પસંદ કરવા માટે હોય છે.

1094
00:59:11,750 --> 00:59:18,273
>> એક નિવેશ પ્રકારની પણ એ ચોરસ છે
સૌથી ખરાબ કેસ દૃશ્ય કરશે કારણ કે

1095
00:59:18,273 --> 00:59:20,950
, એક હોઈ શકે છે, હું દાખલ કરવા માટે હોય છે
એ નંબરો, અધિકાર?

1096
00:59:20,950 --> 00:59:22,765
તેથી હું પહેલેથી જ હું જાઉં છું ખબર છે કે
એ iterations હોય.

1097
00:59:22,765 --> 00:59:25,466

1098
00:59:25,466 --> 00:59:29,840
પરંતુ હું હતો તે નંબરો દરેક માટે, જો
નંબરો તમામ જોવા

1099
00:59:29,840 --> 00:59:34,380
છટણી યાદી અને તે બધી રીતે મૂકી
આ સામે, કે એ ચોરસ હશે

1100
00:59:34,380 --> 00:59:36,230
તે n વખત એ ફરીથી પ્રયત્ન કરશે.

1101
00:59:36,230 --> 00:59:38,280
અર્થમાં બનાવે છે?

1102
00:59:38,280 --> 00:59:41,512
શું ઓમેગા વિશે શું?

1103
00:59:41,512 --> 00:59:42,886
>> AUDIENCE: [અશ્રાવ્ય].

1104
00:59:42,886 --> 00:59:44,620
>> LUCAS: તે શ્રેષ્ઠ કેસ દૃશ્ય છે.

1105
00:59:44,620 --> 00:59:48,810
તેથી તે સમય ઘણો માટે, જેવું છે
શ્રેષ્ઠ કેસ દૃશ્ય છે, સૉર્ટ

1106
00:59:48,810 --> 00:59:50,660
યાદી પહેલેથી સૉર્ટ થાય છે છે.

1107
00:59:50,660 --> 00:59:52,670
તેથી જો તમે ખરેખર નથી
કંઈ પણ કરવા માટે.

1108
00:59:52,670 --> 00:59:56,290
બબલ સૉર્ટ શ્રેષ્ઠ છે
n ના કેસ દૃશ્ય.

1109
00:59:56,290 --> 00:59:58,820
તમે ગાય્સ શા માટે ખબર છે?

1110
00:59:58,820 --> 01:00:00,620
>> AUDIENCE: [અશ્રાવ્ય].

1111
01:00:00,620 --> 01:00:05,640
>> LUCAS: અરે વાહ, તમે સાચવી રાખે તો
માહિતી રેશન કોઈપણ અદલબદલ હતી કે

1112
01:00:05,640 --> 01:00:10,533
તમે કંઈક છે જો નહિં, સુયોજિત જેવા
એક પુનરાવૃત્તિ આ તો ત્યાં તો સાચા

1113
01:00:10,533 --> 01:00:15,140
યાદી પહેલેથી જ, મૂળભૂત રીતે, સૉર્ટ થાય છે
શું ચાલી રહ્યું છે હું જાઉં છું છે

1114
01:00:15,140 --> 01:00:17,890
દરેક બે સ્વેપ કરવાનો પ્રયાસ કરો
અડીને તત્વો છે.

1115
01:00:17,890 --> 01:00:19,920
હું જુઓ કે જાઉં છું
કોઈ અદલબદલ છે.

1116
01:00:19,920 --> 01:00:21,230
અને હું માત્ર અધિકાર દૂર આવો.

1117
01:00:21,230 --> 01:00:24,240
>> તેથી તે હું માત્ર હતી અર્થ એ થાય કે
યાદી એક સમય પસાર થાય છે.

1118
01:00:24,240 --> 01:00:28,990
હું જુઓ, કારણ કે તેથી તે એ છે
n તત્વોના છે.

1119
01:00:28,990 --> 01:00:30,930
શા માટે પસંદગી સૉર્ટ એ ચોરસ?

1120
01:00:30,930 --> 01:00:35,150

1121
01:00:35,150 --> 01:00:45,520
>> અરે વાહ, આ યાદી સૉર્ટ થાય છે, પણ જો માટે
પસંદગી સૉર્ટ દરેક ઇટરેશન, હું

1122
01:00:45,520 --> 01:00:47,590
લઘુત્તમ તત્વ પસંદ કરવા માટે હોય છે.

1123
01:00:47,590 --> 01:00:49,980
જેથી હું જોવા માટે બહાર છે અર્થ એ થાય કે
ક્રમમાંગોઠવાયેલનથી તમામ તત્વો પર

1124
01:00:49,980 --> 01:00:53,350
યાદી અને લઘુત્તમ શોધવા
દરેક ઇટરેશન માટે.

1125
01:00:53,350 --> 01:00:54,600
કે અર્થમાં છે?

1126
01:00:54,600 --> 01:00:56,880

1127
01:00:56,880 --> 01:01:04,690
>> અને નિવેશ તલવાર માં કારણ કે n છે
હું દાખલ કરવા માટે પ્રયાસ કરી રહ્યો છું તે કિસ્સામાં

1128
01:01:04,690 --> 01:01:09,320
નંબરો અને નંબરો તમામ, જ્યારે હું
તેમને દાખલ કરવા માટે પ્રયત્ન કરો, હું તે જુઓ

1129
01:01:09,320 --> 01:01:10,510
યોગ્ય સ્થિતિમાં છે.

1130
01:01:10,510 --> 01:01:15,120
હું તમામ અન્ય તપાસ જાઓ નથી
ક્રમમાંગોઠવાયેલનથી યાદીમાં નંબરો.

1131
01:01:15,120 --> 01:01:17,170
તે એ હશે તેથી કે શા માટે છે.

1132
01:01:17,170 --> 01:01:19,480
અર્થમાં બનાવે છે?

1133
01:01:19,480 --> 01:01:21,035
અને થીટા શું છે?

1134
01:01:21,035 --> 01:01:23,410
>> AUDIENCE: [અશ્રાવ્ય].

1135
01:01:23,410 --> 01:01:24,380
>> LUCAS: શું, માફ કરશો?

1136
01:01:24,380 --> 01:01:24,960
તેને ફરીથી કહો.

1137
01:01:24,960 --> 01:01:25,666
>> AUDIENCE: [અશ્રાવ્ય].

1138
01:01:25,666 --> 01:01:26,490
>> LUCAS: ચોક્કસ.

1139
01:01:26,490 --> 01:01:31,280
તેથી તમે તે માત્ર પસંદગી જોઈ શકો છો
મર્જ કરો માં સ્ટોર પ્રકારની thetas છે.

1140
01:01:31,280 --> 01:01:39,920
તમે માત્ર થીટા છે કારણ કે અને તે છે
મોટા ઓ અને ઓમેગા બંને એક જ હોય ​​તો.

1141
01:01:39,920 --> 01:01:41,520
બરાબર.

1142
01:01:41,520 --> 01:01:44,210
અને છેલ્લે, લોગ n માં પ્રકારની છે મર્જ.

1143
01:01:44,210 --> 01:01:48,910
>> ડેન કહે હતી અને પછી,, સૉર્ટ મર્જ કરો
પ્રકારની એ જ રીતે જેમ કે

1144
01:01:48,910 --> 01:01:50,320
તમે બાઈનરી શોધ કરી.

1145
01:01:50,320 --> 01:01:53,530
તેથી જો તમે યાદીમાંથી છે.

1146
01:01:53,530 --> 01:01:55,170
અને તમે અડધા કાપી રહ્યા છીએ.

1147
01:01:55,170 --> 01:02:00,580
અને પછી તમે તેમને કાપી
નાના છિદ્ર માં.

1148
01:02:00,580 --> 01:02:01,730
અને પછી તમે તેમને મર્જ.

1149
01:02:01,730 --> 01:02:02,960
તમે ગાય્સ અધિકાર, યાદ રાખો કે?

1150
01:02:02,960 --> 01:02:04,960
ઠીક છે, તે કહે છે હતી.

1151
01:02:04,960 --> 01:02:08,330
>> ઠીક છે, પોઇન્ટર.

1152
01:02:08,330 --> 01:02:11,078
તેથી નિર્દેશક શું છે?

1153
01:02:11,078 --> 01:02:12,050
>> AUDIENCE: [અશ્રાવ્ય].

1154
01:02:12,050 --> 01:02:12,820
>> LUCAS: એક સરનામું.

1155
01:02:12,820 --> 01:02:13,720
બરાબર.

1156
01:02:13,720 --> 01:02:18,530
હું ડેવિડ એક ટોળું છે ખબર છે કે
Binky વિડિઓઝ અને વસ્તુઓ તરફ પોઇન્ટ

1157
01:02:18,530 --> 01:02:19,080
દરેક અન્ય.

1158
01:02:19,080 --> 01:02:22,960
પરંતુ હું પોઇન્ટર લાગે ગમે છે
માત્ર એક સરનામું છે.

1159
01:02:22,960 --> 01:02:26,110
તેથી તે ચાલે છે કે એક ચલ છે
એક સરનામું સંગ્રહવા માટે.

1160
01:02:26,110 --> 01:02:31,940
>> તેથી તે માત્ર આ ખાસ ચલ છે
ચાર બાઇટ્સ લાંબી છે.

1161
01:02:31,940 --> 01:02:36,550
કંઈપણ કે નિર્દેશક છે યાદ રાખો,
અમારા 32-bit માટે લાંબા હંમેશા ચાર બાઇટ્સ

1162
01:02:36,550 --> 01:02:39,370
મશીન કેસ સાથે
સાધન.

1163
01:02:39,370 --> 01:02:41,920

1164
01:02:41,920 --> 01:02:47,050
અને તે માત્ર આ સ્થાન ધરાવે છે
તે અંદર એક ચલ.

1165
01:02:47,050 --> 01:02:50,240
>> ઠીક છે, તેથી મૂળભૂત રીતે, આ મેમરી છે.

1166
01:02:50,240 --> 01:02:57,420
તેથી મેમરી દરેક બ્લોક ખરેખર એક
આ સરનામું છે કે જે લેબલ,

1167
01:02:57,420 --> 01:02:58,890
slotty મેમરી.

1168
01:02:58,890 --> 01:03:02,370
જેથી હું કરી શકે છે કે જે થાય છે
માટે નિર્દેશક પોઇન્ટ

1169
01:03:02,370 --> 01:03:03,380
આ સરનામાઓ કોઇ.

1170
01:03:03,380 --> 01:03:09,930
તેથી અમે પોઇંટરો ઉપયોગ કરશો કારણ છે
હું સ્થાન યાદ છે જો

1171
01:03:09,930 --> 01:03:12,300
કે ચોક્કસ ચલ મેમરી છે.

1172
01:03:12,300 --> 01:03:16,560
>> અને તમે ગાય્સ યાદ તે એક છે કે જે
હું એક કાર્ય છે જો કિસ્સાઓમાં હતી

1173
01:03:16,560 --> 01:03:20,820
હું ખરેખર હોય તો માટે તમે કરવા માંગો છો
reals માટે સ્વેપ, હું ખરેખર

1174
01:03:20,820 --> 01:03:22,110
નિર્દેશક મોકલી છે.

1175
01:03:22,110 --> 01:03:23,460
નથી ચલ.

1176
01:03:23,460 --> 01:03:25,200
તમે ગાય્સ કે યાદ છે?

1177
01:03:25,200 --> 01:03:26,450
આ તફાવત between--

1178
01:03:26,450 --> 01:03:33,350

1179
01:03:33,350 --> 01:03:34,120
નામ શું છે?

1180
01:03:34,120 --> 01:03:36,010
કિંમત અને ફોન કરીને કૉલ
સંદર્ભ દ્વારા, અધિકાર?

1181
01:03:36,010 --> 01:03:36,840
>> હા, બરાબર.

1182
01:03:36,840 --> 01:03:38,330
તેથી કિંમત દ્વારા ફોન કરો.

1183
01:03:38,330 --> 01:03:43,570
તમે માત્ર એક ચલ માટે મોકલી ત્યારે
તમે માત્ર એક કિંમત મોકલી રહ્યાં છો કામ.

1184
01:03:43,570 --> 01:03:45,610
તેથી જો તમે ખરેખર મોકલી રહ્યાં છો
ચલ એક નકલ.

1185
01:03:45,610 --> 01:03:49,720
અને તમારા કાર્યક્રમ ઓછી કાળજી શક્યા નથી
ખરેખર જ ચલ તો વિશે

1186
01:03:49,720 --> 01:03:51,650
નકલ બનાવે છે.

1187
01:03:51,650 --> 01:03:56,330
>> અને સંદર્ભ અર્થ એ થાય કે દ્વારા ફોન
હું ખરેખર આ એક નકલ મોકલી રહ્યો છું

1188
01:03:56,330 --> 01:03:57,550
કે ચલ માટે નિર્દેશક.

1189
01:03:57,550 --> 01:04:00,970
તેથી તે હું મોકલી રહ્યો છું કે જે થાય છે
કે ચલ સ્થાન.

1190
01:04:00,970 --> 01:04:04,440
તેથી હું સ્થાન છે સુઝ
ચલ, હું કહી જ્યારે કાર્ય

1191
01:04:04,440 --> 01:04:09,700
પોઇન્ટર સાથે, હું ખરેખર કરવા માટે સક્ષમ છું
મુખ્ય હતું કે ડેટા બદલો.

1192
01:04:09,700 --> 01:04:12,050
અર્થમાં બનાવે છે?

1193
01:04:12,050 --> 01:04:17,560
>> તેમ છતાં, નિર્દેશક એક નકલ છે
નિર્દેશક હજુ ના વાસ્તવિક સરનામું છે

1194
01:04:17,560 --> 01:04:20,090
હું બદલવા માંગો છો તે ચલ.

1195
01:04:20,090 --> 01:04:21,920
અર્થમાં બનાવે છે?

1196
01:04:21,920 --> 01:04:24,290
>> તેથી પોઇન્ટર બનાવવા.

1197
01:04:24,290 --> 01:04:28,410
હંમેશા નિર્દેશક હોય છે, યાદ રાખો
તે પોઇન્ટ છે કે પ્રકાર

1198
01:04:28,410 --> 01:04:29,890
એક તારો છે અને પછી.

1199
01:04:29,890 --> 01:04:31,030
અને પછી તમે નામ મૂકે છે.

1200
01:04:31,030 --> 01:04:35,765
તેથી તમારી પાસે જ્યારે પણ યાદ રાખો કે
ગમે સ્ટાર, તે માટે નિર્દેશક જેવું છે

1201
01:04:35,765 --> 01:04:38,990
ગમે ચલ કે
તમે હતું કે લખો.

1202
01:04:38,990 --> 01:04:42,850
>> અહીં સ્ટાર માં, ઉદાહરણ તરીકે, તે છે
નિર્દેશક અને પૂર્ણાંક.

1203
01:04:42,850 --> 01:04:47,680
અને પછી ચાર સ્ટાર નિર્દેશક છે
ચાર સ્ટાર અને તેથી આગળ.

1204
01:04:47,680 --> 01:04:47,960
અરે વાહ?

1205
01:04:47,960 --> 01:04:52,710
>> પ્રેક્ષક: શું અમે હોય તો એક
એ માટે નિર્દેશક એક્સ સ્ટાર.

1206
01:04:52,710 --> 01:04:55,255
હું એક્સ માટે નિર્દેશક બનાવે છે.

1207
01:04:55,255 --> 01:04:59,432
તે પણ એક પૂર્ણાંક એક્સ જાહેર કરે છે?

1208
01:04:59,432 --> 01:05:05,170
>> LUCAS: ઠીક છે, તેથી તમે એ સ્ટાર એક્સ કહે છે,
તમે માટે નિર્દેશક બનાવવા નથી

1209
01:05:05,170 --> 01:05:06,000
ચલ x.

1210
01:05:06,000 --> 01:05:08,170
તમે એક્સ નામના નિર્દેશક બનાવી રહ્યા છો.

1211
01:05:08,170 --> 01:05:09,396
>> AUDIENCE: [અશ્રાવ્ય].

1212
01:05:09,396 --> 01:05:14,250
>> LUCAS: હું એ સ્ટાર એક્સ કહે તેથી, જ્યારે હું છું
હેય, મેમરી, હું જાઉં છું, કહે છે

1213
01:05:14,250 --> 01:05:16,390
આ ત્રણ બોક્સ એક વિચાર.

1214
01:05:16,390 --> 01:05:20,750
અને હું કે કહે છે કે જાઉં છું
છે, કે જે એક્સ હોઈ ચાલે છે

1215
01:05:20,750 --> 01:05:22,000
જઈને એક નિર્દેશક છે.

1216
01:05:22,000 --> 01:05:26,860

1217
01:05:26,860 --> 01:05:30,640
અને પોઇંટરો વિશે કંઈક રસપ્રદ
અમે તેઓ કહે છે કે છે

1218
01:05:30,640 --> 01:05:32,620
એક મશીન 32-bit માટે 4 બાઇટ્સ.

1219
01:05:32,620 --> 01:05:36,320
અને તે માટે કારણ છે કારણ કે છે
4 બાઇટ્સ 32-બિટ્સ છે.

1220
01:05:36,320 --> 01:05:40,490
>> 64 બિટ્સ ખરેખર છે અને મશીનો
પોઇન્ટર સરનામાં છે

1221
01:05:40,490 --> 01:05:43,480
64 બિટ્સ લાંબા છે.

1222
01:05:43,480 --> 01:05:49,820
તેથી તે માત્ર અર્થ એ થાય કે માપ
મશીન માં સરનામાં અલગ છે.

1223
01:05:49,820 --> 01:05:52,270
>> તેથી સંદર્ભ અને Dereferencing.

1224
01:05:52,270 --> 01:05:54,310
બે ઓપરેટરો છે કે
તમે ગાય્સ યાદ રાખવું જોઈએ.

1225
01:05:54,310 --> 01:05:55,450
પ્રથમ 'ચિન્હ છે.

1226
01:05:55,450 --> 01:05:56,810
બીજા સ્ટાર છે.

1227
01:05:56,810 --> 01:06:05,060
કે સ્ટાર અને આ દ્વારા ગુંચવણ ના થવી નથી
કારણ કે, તે યાદ સ્ટાર

1228
01:06:05,060 --> 01:06:06,950
આ કિસ્સામાં, તમે એ સ્ટાર છે.

1229
01:06:06,950 --> 01:06:08,700
>> તે એક સાથે એક સંપૂર્ણ વસ્તુ જેવું છે.

1230
01:06:08,700 --> 01:06:10,720
કોઈ એ જગ્યા સ્ટાર છે.

1231
01:06:10,720 --> 01:06:12,070
તેથી તે પ્રકાર છે કે જે થાય છે.

1232
01:06:12,070 --> 01:06:14,870
તમારી પાસે જ્યારે કે યાદ રાખો,
ચલ સ્ટાર, તમે છો

1233
01:06:14,870 --> 01:06:16,230
પ્રકાર વિશે વાત.

1234
01:06:16,230 --> 01:06:20,540
>> તમે પછી માત્ર સ્ટાર અને હોય
ચલની નામ, તે અર્થ એ થાય કે

1235
01:06:20,540 --> 01:06:24,100
તમે નિર્દેશક, dereferencing કરી રહ્યાં છો કે જે
તમે જોઈ રહ્યાં છો કે જે થાય છે

1236
01:06:24,100 --> 01:06:28,290
નિર્દેશક, સરનામાં શોધવા તે
, માટે પોઇન્ટ કે સરનામા માટે જતા,

1237
01:06:28,290 --> 01:06:30,850
અને જ્યારે જોઈ
તમે ત્યાં છે.

1238
01:06:30,850 --> 01:06:34,310
તેથી હું તમારી પાસે જ્યારે કે મારા વિદ્યાર્થીઓ કહી
સ્ટાર, તો તમે તેને લાગે છે કે જોઈએ

1239
01:06:34,310 --> 01:06:36,850
સામગ્રી ના સંક્ષેપ.

1240
01:06:36,850 --> 01:06:39,770
>> તમે એક નિર્દેશક હોય તો અને તમે
સ્ટાર નિર્દેશક કરવું, તે છે

1241
01:06:39,770 --> 01:06:41,720
નિર્દેશક સામગ્રી.

1242
01:06:41,720 --> 01:06:44,580
તેથી જો તમે તે પોઇન્ટ છે ગમે પર જાઓ
અને સતત સામગ્રી જુઓ.

1243
01:06:44,580 --> 01:06:47,730
અને 'ચિન્હ જ છે
સરનામું તરીકે વસ્તુ.

1244
01:06:47,730 --> 01:06:52,560
>> હું જેવી તેવી ચલ હોય તો તેથી, ચાલો
પૂર્ણાંક એક બરાબર હું હતી કહે છે કે 3

1245
01:06:52,560 --> 01:06:56,900
હું કે ના સરનામા શોધવા માંગો છો
ચલ મેમરી, હું હમણાં જ કરી શકો છો

1246
01:06:56,900 --> 01:06:58,240
એક 'નું ચિહ્ન.

1247
01:06:58,240 --> 01:07:00,280
તેથી તે એક સરનામું છે.

1248
01:07:00,280 --> 01:07:01,530
અર્થમાં બનાવે છે?

1249
01:07:01,530 --> 01:07:03,790

1250
01:07:03,790 --> 01:07:05,040
>> અહીં એક ઉદાહરણ છે.

1251
01:07:05,040 --> 01:07:08,370

1252
01:07:08,370 --> 01:07:11,530
આ પૂર્ણાંક બી અને પૂર્ણાંક સી ખૂટે છે.

1253
01:07:11,530 --> 01:07:16,520
3 અર્થ બરાબર પૂર્ણાંક જેથી
હું મેમરી પર જાઓ જાઉં છું.

1254
01:07:16,520 --> 01:07:19,870
અને હું એક સ્લોટ શોધવા જાઉં છું
અને અહીં નંબર 3 મૂકો.

1255
01:07:19,870 --> 01:07:22,200
>> અને પછી પૂર્ણાંક બી 4 સમકક્ષ હોય છે.

1256
01:07:22,200 --> 01:07:23,100
હું એ જ વસ્તુ કરવા જાઉં છું.

1257
01:07:23,100 --> 01:07:25,840
મેમરી પર જાઓ અને એક નંબર મૂકી
બોક્સ એક 4.

1258
01:07:25,840 --> 01:07:27,100
અને પૂર્ણાંક 5 સમકક્ષ હોય છે.

1259
01:07:27,100 --> 01:07:29,740
અન્ય બોક્સ શોધો અને સંખ્યાબંધ 5 મૂકો.

1260
01:07:29,740 --> 01:07:36,160
>> તેથી બહાર કરી આ વાક્ય શું છે?
એ સ્ટાર PA 'ચિન્હ એક સમકક્ષ હોય છે.

1261
01:07:36,160 --> 01:07:37,800
તેથી સૌ પ્રથમ, એ સ્ટાર PA.

1262
01:07:37,800 --> 01:07:39,050
તે શું કરી રહ્યા છે?

1263
01:07:39,050 --> 01:07:40,930

1264
01:07:40,930 --> 01:07:42,298
>> AUDIENCE: [અશ્રાવ્ય].

1265
01:07:42,298 --> 01:07:47,890
>> LUCAS: અરે વાહ, તેથી એ સ્ટાર PA, પ્રથમ,
PA કહેવાય નિર્દેશક જાહેર.

1266
01:07:47,890 --> 01:07:53,720
અને પછી તે ની કિંમત સોંપણી છે
કે નિર્દેશક એક ની સરનામું છે.

1267
01:07:53,720 --> 01:07:55,790
તેથી 'નું ચિહ્ન.

1268
01:07:55,790 --> 01:07:58,510
પછી, હું સ્ટાર PB કરો તો,
એક તારો PB શું છે?

1269
01:07:58,510 --> 01:08:02,418

1270
01:08:02,418 --> 01:08:03,150
>> ઓહ, માફ કરશો.

1271
01:08:03,150 --> 01:08:06,330
આ પણ ખૂટે છે. એ સ્ટાર PB.

1272
01:08:06,330 --> 01:08:07,905
હું સ્ટાર પીસી થાય છે.

1273
01:08:07,905 --> 01:08:11,200
હું દિલગીર છું.

1274
01:08:11,200 --> 01:08:11,940
તે જ વાત છે.

1275
01:08:11,940 --> 01:08:16,408
પરંતુ હવે હું એક નિર્દેશક બનાવવા AR સારી છું
પછી સી માટે નિર્દેશક બી અને છે.

1276
01:08:16,408 --> 01:08:16,886
અરે વાહ?

1277
01:08:16,886 --> 01:08:18,136
>> AUDIENCE: [અશ્રાવ્ય]?

1278
01:08:18,136 --> 01:08:25,490

1279
01:08:25,490 --> 01:08:26,670
>> LUCAS: હા.

1280
01:08:26,670 --> 01:08:32,630
તેથી જો તમે મેમરી માટે જાઓ અને તમે પર જાઓ જો
PA માટે સંજ્ઞાપક છે કે બોક્સ,

1281
01:08:32,630 --> 01:08:37,149
તમે ખરેખર રહ્યા છીએ
એક ની એક સરનામું જુઓ.

1282
01:08:37,149 --> 01:08:38,399
બરાબર?

1283
01:08:38,399 --> 01:08:42,970

1284
01:08:42,970 --> 01:08:43,300
અરે વાહ?

1285
01:08:43,300 --> 01:08:45,605
>> AUDIENCE: [અશ્રાવ્ય]?

1286
01:08:45,605 --> 01:08:49,260
>> LUCAS: અરે વાહ, નિર્દેશક એક સરનામું છે.

1287
01:08:49,260 --> 01:08:50,120
કે ક્યારેય ભૂલશો નહીં.

1288
01:08:50,120 --> 01:08:52,800
તે સૌથી મહત્વપૂર્ણ જેવું છે
પોઇન્ટર વિશે ભાગ છે.

1289
01:08:52,800 --> 01:08:56,180
સંગ્રહ અને સરનામું છે
કેટલાક ચલ છે.

1290
01:08:56,180 --> 01:08:56,890
બીજું કંઈપણ?

1291
01:08:56,890 --> 01:08:58,370
કોઈપણ અન્ય પ્રશ્નો છે?

1292
01:08:58,370 --> 01:08:59,189
બરાબર.

1293
01:08:59,189 --> 01:09:00,399
>> તેથી પોઇન્ટર અને એરે.

1294
01:09:00,399 --> 01:09:08,189
યાદ રાખો કે હું એરે 3 પૂર્ણાંક શું છે,
મૂળભૂત રીતે, હું શું કરી રહ્યો છું હું પ્રકારની, છું છે

1295
01:09:08,189 --> 01:09:12,779
ના, એક નિર્દેશક માં જાહેર.

1296
01:09:12,779 --> 01:09:18,960
તેથી એરે પ્રકારની માટે નિર્દેશક જેવી છે
મેમરી ચોક્કસ સ્થળ કે જેમાં હું

1297
01:09:18,960 --> 01:09:21,999
પૂર્ણાંકો માટે ત્રણ સ્લોટ ફાળવવામાં.

1298
01:09:21,999 --> 01:09:23,430
કે અર્થમાં છે?

1299
01:09:23,430 --> 01:09:30,250
>> હું પૂર્ણાંક એરે 3 જ્યારે તેથી, હું શું છું
કરી, મૂળભૂત રીતે, ત્રણ રહ્યા છે

1300
01:09:30,250 --> 01:09:31,479
મેમરી સ્લોટ.

1301
01:09:31,479 --> 01:09:33,899
તેથી હું માત્ર મેમરી ત્રણ સ્લોટ શોધો.

1302
01:09:33,899 --> 01:09:38,810
તેથી હું પછી, એક તારો એરે, તે કરો તો
મૂળભૂત રીતે એરે સામગ્રી અર્થ થાય છે,

1303
01:09:38,810 --> 01:09:46,180
જે હું જાઓ, હું નિર્દેશક ભૂંસી અર્થ એ થાય
તે પોઇન્ટ છે કે જે જગ્યા છે,

1304
01:09:46,180 --> 01:09:47,939
અને હું નંબર એક મૂકો.

1305
01:09:47,939 --> 01:09:53,729
>> અને પછી, હું સ્ટાર એરે વત્તા 1 કરો તો,
કે એરે કરી તરીકે જ વાત છે

1306
01:09:53,729 --> 01:09:59,690
માત્ર હું પર જાઓ, જેનો અર્થ છે એક કૌંસ
તે તરફ સંકેત છે કે આ સ્થળ.

1307
01:09:59,690 --> 01:10:03,000
અને પછી વત્તા 1 બનાવે
મને એક પદ પાળી.

1308
01:10:03,000 --> 01:10:06,510
તેથી હું ખરેખર આ સ્થિતિ પર જાઓ
અને બે નંબર મૂકો.

1309
01:10:06,510 --> 01:10:10,900
>> અને પછી, છેવટે, હું જ્યારે કરવું
એરે વત્તા 2, હું જ્યાં પર જાઓ

1310
01:10:10,900 --> 01:10:11,825
પર એરે માતાનો પોઇન્ટ.

1311
01:10:11,825 --> 01:10:14,690
અને પછી હું મેમરી બ્લોકો ખસેડવા.

1312
01:10:14,690 --> 01:10:16,240
અને પછી હું અહીં સંખ્યા ત્રણ મૂકો.

1313
01:10:16,240 --> 01:10:16,600
અરે વાહ?

1314
01:10:16,600 --> 01:10:21,400
>> પ્રેક્ષક: તેથી સ્ટાર એરે ખાલી છે
ખૂબ પ્રથમ બિંદુ કહે.

1315
01:10:21,400 --> 01:10:25,090
અને તમે માત્ર કારણ કે, 1 ઉમેરી શકો છો
અમે માત્ર ખરેખર છો

1316
01:10:25,090 --> 01:10:27,295
કે પ્રથમ સરનામું સંદર્ભ.

1317
01:10:27,295 --> 01:10:28,545
>> LUCAS: અરે વાહ.

1318
01:10:28,545 --> 01:10:32,720

1319
01:10:32,720 --> 01:10:36,020
આપણે શા માટે, ઉદાહરણ તરીકે, એરે કહે છે
0, એરે 1, અને એરે 2?

1320
01:10:36,020 --> 01:10:38,970

1321
01:10:38,970 --> 01:10:42,790
હું શા માટે તમે 0 કરવું, કહી રહ્યો છું
1, 2, 3 ને બદલે 1, 2, 3?

1322
01:10:42,790 --> 01:10:46,550
એક કારણો છે, એક, કોમ્પ્યુટર છે
પ્રોગ્રામરો શરૂ પસંદ કરે છે

1323
01:10:46,550 --> 01:10:47,750
0 થી ગણતરી.

1324
01:10:47,750 --> 01:10:52,370
તમે એરે 0 કરવું કારણ કે જ્યારે બે છે
તે એરે કરી તરીકે જ વાત છે

1325
01:10:52,370 --> 01:10:56,330
એટલે કે વત્તા 0, હું પર જાઓ
તે સ્થિતિમાં, અને હું નથી

1326
01:10:56,330 --> 01:10:59,320
કોઈપણ મેમરી બ્લોક્સ અવગણો.

1327
01:10:59,320 --> 01:11:01,750
તેથી હું કોઇ મેમરી બ્લોકો ખસેડવા નથી.

1328
01:11:01,750 --> 01:11:02,015
અરે વાહ?

1329
01:11:02,015 --> 01:11:03,265
>> AUDIENCE: [અશ્રાવ્ય]?

1330
01:11:03,265 --> 01:11:05,928

1331
01:11:05,928 --> 01:11:12,670
>> LUCAS: તેથી તે શું છે પૂછવા છે
કરી વચ્ચે તફાવત

1332
01:11:12,670 --> 01:11:14,000
આ કે malloc કરી.

1333
01:11:14,000 --> 01:11:17,550
તફાવત એ છે કે છે
પૂર્ણાંક એરે 3 એક બનાવવા છે

1334
01:11:17,550 --> 01:11:19,260
સ્ટેક પર એરે.

1335
01:11:19,260 --> 01:11:23,080
અને હું malloc શું છે, તે
ઢગલો પર બનાવે છે.

1336
01:11:23,080 --> 01:11:25,250
કે અર્થમાં છે?

1337
01:11:25,250 --> 01:11:28,870
>> આમ કેવી રીતે malloc ખરેખર કામ કરે છે?

1338
01:11:28,870 --> 01:11:32,245
તેથી શા માટે અમે પણ malloc વાપરવા માટે જરૂરી છે?

1339
01:11:32,245 --> 01:11:35,730

1340
01:11:35,730 --> 01:11:39,700
આધાર તમારા કમ્પાઇલર પ્રકારની બહાર બધા
તમે જાહેર કે ચલો.

1341
01:11:39,700 --> 01:11:44,040
અને તે બધા માટે જગ્યા બનાવે છે
સ્ટેક તેમને.

1342
01:11:44,040 --> 01:11:47,180
તેથી તમારા ચલો બધા જતા હોય છે
ક્યાંક સ્ટેક માં છે.

1343
01:11:47,180 --> 01:11:49,460
અહીં પર્યાવરણ ચલો છે.

1344
01:11:49,460 --> 01:11:53,850
>> તે ચલો માટે જેથી મૂળભૂત, જગ્યા
મેમરી પર ફાળવવામાં આવે છે

1345
01:11:53,850 --> 01:11:55,080
સમય કમ્પાઇલ.

1346
01:11:55,080 --> 01:11:58,790
તેથી તે તમારા કમ્પ્યુટર છે કે જે થાય છે
તે ચલો તમામ ખબર

1347
01:11:58,790 --> 01:11:59,790
અગાઉથી.

1348
01:11:59,790 --> 01:12:02,500
તે શું કિંમત ખબર જરૂર નથી
તમે તેમને મૂકવા જઈ રહ્યાં છો.

1349
01:12:02,500 --> 01:12:05,490
પરંતુ તે કેવી રીતે કરવાની જરૂર છે
તમે જરૂર બધી મેમરીનો.

1350
01:12:05,490 --> 01:12:09,380
>> પરંતુ હવે, ચાલો, ઉદાહરણ તરીકે, કહે છે કે દો
તમે એક એરે બનાવવા અથવા એક લઇ રહ્યા છીએ

1351
01:12:09,380 --> 01:12:13,430
તમે લઈ રહ્યા છો તે શબ્દમાળા
વપરાશકર્તા માંથી.

1352
01:12:13,430 --> 01:12:17,300
તમે જાણતા નથી કે કેવી રીતે લાંબા શબ્દમાળા
ઉદાહરણ તરીકે, કરી રહ્યું છે.

1353
01:12:17,300 --> 01:12:20,600
તેથી જો તમે ચોક્કસ કેટલી ખબર નથી
મેમરી બ્લોક્સ તમે, ફાળવવા?

1354
01:12:20,600 --> 01:12:24,120
>> તેથી તે ખરેખર માટે અર્થમાં નથી
તમે 100 અક્ષરો મૂકી કહે છે.

1355
01:12:24,120 --> 01:12:26,420
અને પછી વપરાશકર્તા 150 લખે શું છે?

1356
01:12:26,420 --> 01:12:27,670
તમે ખરાબ કરી રહ્યા છીએ.

1357
01:12:27,670 --> 01:12:30,160

1358
01:12:30,160 --> 01:12:34,620
>> જેથી મૂળભૂત છે, તમે કેવી રીતે ખાતરી કરી શકાતી નથી
તમે ફાળવણી કરવાની જરૂર બધી મેમરીનો

1359
01:12:34,620 --> 01:12:35,960
જ્યારે તમે કાર્યક્રમ કમ્પાઇલ.

1360
01:12:35,960 --> 01:12:38,240
તમે માત્ર સ્કોર સમય પર છો.

1361
01:12:38,240 --> 01:12:39,950
તમે ઢગલો છે તેથી કે શા માટે છે.

1362
01:12:39,950 --> 01:12:47,610
તેથી આ ઢગલો મેમરી હોય રહ્યું છે
તમે દરમિયાન ફાળવણી રહ્યાં છો

1363
01:12:47,610 --> 01:12:50,810
કાર્યક્રમ ચાલી સમયગાળો.

1364
01:12:50,810 --> 01:12:55,780
>> તેથી મૂળભૂત રીતે, તમે malloc શું છે, શું
તમે મેમરી ફાળવણી છે કરી રહ્યા છીએ

1365
01:12:55,780 --> 01:13:00,160
તમે છો, એટલે કે રનટાઇમ,
કે તે સમયે યોગ્ય નિર્ણય કે તમે

1366
01:13:00,160 --> 01:13:02,670
કે મેમરી હોવી જોઇએ.

1367
01:13:02,670 --> 01:13:04,210
તમે તેને ફાળવણી કરી રહ્યા હો ત્યારે તેથી તે છે.

1368
01:13:04,210 --> 01:13:06,430
કે અર્થમાં છે?

1369
01:13:06,430 --> 01:13:11,690
>> તેથી સ્ટેક ચલો છે, યાદ
કે કમ્પાઇલ સમય પર બનાવવામાં આવે છે.

1370
01:13:11,690 --> 01:13:14,560
અને પછી ઢગલો ચલો છે
તમે જાઓ તરીકે બનાવવામાં આવે છે

1371
01:13:14,560 --> 01:13:15,600
ઉદાહરણ તરીકે malloc સાથે.

1372
01:13:15,600 --> 01:13:16,850
>> AUDIENCE: [અશ્રાવ્ય]?

1373
01:13:16,850 --> 01:13:19,179

1374
01:13:19,179 --> 01:13:24,340
>> LUCAS: તેથી GetString છે
malloc કહી રહ્યા.

1375
01:13:24,340 --> 01:13:26,710
મને malloc વિશે વાત કરો, અને
હું GetString સમજાવવું પડશે.

1376
01:13:26,710 --> 01:13:32,000
તેથી malloc આ જ વાત છે
મેમરી ફાળવણી છે.

1377
01:13:32,000 --> 01:13:34,600
તેથી તે ફાળવણી બનશે
ઢગલો પર મેમરી.

1378
01:13:34,600 --> 01:13:40,010
અને તે માટે નિર્દેશક પરત ચાલી રહ્યું છે
જ્યાં કે મેમરી ની ફાળવણી કરવામાં આવી હતી.

1379
01:13:40,010 --> 01:13:43,090
>> તેથી જો તમે કરવું જ્યારે

1380
01:13:43,090 --> 01:13:44,910
અહીં ઉદાહરણ માટે

1381
01:13:44,910 --> 01:13:45,830
એ સ્ટાર નિર્દેશક.

1382
01:13:45,830 --> 01:13:50,520
અને પછી નિર્દેશક malloc બરાબર
ઇંચ ગુણ્યા 10 ની માપ.

1383
01:13:50,520 --> 01:13:52,110
હું એક નિર્દેશક બનાવવા છું.

1384
01:13:52,110 --> 01:13:59,020
અને પછી હું કે નિર્દેશક સોંપણી છું
નિર્દેશક કે malloc ની કિંમત

1385
01:13:59,020 --> 01:13:59,680
મને આપે છે.

1386
01:13:59,680 --> 01:14:04,150
>> તેથી હું પૂછવા છું malloc તમે સ્થાપિત કરી શકે છે
10 પૂર્ણાંકો માટે જગ્યા.

1387
01:14:04,150 --> 01:14:05,390
તે કહે છે તે છે.

1388
01:14:05,390 --> 01:14:09,020
અને malloc મને પાછા આપે છે એક
કે સ્થળ પર નિર્દેશક.

1389
01:14:09,020 --> 01:14:11,460
અર્થમાં બનાવે છે?

1390
01:14:11,460 --> 01:14:12,270
બરાબર.

1391
01:14:12,270 --> 01:14:17,940
હું અને GetString, મૂળભૂત રીતે, એક કરી છે
તમે ફાળવી શકો છો જેથી malloc માટે કૉલ

1392
01:14:17,940 --> 01:14:21,680
રનટાઈમ દરમિયાન મેમરી.

1393
01:14:21,680 --> 01:14:26,460
>> હંમેશા નલ ચકાસવા માટે યાદ
malloc નલ પાછા જઈ રહ્યું છે, કારણ કે

1394
01:14:26,460 --> 01:14:28,200
તે મેમરી ફાળવણી કરી શકે નહિં.

1395
01:14:28,200 --> 01:14:31,660
માતાનો તમે હાસ્યાસ્પદ માટે પૂછો કે કહો
મેમરી રકમ.

1396
01:14:31,660 --> 01:14:33,950
તમારા કમ્પ્યુટર નથી ચાલી રહ્યું છે
ખૂબ કે ફાળવવા માટે સક્ષમ.

1397
01:14:33,950 --> 01:14:36,410
>> તેથી malloc માત્ર રહ્યું છે
નલ પરત.

1398
01:14:36,410 --> 01:14:42,210
તેથી હંમેશા તે ચકાસવા માટે યાદ
તમે malloc તરફથી મળી કે નિર્દેશક છે

1399
01:14:42,210 --> 01:14:45,640
નલ કે નહીં તે હોય, તો તમે કદાચ, કારણ કે
નિર્દેશક dereferencing કરી અને

1400
01:14:45,640 --> 01:14:48,340
બાજુ ખામી કારણ.

1401
01:14:48,340 --> 01:14:50,930
અને છેલ્લે, ભૂલશો નહીં
તમારા મફત મેમરી.

1402
01:14:50,930 --> 01:14:57,800

1403
01:14:57,800 --> 01:15:00,560
>> Malloc ઢગલો મેમરી રહ્યા છે.

1404
01:15:00,560 --> 01:15:03,436
અને તમે મેમરી મુક્ત છે
કાર્યક્રમ પૂર્ણ થાય છે પહેલાં.

1405
01:15:03,436 --> 01:15:05,370
ઠીક છે, તે મારા માટે બધા છે.

1406
01:15:05,370 --> 01:15:07,900
માફ કરશો, રોબ.

1407
01:15:07,900 --> 01:15:07,950
આભાર.

1408
01:15:07,950 --> 01:15:09,878
>> [વધાવી]

1409
01:15:09,878 --> 01:15:12,679
>> LUCAS: કોઈપણ છેલ્લા પ્રશ્નો
રોબ આવે તે પહેલાં?

1410
01:15:12,679 --> 01:15:13,138
કોઈ?

1411
01:15:13,138 --> 01:15:13,597
અરે વાહ?

1412
01:15:13,597 --> 01:15:15,892
>> પ્રેક્ષક: હું જોઈ ન હતી
આ એક ઓનલાઇન.

1413
01:15:15,892 --> 01:15:17,269
તમે હજુ સુધી તે અપલોડ છે?

1414
01:15:17,269 --> 01:15:19,106
>> LUCAS: હું ડેવ છે
ટૂંક સમયમાં તે અપલોડ.

1415
01:15:19,106 --> 01:15:19,880
>> ડેવ: તે પોસ્ટ કરવામાં આવશે.

1416
01:15:19,880 --> 01:15:20,310
>> LUCAS: તે ઓનલાઇન હશો.

1417
01:15:20,310 --> 01:15:21,175
>> પ્રેક્ષક: તે કરો.

1418
01:15:21,175 --> 01:15:22,090
>> LUCAS: તે છે?

1419
01:15:22,090 --> 01:15:23,157
બરાબર.

1420
01:15:23,157 --> 01:15:23,644
અરે વાહ?

1421
01:15:23,644 --> 01:15:27,053
>> AUDIENCE: [અશ્રાવ્ય]?

1422
01:15:27,053 --> 01:15:30,285
>> LUCAS: હા, તમે મુક્ત કરીશું તમામ
ઢગલો મૂકી છે કે મેમરી.

1423
01:15:30,285 --> 01:15:31,535
>> AUDIENCE: [અશ્રાવ્ય]?

1424
01:15:31,535 --> 01:15:34,518

1425
01:15:34,518 --> 01:15:36,160
>> LUCAS: હા.

1426
01:15:36,160 --> 01:15:39,980
તમે એક સંસ્કૃતિ malloc છે કે કોઈપણ સમયે,
તમે મફત એક સંસ્કૃતિ હોવા જોઈએ

1427
01:15:39,980 --> 01:15:42,640
તમે પછી કે ચલ ઉપયોગ કરવાનું બંધ.

1428
01:15:42,640 --> 01:15:44,800
તેથી malloc અને મફત છે
હંમેશા સાથે.

1429
01:15:44,800 --> 01:15:45,410
તેમના શ્રેષ્ઠ મિત્રો.

1430
01:15:45,410 --> 01:15:46,720
અરે વાહ.

1431
01:15:46,720 --> 01:15:47,970
રોબ?

1432
01:15:47,970 --> 01:15:55,595

1433
01:15:55,595 --> 01:15:56,850
>> રોબ: હું ઝડપથી જાઓ પડશે.

1434
01:15:56,850 --> 01:16:00,466
અને પણ વિડિઓ મૂકવામાં આવશે.

1435
01:16:00,466 --> 01:16:01,716
હું પર માઇક છે.

1436
01:16:01,716 --> 01:16:24,060

1437
01:16:24,060 --> 01:16:26,230
>> ઠીક છે, તેથી સપ્તાહ પાંચ સામગ્રી.

1438
01:16:26,230 --> 01:16:27,970
અમે પ્રથમ વસ્તુ સ્ટેક છે.

1439
01:16:27,970 --> 01:16:33,390
તેથી માત્ર એક સ્ટેક છે તે યાદ
સક્રિય કાર્ય કોલ પ્રતિ ફ્રેમ.

1440
01:16:33,390 --> 01:16:34,710
અમે એક બીજા કે જોશો.

1441
01:16:34,710 --> 01:16:37,850
અને પણ ખરેખર જાય છે યાદ
દરેક સ્ટેક ફ્રેમ માં હશે આવે છે

1442
01:16:37,850 --> 01:16:41,880
અમારા કાર્યો સ્થાનિક ચલો,
માં પસાર થાય છે કે દલીલો અમારા

1443
01:16:41,880 --> 01:16:43,880
એક દંપતિ સાથે કાર્યો,
અન્ય વસ્તુઓ તમે ખરેખર નથી

1444
01:16:43,880 --> 01:16:45,260
વિશે ચિંતા કરવાની જરૂર છે.

1445
01:16:45,260 --> 01:16:50,950
>> અહીં જ્યાં એક ઉદાહરણ કાર્યક્રમ છે,
સૂચના, મુખ્ય પરત printfing છે

1446
01:16:50,950 --> 01:16:52,830
foo 4 મૂલ્ય.

1447
01:16:52,830 --> 01:16:57,930
foo માત્ર પાછા જઈ રહ્યું છે
બાર 4 અલ્પવિરામ 6 કિંમત.

1448
01:16:57,930 --> 01:17:02,380
અને બાર કેટલાક સ્થાનિક સુયોજિત રહ્યું છે
4 વખત 6 બરાબર ચલ n.

1449
01:17:02,380 --> 01:17:03,920
અને પછી એ આવો.

1450
01:17:03,920 --> 01:17:09,130
>> તેથી આપણે સમગ્ર સ્ટેક જુઓ
આ કાર્યક્રમ ના વાસ્તવિક પુનરાવૃત્તિ.

1451
01:17:09,130 --> 01:17:10,500
તેથી અમારા સ્ટેક તળિયે છે.

1452
01:17:10,500 --> 01:17:12,620
સ્ટેક સુધી વધે છે કે યાદ રાખો.

1453
01:17:12,620 --> 01:17:15,370
અમારા સ્ટેક તળિયે તેથી, અમે
મુખ્ય માટે એક સ્ટેક ફ્રેમ હોય છે.

1454
01:17:15,370 --> 01:17:17,000
જ્યારે આ કાર્યક્રમ શરૂ થાય છે, મુખ્ય
હંમેશા અંતે હોઈ ચાલે છે

1455
01:17:17,000 --> 01:17:18,560
અમારા સ્ટેક નીચે.

1456
01:17:18,560 --> 01:17:20,880
>> અને અંદર છે અમારા
મુખ્ય માટે ફ્રેમ ગંજી?

1457
01:17:20,880 --> 01:17:23,810
તેથી કોઈ સ્થાનિક છે, તેમ છતાં
મુખ્ય માટે ચલો હું પહેલાં જણાવ્યું હતું કે, જેમ

1458
01:17:23,810 --> 01:17:29,670
અમે argc અને rgv જગ્યા લેવા છે
મુખ્ય સ્ટેક ફ્રેમ ની અંદર.

1459
01:17:29,670 --> 01:17:33,260
હવે રહ્યું છે તેથી મુખ્ય
આ કાર્ય foo કહે છે.

1460
01:17:33,260 --> 01:17:35,125
અને તે foo રહ્યું છે એનો અર્થ એ થાય
તેની પોતાની સ્ટેક ફ્રેમ છે.

1461
01:17:35,125 --> 01:17:36,970
>> તેથી હવે અમે અંદર છો
આ કાર્ય foo.

1462
01:17:36,970 --> 01:17:38,610
અને શું જવા માટે જરૂર છે
foo માતાનો સ્ટેક ફ્રેમ?

1463
01:17:38,610 --> 01:17:41,100
વેલ, foo એક દલીલ એ છે.

1464
01:17:41,100 --> 01:17:45,440
તે છે અને ત્યારથી એ 4 બરાબર શું છે
મુખ્ય foo દલીલ તરીકે પસાર છે.

1465
01:17:45,440 --> 01:17:48,490
>> તેથી હવે foo બાર કહી રહ્યા છે.

1466
01:17:48,490 --> 01:17:52,070
શું બાર અંદર હોય રહ્યું છે
તેની 'સ્ટેક ફ્રેમ?

1467
01:17:52,070 --> 01:17:55,610
તે છ સમાન 4 વાય બરાબર એક્સ છે.

1468
01:17:55,610 --> 01:17:58,540
કે અમે હોય રહ્યા છીએ તે બધા નથી
બાર કારણ કે સ્ટેક ફ્રેમમાં

1469
01:17:58,540 --> 01:18:00,580
પણ સ્થાનિક ચલ n છે.

1470
01:18:00,580 --> 01:18:03,370
અને એ અમે 24 સમાન સુયોજિત કરવા માટે જઈ રહ્યાં છો.

1471
01:18:03,370 --> 01:18:05,750
>> તેથી હવે બાર એ પાછા જઈ રહ્યું છે.

1472
01:18:05,750 --> 01:18:09,300
તેથી બાર 24 પરત આવે છે
સ્ટેક ફ્રેમ foo.

1473
01:18:09,300 --> 01:18:12,560
અને બાર હવે, પરત આવે છે, કારણ કે
અમે સ્ટેક ફ્રેમ પોપિંગ રહ્યાં છો એનો અર્થ એ થાય

1474
01:18:12,560 --> 01:18:14,250
સ્ટેક બંધ બાર માટે.

1475
01:18:14,250 --> 01:18:18,430
બાર હતી જેથી તમામ મેમરી
ઉપયોગ સ્ટેક બોલ હવે છે.

1476
01:18:18,430 --> 01:18:21,550
>> હવે, foo પણ રહ્યું છે
મુખ્ય 24 પાછા.

1477
01:18:21,550 --> 01:18:25,470
તેથી હવે કે foo, મેમરી પરત આવે છે
કે foo તેના 'માં ઉપયોગ કરવામાં આવ્યો હતો

1478
01:18:25,470 --> 01:18:27,550
સ્ટેક ફ્રેમ પણ ગયો છે.

1479
01:18:27,550 --> 01:18:29,660
અને હવે, મુખ્ય printf કહી રહ્યા છે.

1480
01:18:29,660 --> 01:18:31,660
તેથી printf માત્ર અન્ય કાર્ય છે.

1481
01:18:31,660 --> 01:18:35,320
અમે printf કહી છે, તે જ હશે
આ printf માટે અન્ય સ્ટેક ફ્રેમ

1482
01:18:35,320 --> 01:18:36,470
વિધેય કોલ.

1483
01:18:36,470 --> 01:18:37,990
>> શું અમે printf પસાર કરવામાં આવે છે?

1484
01:18:37,990 --> 01:18:40,090
તે જવા માટે ચાલે છે તે છે
તેના સ્ટેક ફ્રેમ પર.

1485
01:18:40,090 --> 01:18:44,970
ખૂબ જ ઓછામાં ઓછા, અમે પસાર કરી રહ્યાં
કે ટકા હું એ બેકસ્લેશ અને

1486
01:18:44,970 --> 01:18:47,180
દલીલ 24.

1487
01:18:47,180 --> 01:18:50,370
તે સ્ટેક ફ્રેમ છે માં તે વધુ હોય શકે છે
printf કેટલાક ઉપયોગ કરી થાય તો

1488
01:18:50,370 --> 01:18:51,200
સ્થાનિક ચલો.

1489
01:18:51,200 --> 01:18:51,920
અમે જાણતા નથી.

1490
01:18:51,920 --> 01:18:53,810
>> પરંતુ બધા કે printf માં જાય છે
ફ્રેમ ગંજી.

1491
01:18:53,810 --> 01:18:55,740
તે printf ચલાવવા બનશે.

1492
01:18:55,740 --> 01:18:56,830
પછી printf થાય છે.

1493
01:18:56,830 --> 01:18:57,820
તે આપશે.

1494
01:18:57,820 --> 01:18:58,960
છેલ્લે, મુખ્ય કરવામાં આવે છે.

1495
01:18:58,960 --> 01:18:59,860
મુખ્ય આપશે.

1496
01:18:59,860 --> 01:19:02,020
અને પછી અમારા કાર્યક્રમ કરવામાં આવે છે.

1497
01:19:02,020 --> 01:19:02,480
અરે વાહ?

1498
01:19:02,480 --> 01:19:04,505
>> પ્રેક્ષક: તમે જોઈ રહ્યા છો [અશ્રાવ્ય]

1499
01:19:04,505 --> 01:19:05,900
દલીલો [અશ્રાવ્ય]

1500
01:19:05,900 --> 01:19:06,830
પરિમાણો?

1501
01:19:06,830 --> 01:19:09,970
>> રોબ: તેથી સૂક્ષ્મ તફાવત છે
દલીલો અને પરિમાણો વચ્ચે.

1502
01:19:09,970 --> 01:19:14,400
અને ખરેખર, સામાન્ય વાત, લોકો કરે છે
માત્ર બધા સમય તેમને ભળવું.

1503
01:19:14,400 --> 01:19:17,550
પરંતુ પરિમાણો ઔપચારિક છે
વસ્તુઓ નામ.

1504
01:19:17,550 --> 01:19:20,180
>> તેથી argc અને argv આ છે
મુખ્ય પરિમાણો.

1505
01:19:20,180 --> 01:19:23,440
દલીલો શું તમે ખરેખર છે
તે પરિમાણો તરીકે પસાર કરે છે.

1506
01:19:23,440 --> 01:19:28,340
તેથી હું 4 foo, 4 કૉલ જ્યારે
હું પસાર છું દલીલ છે.

1507
01:19:28,340 --> 01:19:31,460
અને અંદર પરિમાણ એ,
foo, કિંમત 4 પર લઈ જાય છે

1508
01:19:31,460 --> 01:19:32,880
4 થી દલીલ હતી.

1509
01:19:32,880 --> 01:19:35,826
>> AUDIENCE: [અશ્રાવ્ય]?

1510
01:19:35,826 --> 01:19:37,880
>> રોબ: એ બાર સ્થાનિક ચલ છે.

1511
01:19:37,880 --> 01:19:41,420

1512
01:19:41,420 --> 01:19:44,960
એ હજુ પણ foo માટે સ્થાનિક છે, પરંતુ
તે foo માટે પરિમાણ છે.

1513
01:19:44,960 --> 01:19:48,190
તે એક સ્થાનિક ચલ નથી.

1514
01:19:48,190 --> 01:19:48,546
અરે વાહ?

1515
01:19:48,546 --> 01:19:51,180
>> AUDIENCE: [અશ્રાવ્ય]?

1516
01:19:51,180 --> 01:19:55,400
>> રોબ: foo માત્ર ફોન છે બાર અને
ગમે બાર વળતર પરત.

1517
01:19:55,400 --> 01:19:56,786
>> AUDIENCE: [અશ્રાવ્ય]?

1518
01:19:56,786 --> 01:19:59,591
>> રોબ: અરે વાહ, માત્ર બહુવિધ જોવા માટે
ફ્રેમ ગંજી.

1519
01:19:59,591 --> 01:20:00,082
અરે વાહ?

1520
01:20:00,082 --> 01:20:03,519
>> પ્રેક્ષક: શા foo કહેવાય હતી
printf પહેલાં?

1521
01:20:03,519 --> 01:20:05,920
>> રોબ: શા foo printf પહેલાં તરીકે ઓળખાતું હતું?

1522
01:20:05,920 --> 01:20:10,740
હું કરી શકે છે તેથી, તેના બદલે, કંઈક
પૂર્ણાંક જેવા એક્સ 4 foo બરાબર

1523
01:20:10,740 --> 01:20:12,980
અને પછી એક્સ મુદ્રિત.

1524
01:20:12,980 --> 01:20:17,900
પરંતુ તેના બદલે, હું કાર્ય સંયુક્ત
આ printf દલીલ માં ફોન કરો.

1525
01:20:17,900 --> 01:20:23,670
>> પરંતુ નોટિસ કે અમે ખરેખર નથી કરી શકો છો
અમે ત્યાં સુધી printf કરવા માટે કૉલ ચલાવો

1526
01:20:23,670 --> 01:20:25,610
4 foo શું બહાર આકૃતિ.

1527
01:20:25,610 --> 01:20:27,480
તેથી અમે આ મૂલ્યાંકન રહ્યા છીએ.

1528
01:20:27,480 --> 01:20:32,504
અને તે થાય છે માત્ર એક જ વાર ચાલુ છે
પાછા આવો અને આ મૂલ્યાંકન.

1529
01:20:32,504 --> 01:20:32,990
અરે વાહ?

1530
01:20:32,990 --> 01:20:37,364
>> પ્રેક્ષક: બંને બાર છે [અશ્રાવ્ય]

1531
01:20:37,364 --> 01:20:41,738
કિંમત, શા માટે આપણે [અશ્રાવ્ય] નથી?

1532
01:20:41,738 --> 01:20:44,400
>> રોબ: તેઓ સંપૂર્ણપણે પૂર્ણાંક પ્રયત્ન કરીશું.

1533
01:20:44,400 --> 01:20:46,260
તે પર કેચ ન હતી
બહુવિધ પસાર થશે.

1534
01:20:46,260 --> 01:20:49,010
તેથી તે પૂર્ણાંક બાર અને પૂર્ણાંક હોવી જોઈએ
તે બંને કારણ foo

1535
01:20:49,010 --> 01:20:50,460
પૂર્ણાંકો પરત ફરી રહ્યા છે.

1536
01:20:50,460 --> 01:20:54,214
તેઓ જઈ રહ્યાં છો તો રદબાતલ માત્ર છે
વાસ્તવિક કિંમતો પાછા.

1537
01:20:54,214 --> 01:20:54,692
અરે વાહ?

1538
01:20:54,692 --> 01:20:58,038
>> પ્રેક્ષક: તમે એક લીટી હોય તો ઉપર
પરત, [અશ્રાવ્ય]?

1539
01:20:58,038 --> 01:21:01,862

1540
01:21:01,862 --> 01:21:03,730
>> રોબ: પરત ઉપર એક લાઇન?

1541
01:21:03,730 --> 01:21:04,410
>> પ્રેક્ષક: યાહ.

1542
01:21:04,410 --> 01:21:10,780
જેમ તમે printf અને [અશ્રાવ્ય] ન હોય તો,
તે બે વખત છાપો છો?

1543
01:21:10,780 --> 01:21:12,992
>> રોબ: foo ની અંદર તેથી?

1544
01:21:12,992 --> 01:21:15,945
અમે અહીં એક printf હોય તો?

1545
01:21:15,945 --> 01:21:16,750
>> પ્રેક્ષક: યાહ.

1546
01:21:16,750 --> 01:21:19,510
>> રોબ: તેથી જો અમે printf અધિકાર હતો
અહીં, એક વખત તે છાપી શકે છે.

1547
01:21:19,510 --> 01:21:23,400
અમે એક વખત યોગ્ય foo ફોન આવે છે
અહીં, પછી અમે printf હિટ પડશે.

1548
01:21:23,400 --> 01:21:24,620
તો પછી અમે બાર કહી શકશો.

1549
01:21:24,620 --> 01:21:25,710
અને પછી foo આપશે.

1550
01:21:25,710 --> 01:21:26,275
અને તે છે.

1551
01:21:26,275 --> 01:21:30,985
અમે માત્ર ક્યારેય અનુભવી
એકવાર printf.

1552
01:21:30,985 --> 01:21:31,482
અરે વાહ?

1553
01:21:31,482 --> 01:21:32,973
>> AUDIENCE: [અશ્રાવ્ય]

1554
01:21:32,973 --> 01:21:37,950
અમે પ્રથમ છો કારણ કે printf foo ફોન
printf ફોન અને પછી અમે પસાર કરી રહ્યાં

1555
01:21:37,950 --> 01:21:38,580
દલીલો.

1556
01:21:38,580 --> 01:21:40,960
>> રોબ: સિદ્ધાંતમાં તેથી, નથી
printf foo ફોન?

1557
01:21:40,960 --> 01:21:42,220
તેથી કોઈ.

1558
01:21:42,220 --> 01:21:47,360
સી રહ્યું છે કે માત્ર ક્રમ
અમે કરી શકો છો તે પહેલાં, આ વસ્તુઓ છે ચલાવો

1559
01:21:47,360 --> 01:21:49,800
, દલીલો તમામ એક કાર્ય કૉલ
કાર્ય માટે હોય છે

1560
01:21:49,800 --> 01:21:51,600
સંપૂર્ણપણે મૂલ્યાંકન કરવામાં.

1561
01:21:51,600 --> 01:21:53,540
તેથી આ સંપૂર્ણપણે મૂલ્યાંકન કરવામાં આવે છે?

1562
01:21:53,540 --> 01:21:54,610
હા, તે માત્ર એક શબ્દમાળા છે.

1563
01:21:54,610 --> 01:21:55,480
તે માત્ર એક કિંમત છે.

1564
01:21:55,480 --> 01:21:57,200
>> તો પછી અમે સંપૂર્ણપણે છે
આ મૂલ્યાંકન.

1565
01:21:57,200 --> 01:21:59,720
હવે તમામ, કરવામાં આવે છે એકવાર
તેની દલીલો મૂલ્યાંકન કરવામાં આવે છે.

1566
01:21:59,720 --> 01:22:01,982
અને હવે અમે આ કરી શકો છો
printf માટે ફોન કરો.

1567
01:22:01,982 --> 01:22:02,478
અરે વાહ?

1568
01:22:02,478 --> 01:22:03,966
>> પ્રેક્ષક: એક પ્રશ્ન.

1569
01:22:03,966 --> 01:22:06,942
તમે રદબાતલ કાર્ય છે, જ જોઈએ
તમે વળતર અર્ધવિરામ છે?

1570
01:22:06,942 --> 01:22:09,910
>> રોબ: તમે વળતર અર્ધવિરામ નથી
તમે રદબાતલ કાર્ય હોય છે.

1571
01:22:09,910 --> 01:22:13,370

1572
01:22:13,370 --> 01:22:14,780
બરાબર.

1573
01:22:14,780 --> 01:22:15,830
તેથી હવે કેટલાક ઢગલો સામગ્રી.

1574
01:22:15,830 --> 01:22:19,640
તેથી ઢગલો અમે વ્યવહાર જઈ રહ્યાં છો કેવી રીતે
ગતિશીલ મેમરી વ્યવસ્થાપન સાથે.

1575
01:22:19,640 --> 01:22:23,100
અને આ સીધા સાથે વિરોધાભાસ
અમે આપોઆપ ફોન કરશે જે સ્ટેક

1576
01:22:23,100 --> 01:22:24,100
મેમરી મેનેજમેન્ટ.

1577
01:22:24,100 --> 01:22:27,140
>> સ્ટેક પર તેથી, તમે ખરેખર ક્યારેય
કેવી રીતે સ્થાનિક ચલો સાથે વ્યવહાર

1578
01:22:27,140 --> 01:22:30,400
દબાણ અને બધી બોલ પોપ કરવામાં આવી રહી છે
આ સ્ટેક ફ્રેમ્સ અને તે સામગ્રી.

1579
01:22:30,400 --> 01:22:31,070
તમે તે વિશે ચિંતા કરવાની જરૂર નથી.

1580
01:22:31,070 --> 01:22:32,070
તે આપોઆપ છે.

1581
01:22:32,070 --> 01:22:36,990
તેથી આ ઢગલો જાતે છે.

1582
01:22:36,990 --> 01:22:38,070
અને [અશ્રાવ્ય]

1583
01:22:38,070 --> 01:22:41,260
આ વિધેયો આવે
malloc અને મફત છે.

1584
01:22:41,260 --> 01:22:43,550
>> અહીં અન્ય કાર્યક્રમ છે.

1585
01:22:43,550 --> 01:22:47,145
અમે કરી રહ્યા છીએ બધા mallocing છે
પૂર્ણાંક.

1586
01:22:47,145 --> 01:22:49,360
અમે સ્ટાર એક્સ માં સ્ટોર કરી રહ્યાં છો.

1587
01:22:49,360 --> 01:22:52,520
અલબત્ત, અમે તપાસ છે
એક્સ નલ છે તે જોવા માટે.

1588
01:22:52,520 --> 01:22:56,400
તો પછી અમે માત્ર શું સુયોજિત કરવા માટે જઈ રહ્યાં છો
એક્સ 50 પોઇન્ટ છે.

1589
01:22:56,400 --> 01:23:00,350

1590
01:23:00,350 --> 01:23:03,260
, પોઇન્ટ છે શું એક્સ છાપો
પ્રિન્ટ એક્સ, અને પછી મફત એક્સ.

1591
01:23:03,260 --> 01:23:08,920
>> તેથી આ કેવી રીતે ખરેખર જોવા રહ્યું છે
અમે અમારા સ્ટેક અને ઢગલો જોવા તો શું?

1592
01:23:08,920 --> 01:23:10,950
તેથી અમે ફરીથી શરૂ કરી શકશો.

1593
01:23:10,950 --> 01:23:12,580
પહેલાની જેમ અમારા સ્ટેક નીચે.

1594
01:23:12,580 --> 01:23:15,930
તને સીધી ઢગલો યાદ રાખો કે
સ્ટેક વિરોધ?

1595
01:23:15,930 --> 01:23:18,850
તેથી અમે હોય રહ્યા છીએ
ત્યાં અમારા ઢગલો ટોચ.

1596
01:23:18,850 --> 01:23:22,590
>> અમારા સ્ટેક તળિયે તેથી, અમે છે
મુખ્ય માટે અમારા સ્ટેક ફ્રેમ.

1597
01:23:22,590 --> 01:23:28,000
તે argc, argv માટે જગ્યા છે, અને અમે
હવે સ્થાનિક ચલ x, હોય છે જે

1598
01:23:28,000 --> 01:23:30,030
પૂર્ણાંક સ્ટાર છે.

1599
01:23:30,030 --> 01:23:32,240
તેથી અમે ફરી વળવું રહ્યા છીએ
આ કાર્યક્રમ દ્વારા.

1600
01:23:32,240 --> 01:23:34,420
અમે પ્રથમ વસ્તુ છે
malloc માટે કૉલ.

1601
01:23:34,420 --> 01:23:36,250
>> તેથી અમે malloc માટે કૉલ કરી રહ્યા છીએ.

1602
01:23:36,250 --> 01:23:37,100
Malloc એક કાર્ય છે.

1603
01:23:37,100 --> 01:23:38,770
તે સ્ટેક ફ્રેમ વિચાર રહ્યું છે.

1604
01:23:38,770 --> 01:23:40,180
અમે malloc માટે પસાર કરવામાં આવે છે?

1605
01:23:40,180 --> 01:23:41,610
તે અંદર જાઓ રહ્યું છે
સ્ટેક ફ્રેમ.

1606
01:23:41,610 --> 01:23:45,130
અમે 4 છે એ, કદ પસાર કરી રહ્યાં છો.

1607
01:23:45,130 --> 01:23:49,700
જેથી malloc માટે પસાર થાય છે.

1608
01:23:49,700 --> 01:23:50,910
>> Malloc શું કરે છે?

1609
01:23:50,910 --> 01:23:53,820
તે અમને ઢગલો પર કેટલાક જગ્યા ખેંચે છે.

1610
01:23:53,820 --> 01:23:55,320
તેથી અમે ઢગલો પર જાઓ રહ્યા છીએ.

1611
01:23:55,320 --> 01:23:57,990
અને અમે ગ્રેબ રહ્યા છીએ
ઢગલો 4 બાઇટ્સ.

1612
01:23:57,990 --> 01:24:01,500
તેથી આપણે માત્ર કે આપી દો
મનસ્વી સરનામું.

1613
01:24:01,500 --> 01:24:06,680
0x123 જસ્ટ કે એક છે ડોળ
ઢગલો પર કે સરનામું.

1614
01:24:06,680 --> 01:24:12,300
>> જેથી અંદર ખરેખર શું છે
સરનામું ox123 પર મેમરી પ્રદેશમાં?

1615
01:24:12,300 --> 01:24:13,080
કચરો.

1616
01:24:13,080 --> 01:24:15,270
તેથી અમે તે પણ સંગ્રહિત નથી.

1617
01:24:15,270 --> 01:24:18,830
તેથી જ્યાં સુધી અમે જાણીએ છીએ
કંઈપણ હોઈ શકે છે.

1618
01:24:18,830 --> 01:24:20,560
તમે તેને શૂન્ય છે ધારે ન જોઈએ.

1619
01:24:20,560 --> 01:24:23,870
તે શૂન્ય મોટા ભાગે છે.

1620
01:24:23,870 --> 01:24:26,260
>> તેથી હવે malloc વળતર.

1621
01:24:26,260 --> 01:24:28,020
અને અમે જ્યારે malloc વળતર શું કરવું?

1622
01:24:28,020 --> 01:24:29,800
અમે તે આપે છે તે સુયોજિત કરો.

1623
01:24:29,800 --> 01:24:32,290
અમે બરાબર એક્સ સેટ શું
તે પરત આવે છે.

1624
01:24:32,290 --> 01:24:33,690
તેથી તે શું પરત આવે છે?

1625
01:24:33,690 --> 01:24:38,150
કે છે કારણ કે તે 0x123 પરત છે
મેમરી બ્લોક સરનામું તે

1626
01:24:38,150 --> 01:24:40,850
માત્ર ઢગલો ફાળવવામાં.

1627
01:24:40,850 --> 01:24:47,160
>> તેથી 0x123 એક્સ હવે સેટ કરી રહ્યું છે પાછા
0x123 બરાબર છે, કે જે pictorially,

1628
01:24:47,160 --> 01:24:52,940
અમે વારંવાર એક વાસ્તવિક કર્યા એક્સ તરીકે ડ્રો
કે બ્લોક માટે પોઇન્ટ તીર.

1629
01:24:52,940 --> 01:24:55,820
પરંતુ એક્સ માત્ર કે સરનામું સ્ટોર કરે છે.

1630
01:24:55,820 --> 01:24:58,670
તેથી હવે અમે એક્સ નલ છે તે ચકાસવા માટે છે.

1631
01:24:58,670 --> 01:24:59,120
તે નલ નથી.

1632
01:24:59,120 --> 01:25:02,170
અમે તે malloc સફળ ડોળ કરવો કે.

1633
01:25:02,170 --> 01:25:04,950
>> તેથી હવે સ્ટાર એક્સ 50 સમકક્ષ હોય છે.

1634
01:25:04,950 --> 01:25:08,450
તેથી સ્ટાર એનો અર્થ યાદ
તે સરનામા પર જાઓ.

1635
01:25:08,450 --> 01:25:12,700
તેથી 0x123 અમે રહ્યા છીએ
તે સરનામા પર જાઓ.

1636
01:25:12,700 --> 01:25:14,660
જેથી ત્યાં અમને લઈ આવે છે.

1637
01:25:14,660 --> 01:25:16,310
અમે તે સરનામાં પર શું કરી રહ્યા છે?

1638
01:25:16,310 --> 01:25:19,020
અમે 50 સ્ટોર કરી રહ્યાં.

1639
01:25:19,020 --> 01:25:22,500
>> તેથી આ વાક્ય પછી, કે શું છે
વસ્તુઓ જેમ દેખાય છે જતા હોય છે.

1640
01:25:22,500 --> 01:25:24,640
તેથી હવે તે લાંબા સમય સુધી છે
ત્યાં કચરો છે.

1641
01:25:24,640 --> 01:25:28,910
હવે અમે 50 કે ખબર છે કે
ચોક્કસ સરનામું કારણ કે

1642
01:25:28,910 --> 01:25:32,410
અમે તે માં સુયોજિત કરો.

1643
01:25:32,410 --> 01:25:32,790
બરાબર?

1644
01:25:32,790 --> 01:25:34,370
તેથી હવે અમે એફ છાપી રહ્યા છીએ.

1645
01:25:34,370 --> 01:25:38,490
>> તેથી પ્રથમ અમે સ્ટાર એક્સ છાપી રહ્યા છીએ.

1646
01:25:38,490 --> 01:25:39,640
તેથી સ્ટાર એક્સ શું છે?

1647
01:25:39,640 --> 01:25:44,300
ફરીથી, સ્ટાર એક્સ પર જાઓ અર્થ એ થાય
એક્સ પોઇન્ટ છે કે વસ્તુ.

1648
01:25:44,300 --> 01:25:47,140
તેથી એક્સ કે 0x123 જાઓ સ્ટોર કરે છે.

1649
01:25:47,140 --> 01:25:48,490
અમે 50 મળે છે.

1650
01:25:48,490 --> 01:25:50,540
જેથી એફ છાપો.

1651
01:25:50,540 --> 01:25:54,900
અને તે 50 છાપી રહ્યું છે એનો અર્થ એ થાય.

1652
01:25:54,900 --> 01:25:56,850
અને પછી આપે છે.

1653
01:25:56,850 --> 01:25:58,340
>> અને પછી અમે બીજા printf છે.

1654
01:25:58,340 --> 01:25:59,370
હવે અમે ટકા પૃષ્ઠ છો.

1655
01:25:59,370 --> 01:26:01,680
તમે તેને જોઇ ન હોય, તો તે છે
માત્ર તમે એક નિર્દેશક છાપો કેવી રીતે.

1656
01:26:01,680 --> 01:26:04,960
તેથી અમે ટકા ટકા હું છે
એફ, અને પહેલેથી જ તે તમામ.

1657
01:26:04,960 --> 01:26:07,160
તેથી ટકા પૃષ્ઠ, એક નિર્દેશક છાપો.

1658
01:26:07,160 --> 01:26:08,920
>> તેથી એક્સ એક નિર્દેશક છે.

1659
01:26:08,920 --> 01:26:13,440
તેથી અમે પોતે એક્સ છાપી રહ્યા છીએ જો,
અમે અંદર ખરેખર શું છે છાપવા કરી રહ્યાં છો

1660
01:26:13,440 --> 01:26:19,220
જેથી પ્રથમ 0x123 છે એક્સ,
પ્રિન્ટ એફ 50 છાપી રહ્યું છે.

1661
01:26:19,220 --> 01:26:23,620
બીજા પ્રિન્ટ એફ રહ્યું છે
અરે વાહ 0x123 છાપવા માટે?

1662
01:26:23,620 --> 01:26:27,460
>> પ્રેક્ષક: તમે ટકા ઉપયોગ કરો છો
એક્સ એક નિર્દેશક છાપો?

1663
01:26:27,460 --> 01:26:31,200
>> રોબ: તેથી તમે ટકા ઉપયોગ કરી શકું
એક્સ એક નિર્દેશક છાપો?

1664
01:26:31,200 --> 01:26:38,350
તેથી, તમે આ કરી શકો છો પરંતુ ટકા એક્સ માત્ર છે
સામાન્ય રીતે, માટે જેમ તમે કેટલાક હોય તો

1665
01:26:38,350 --> 01:26:40,325
પૂર્ણાંક અને તમે છાપવાનો કરવા માંગો છો
તે હેક્સાડેસિમલ તરીકે.

1666
01:26:40,325 --> 01:26:43,250

1667
01:26:43,250 --> 01:26:44,880
તમે તે કેવી રીતે કરવું કે જે હમણાં જ છે.

1668
01:26:44,880 --> 01:26:47,160
>> જ્યારે ટકા ડી કરશે
દશાંશ તરીકે છાપો.

1669
01:26:47,160 --> 01:26:50,310
અમે ટકા મળી હતી કે છે
ડી. હું માત્ર પૂર્ણાંક છે.

1670
01:26:50,310 --> 01:26:52,690
ટકા પૃષ્ઠ ખાસ છે
પોઇન્ટર.

1671
01:26:52,690 --> 01:26:54,060
>> તેથી એક્સ એક નિર્દેશક છે.

1672
01:26:54,060 --> 01:26:56,360
અમે ટકા પૃષ્ઠ ઉપયોગ કરવા માંગો છો.

1673
01:26:56,360 --> 01:26:57,937
પરંતુ ટકા એક્સ કામ કરી શકે છે.

1674
01:26:57,937 --> 01:26:58,414
અરે વાહ?

1675
01:26:58,414 --> 01:26:59,664
>> AUDIENCE: [અશ્રાવ્ય]?

1676
01:26:59,664 --> 01:27:04,138

1677
01:27:04,138 --> 01:27:05,388
>> રોબ: અરે વાહ.

1678
01:27:05,388 --> 01:27:07,870

1679
01:27:07,870 --> 01:27:13,440
આ માટે ઓછામાં ઓછા જેથી call-- હું
અહીં તે સમાવેશ થયો ન હતો.

1680
01:27:13,440 --> 01:27:19,850
પરંતુ આ બે દલીલો જરૂરી છે
આ સ્ટેક ફ્રેમ ની અંદર

1681
01:27:19,850 --> 01:27:23,040
કોઈપણ સ્થાનિક ચલો સાથે
printf ઉપયોગ કરી થાય છે.

1682
01:27:23,040 --> 01:27:27,020
અને પછી આગામી કોલ હવે printf માટે
printf ની અંદર સ્ટેક ફ્રેમ છે

1683
01:27:27,020 --> 01:27:33,960
ટકા પૃષ્ઠ બેકસ્લેશ n એ અને ગમે તે
x ની કિંમત 0x123 છે, કે જે છે.

1684
01:27:33,960 --> 01:27:34,425
અરે વાહ?

1685
01:27:34,425 --> 01:27:35,675
>> AUDIENCE: [અશ્રાવ્ય]?

1686
01:27:35,675 --> 01:27:38,145

1687
01:27:38,145 --> 01:27:40,880
>> રોબ: તે કંઈક છાપવા પડશે
કે આ જેવો દેખાય છે.

1688
01:27:40,880 --> 01:27:41,846
>> AUDIENCE: [અશ્રાવ્ય].

1689
01:27:41,846 --> 01:27:44,510
>> રોબ: તેથી તે સરનામું સ્વરૂપમાં તે છાપે છે.

1690
01:27:44,510 --> 01:27:47,003
તે એક સરનામું જેવો દેખાય છે.

1691
01:27:47,003 --> 01:27:47,494
અરે વાહ?

1692
01:27:47,494 --> 01:27:49,458
>> AUDIENCE: [અશ્રાવ્ય]?

1693
01:27:49,458 --> 01:27:51,075
>> રોબ: શા માટે છે?

1694
01:27:51,075 --> 01:27:52,920
>> AUDIENCE: [અશ્રાવ્ય]?

1695
01:27:52,920 --> 01:27:55,240
>> રોબ: શા માટે આ નિર્દેશક 4 બાઇટ્સ છે?

1696
01:27:55,240 --> 01:27:58,500
તેથી સંપૂર્ણ જથ્થો છે
આ સામે 0 ના.

1697
01:27:58,500 --> 01:28:03,740
તેથી તે ખરેખર 0x0000000123 છે.

1698
01:28:03,740 --> 01:28:06,510
64-bit સિસ્ટમ પર, હશે
વધુ zeros સંપૂર્ણ જથ્થો.

1699
01:28:06,510 --> 01:28:11,410

1700
01:28:11,410 --> 01:28:11,900
અરે વાહ?

1701
01:28:11,900 --> 01:28:13,150
>> AUDIENCE: [અશ્રાવ્ય].

1702
01:28:13,150 --> 01:28:17,290

1703
01:28:17,290 --> 01:28:21,130
>> રોબ: તેથી પ્રથમ printf
print-- રહ્યું છે

1704
01:28:21,130 --> 01:28:21,980
>> AUDIENCE: [અશ્રાવ્ય].

1705
01:28:21,980 --> 01:28:24,420
>> રોબ: હા, તે છાપી રહ્યું છે
શું એક્સ પોઇન્ટ છે.

1706
01:28:24,420 --> 01:28:27,030

1707
01:28:27,030 --> 01:28:29,070
સ્ટાર આ શું કહે છે
વસ્તુ તરફ ઇશારો.

1708
01:28:29,070 --> 01:28:30,300
તે ગ્રેબ.

1709
01:28:30,300 --> 01:28:31,455
તેથી તે પોઇન્ટ છે શું?

1710
01:28:31,455 --> 01:28:31,850
50.

1711
01:28:31,850 --> 01:28:32,410
તે ગ્રેબ.

1712
01:28:32,410 --> 01:28:33,390
કે અમે છાપી રહ્યા છીએ તે છે.

1713
01:28:33,390 --> 01:28:37,020
આગામી એક, જ્યારે, અમે છો
માત્ર પોતે એક્સ છાપવા.

1714
01:28:37,020 --> 01:28:38,850
એફ ની અંદર શું છે?

1715
01:28:38,850 --> 01:28:43,710
0x123.

1716
01:28:43,710 --> 01:28:44,500
બરાબર.

1717
01:28:44,500 --> 01:28:46,620
>> અને પછી, છેવટે, અમે મફત છે.

1718
01:28:46,620 --> 01:28:48,040
અમે મુક્ત કરવા પસાર કરવામાં આવે છે?

1719
01:28:48,040 --> 01:28:49,470
અમે એક્સ પસાર કરી રહ્યાં છો.

1720
01:28:49,470 --> 01:28:52,380
હું ખરેખર પ્રદર્શિત કે સમય
તે સ્ટેક ફ્રેમ.

1721
01:28:52,380 --> 01:28:56,370
>> તેથી અમે કિંમત પસાર કરી રહ્યાં
0x123 મુક્ત કરવા.

1722
01:28:56,370 --> 01:28:59,070
તેથી હવે જાણે મફત, બધા અધિકાર,
હું ઢગલો સુધી જવું પડશે

1723
01:28:59,070 --> 01:29:00,050
અને તે મેમરી મફત છે.

1724
01:29:00,050 --> 01:29:03,920
તે લાંબા સમય સુધી ઉપયોગ છે તે
સરનામું 0x123 પર છે.

1725
01:29:03,920 --> 01:29:07,010
>> તેથી મફત પ્રકાશિત રહ્યું છે
ઢગલો થી છે.

1726
01:29:07,010 --> 01:29:09,490
હવે અમારા ઢગલો ફરી ખાલી છે.

1727
01:29:09,490 --> 01:29:11,120
અમે કોઈ મેમરી લીક્સ હોય છે.

1728
01:29:11,120 --> 01:29:12,940
હવે મફત આપશે.

1729
01:29:12,940 --> 01:29:16,130
કે એક્સ હજુ 0x123 છે નોટિસ.

1730
01:29:16,130 --> 01:29:18,240
પરંતુ તે હવે માન્ય મેમરી નથી.

1731
01:29:18,240 --> 01:29:21,220

1732
01:29:21,220 --> 01:29:23,986
અમે લાંબા સમય સુધી ખોટો સંદર્ભ એક્સ જોઈએ.

1733
01:29:23,986 --> 01:29:24,440
અરે વાહ?

1734
01:29:24,440 --> 01:29:27,240
>> પ્રેક્ષક: 0 બિનજરૂરી પાછા છે?

1735
01:29:27,240 --> 01:29:28,290
>> રોબ: 0 બિનજરૂરી returen છે?

1736
01:29:28,290 --> 01:29:31,110
હા.

1737
01:29:31,110 --> 01:29:33,950
અમે હમણાં જ ત્યાં છે, કારણ કે તે મૂકી
અમે હવા માટે વળતર એક છે.

1738
01:29:33,950 --> 01:29:36,830
તેથી તે હા, દે, જેવું છે
પરત 0 સમાવેશ થાય છે.

1739
01:29:36,830 --> 01:29:37,310
અરે વાહ?

1740
01:29:37,310 --> 01:29:38,560
>> AUDIENCE: [અશ્રાવ્ય]?

1741
01:29:38,560 --> 01:29:42,110

1742
01:29:42,110 --> 01:29:45,580
>> રોબ: તેથી મફત એક્સ પછી, શું થાય છે જો
અમે નિર્દેશક ખોટો સંદર્ભ માટે પ્રયાસ?

1743
01:29:45,580 --> 01:29:47,240
તે કશું ખોટું કે શક્ય છે.

1744
01:29:47,240 --> 01:29:49,330
અમે હજુ પણ 50 મળશે કે તે શક્ય છે.

1745
01:29:49,330 --> 01:29:53,590
>> તે મેમરી છે, પણ શક્ય છે
હવે કંઈક બીજું માટે ઉપયોગ થાય છે.

1746
01:29:53,590 --> 01:29:57,140
તેથી તે અવ્યાખ્યાયિત વર્તન છે.

1747
01:29:57,140 --> 01:30:00,772
અને અવ્યાખ્યાયિત કંઈપણ અર્થ એ થાય
થઇ શકે છે.

1748
01:30:00,772 --> 01:30:01,250
અરે વાહ?

1749
01:30:01,250 --> 01:30:02,500
>> AUDIENCE: [અશ્રાવ્ય]?

1750
01:30:02,500 --> 01:30:07,942

1751
01:30:07,942 --> 01:30:10,830
>> રોબ: ના, જેથી તમે સોંપી જો
બીજું કંઈક કરવા માટે એક્સ.

1752
01:30:10,830 --> 01:30:15,870
તેથી અહીં જો અમે એક્સ સમકક્ષ હોય છે જણાવ્યું હતું કે,
malloc કંઈક બીજું

1753
01:30:15,870 --> 01:30:17,100
malloc માપ ઘટના

1754
01:30:17,100 --> 01:30:20,180
પછી તે મૂળ બ્લોક
મેમરી મુક્ત નથી.

1755
01:30:20,180 --> 01:30:21,490
અને અમે સત્તાવાર રીતે તે ગુમાવી છે.

1756
01:30:21,490 --> 01:30:23,150
કે જે મેમરી છિદ્ર છે.

1757
01:30:23,150 --> 01:30:25,090
અમે બધા સંદર્ભો ગુમાવ્યું છે
મેમરી કે બ્લોક છે.

1758
01:30:25,090 --> 01:30:26,827
તેથી અમે ક્યારેય તેને મુક્ત કરી શકો છો કોઈ રીત નથી.

1759
01:30:26,827 --> 01:30:32,074

1760
01:30:32,074 --> 01:30:36,630
ઠીક છે, તેથી તે પછી કરવામાં 0 અર્થ આવો.

1761
01:30:36,630 --> 01:30:37,900
>> બધા હક છે, તેથી સ્ટેક ઓવરફ્લો.

1762
01:30:37,900 --> 01:30:39,320
અહીં વિચાર શું છે?

1763
01:30:39,320 --> 01:30:41,210
તેથી યાદ રાખો કે, ઢગલો નીચે રહ્યું છે.

1764
01:30:41,210 --> 01:30:43,480
સ્ટેક સુધી ચાલે છે.

1765
01:30:43,480 --> 01:30:48,000
તેથી આ વ્યાખ્યાન ના ઉદાહરણ તરીકે, હતી
હું જ્યાં મુખ્ય માત્ર રહ્યું છે, લાગે છે

1766
01:30:48,000 --> 01:30:51,380
રહ્યું છે આ કાર્ય foo, કૉલ
પર પુનરાવર્તિત પોતે કૉલ અને

1767
01:30:51,380 --> 01:30:52,320
ફરીથી.

1768
01:30:52,320 --> 01:30:55,370
>> તેથી ફ્રેમ જવું છે ગંજી
બરાબર એ જ કામ કરે છે.

1769
01:30:55,370 --> 01:30:58,130
તેથી અમે મુખ્ય સાથે શરૂ રહ્યા છીએ
નીચે સ્ટેક ફ્રેમ છે.

1770
01:30:58,130 --> 01:31:02,000
પછી મુખ્ય, foo કહી રહ્યા છે, જે
સ્ટેક ફ્રેમ વિચાર રહ્યું છે.

1771
01:31:02,000 --> 01:31:04,260
>> પછી foo foo કહી રહ્યા છે
ફરીથી, કે જે વિચાર રહ્યું છે

1772
01:31:04,260 --> 01:31:05,500
અન્ય સ્ટેક ફ્રેમ.

1773
01:31:05,500 --> 01:31:08,270
અને પછી ફરી, અને ફરી, અને ફરી,
અને ફરી, ત્યાં સુધી છેવટે, અમે ચલાવવા

1774
01:31:08,270 --> 01:31:09,190
ઢગલો માં.

1775
01:31:09,190 --> 01:31:11,990
તેથી આ અમે વિચાર કેવી રીતે
સ્ટેક ઓવરફ્લો.

1776
01:31:11,990 --> 01:31:14,910
અને આ બિંદુએ, તમે seg ખામી.

1777
01:31:14,910 --> 01:31:17,335
અથવા તમે ખરેખર seg પહેલાં દોષ છો
આ બિંદુએ પરંતુ હા.

1778
01:31:17,335 --> 01:31:19,660
>> પ્રેક્ષક: કોર ડમ્પ છે
seg દોષ તરીકે જ?

1779
01:31:19,660 --> 01:31:26,140
>> રોબ: તેથી તમે સેગ્મેન્ટેશન જોશો
દોષ કોર ડમ્પ.

1780
01:31:26,140 --> 01:31:28,760
તમે કોર ડમ્પ જ્યારે વિચાર
તમે seg ખામી.

1781
01:31:28,760 --> 01:31:32,580
અને તે તમામ એક ડમ્પ જેવું છે
તમારી વર્તમાન મેમરી સમાવિષ્ટો જેથી

1782
01:31:32,580 --> 01:31:36,670
તમે પ્રયાસ કરો અને ઓળખી શકે છે કે
શા માટે તમે faulted seg.

1783
01:31:36,670 --> 01:31:37,135
અરે વાહ?

1784
01:31:37,135 --> 01:31:38,385
>> AUDIENCE: [અશ્રાવ્ય]?

1785
01:31:38,385 --> 01:31:40,855

1786
01:31:40,855 --> 01:31:45,460
>> રોબ: તેથી સેગ્મેન્ટેશન ક્ષતિમાં અર્થ
સ્ટેક ઓવરફ્લો છે.

1787
01:31:45,460 --> 01:31:47,060
તેથી જરૂરી નથી.

1788
01:31:47,060 --> 01:31:49,880
એક સેગ્મેન્ટેશન ક્ષતિમાં તમે છો કે જે થાય છે
એ રીતે સ્પર્શ મેમરી

1789
01:31:49,880 --> 01:31:50,880
તમે ન હોવી જોઈએ.

1790
01:31:50,880 --> 01:31:54,750
જેથી રહ્યું એક રીતે, જ્યારે છે
જો અમે સ્પર્શ શરૂ, ઓવરફ્લો સ્ટેક

1791
01:31:54,750 --> 01:31:58,736
અમે ન હોવી જોઈએ તે રીતે મેમરી.

1792
01:31:58,736 --> 01:31:59,208
અરે વાહ?

1793
01:31:59,208 --> 01:32:00,458
>> AUDIENCE: [અશ્રાવ્ય]?

1794
01:32:00,458 --> 01:32:03,456

1795
01:32:03,456 --> 01:32:05,830
>> રોબ: એક અનંત લૂપ અંદર તેથી.

1796
01:32:05,830 --> 01:32:08,770
જેમ, આ ફરી યાદ આવવું અનંત જેવી છે
લૂપ અને તેથી અમે અન્ય વિચાર

1797
01:32:08,770 --> 01:32:09,770
સ્ટેક દરેક સમય ફ્રેમ.

1798
01:32:09,770 --> 01:32:13,540
પરંતુ માત્ર એક નિયમિત ની અંદર
અનંત one-- જ્યારે

1799
01:32:13,540 --> 01:32:16,390
સાથે સાથે, ચાલો પણ છાપી ન દો એફ

1800
01:32:16,390 --> 01:32:17,040
કંઈક.

1801
01:32:17,040 --> 01:32:18,390
ગમે.

1802
01:32:18,390 --> 01:32:20,610
>> અમે મળતું હોવું નથી જઈ રહ્યાં છો
અન્ય સ્ટેક ફ્રેમ.

1803
01:32:20,610 --> 01:32:22,530
અમે હમણાં જ રહ્યાં રાખવા રહ્યા છીએ
આ એક સૂચના પર.

1804
01:32:22,530 --> 01:32:23,920
આ સ્ટેક વધતી નથી.

1805
01:32:23,920 --> 01:32:27,290
તે દરેક ફરી યાદ આવવું છે તે હકીકત છે
કોલ અમને સ્ટેક ફ્રેમ આપે છે.

1806
01:32:27,290 --> 01:32:31,231
અમે સ્ટેક ઓવરફ્લો વિચાર શા માટે છે.

1807
01:32:31,231 --> 01:32:31,728
અરે વાહ?

1808
01:32:31,728 --> 01:32:38,189
>> પ્રેક્ષક: તેથી જો તમે વિચાર કહેવાય
જ્યારે લૂપ અને પછી [અશ્રાવ્ય]?

1809
01:32:38,189 --> 01:32:42,000
>> રોબ: જો જ્યારે લૂપ અંદર તેથી
એક printf હતી, તો તમે હજુ પણ કરશે

1810
01:32:42,000 --> 01:32:42,790
seg દોષ નથી.

1811
01:32:42,790 --> 01:32:46,090
હું માત્ર વસ્તુઓ ગૂંચવાડો ઊભો કરવા માંગો છો ન હતી.

1812
01:32:46,090 --> 01:32:46,610
તે લૂપ કરશે.

1813
01:32:46,610 --> 01:32:48,225
તમે એક સ્ટેક મેળવવા માગો છો
આ printf માટે ફ્રેમ.

1814
01:32:48,225 --> 01:32:49,580
>> પછી printf પરત ફરશે.

1815
01:32:49,580 --> 01:32:50,280
પછી તમે ફરીથી લૂપ છો.

1816
01:32:50,280 --> 01:32:51,460
તમે એક સ્ટેક મેળવવા માગો છો
આ printf માટે ફ્રેમ.

1817
01:32:51,460 --> 01:32:52,850
તે પાછો આવશે.

1818
01:32:52,850 --> 01:32:54,060
એક સ્ટેક ફ્રેમ.

1819
01:32:54,060 --> 01:33:00,215
તેથી જો તમે આ અનંત ન મળી રહ્યા
સ્ટેક ફ્રેમ્સ અપ અમાનત જથ્થો ઊભો કરવો.

1820
01:33:00,215 --> 01:33:03,185
>> AUDIENCE: [અશ્રાવ્ય]?

1821
01:33:03,185 --> 01:33:04,040
>> રોબ: હા.

1822
01:33:04,040 --> 01:33:09,360
તેથી આ સ્ટેક ઓવરફ્લો થાય
આ કંઈ કારણ

1823
01:33:09,360 --> 01:33:11,600
foo કોલ્સ પરત ફરી રહ્યા છે.

1824
01:33:11,600 --> 01:33:15,250
અમે પાછા તો પછી અમે કરશે તેથી
સ્ટેક ફ્રેમ્સ ગુમાવી શરૂ કરો.

1825
01:33:15,250 --> 01:33:17,870
અને પછી અમે સ્ટેક ઓવરફ્લો નથી.

1826
01:33:17,870 --> 01:33:20,070
તમે આધાર કેસ જરૂર શા માટે અને તે છે
તમારી વ્યક્તિગત કાર્યો માટે.

1827
01:33:20,070 --> 01:33:22,992

1828
01:33:22,992 --> 01:33:23,479
અરે વાહ?

1829
01:33:23,479 --> 01:33:27,375
>> પ્રેક્ષક: સંભવિત કદ અને છે
ઢગલો માટે જ માટે ગંજી

1830
01:33:27,375 --> 01:33:29,880
બધા કાર્યક્રમો?

1831
01:33:29,880 --> 01:33:31,910
>> રોબ: આશરે.

1832
01:33:31,910 --> 01:33:35,090
છે સ્ટેક સંભવિત કદ અને
બધા કાર્યક્રમો માટે જ ઢગલો?

1833
01:33:35,090 --> 01:33:37,180
આશરે.

1834
01:33:37,180 --> 01:33:40,080
કેટલાક રેન્ડમાઈઝેશન માટે છે
જ્યાં સ્ટેક શરૂ થાય છે અને

1835
01:33:40,080 --> 01:33:42,400
જ્યાં ઢગલો શરૂ થાય છે.

1836
01:33:42,400 --> 01:33:45,870
તમે એક સંપૂર્ણ ઘણો છે થાય છે
વૈશ્વિક ચલો અને વસ્તુઓ, તમે કદાચ

1837
01:33:45,870 --> 01:33:49,520
કેટલાક જગ્યા માંથી દૂર લઇ
તમારા ઢગલો માટે.

1838
01:33:49,520 --> 01:33:54,060
>> 64-bit સિસ્ટમ પર, તમે વર્ચ્યુઅલ
અનંત મેમરી છે.

1839
01:33:54,060 --> 01:33:55,820
માત્ર ખૂબ જ છે.

1840
01:33:55,820 --> 01:33:59,250
32 બિટ્સ અને 64 બિટ્સ, કે વચ્ચે
નોંધપાત્ર તફાવત છે.

1841
01:33:59,250 --> 01:34:02,350
>> તમે વધુ સંપૂર્ણ ઘણો વિચાર જઈ રહ્યાં છો
64-bit પર ગંજી અને ઢગલો જગ્યા

1842
01:34:02,350 --> 01:34:05,810
સિસ્ટમ માત્ર વધારે છે કારણ કે
તેઓ ઉપયોગ કરી શકો છો સંબોધે છે.

1843
01:34:05,810 --> 01:34:09,360
પરંતુ વ્યક્તિગત સિસ્ટમ પર, તે થશે
સ્ટેક આશરે જ જથ્થો હોઈ

1844
01:34:09,360 --> 01:34:10,785
અને ઢગલો જગ્યા.

1845
01:34:10,785 --> 01:34:13,635

1846
01:34:13,635 --> 01:34:15,530
અધિકાર છે.

1847
01:34:15,530 --> 01:34:18,220
>> તેથી છેલ્લા વસ્તુ સંકલન છે.

1848
01:34:18,220 --> 01:34:19,810
તેથી તમે આ પ્રક્રિયા ખબર હોવી જોઇએ.

1849
01:34:19,810 --> 01:34:22,240
ચાર મોટા પગલાંઓ છે.

1850
01:34:22,240 --> 01:34:24,400
જેથી પ્રથમ એક જોઈએ
યાદ સરળ છે.

1851
01:34:24,400 --> 01:34:25,085
પૂર્વ પ્રક્રિયા.

1852
01:34:25,085 --> 01:34:28,390
તે માં પૂર્વ ઉપસર્ગ છે.

1853
01:34:28,390 --> 01:34:32,080
તેથી તે બીજું બધું પહેલાં આવે છે.

1854
01:34:32,080 --> 01:34:34,000
>> યાદ આ બાબત હેશ છે.

1855
01:34:34,000 --> 01:34:37,250
તેથી હેશ વ્યાખ્યાયિત અને હેશ સમાવેશ
તે તમામ.

1856
01:34:37,250 --> 01:34:39,560
તે બધા પૂર્વ પ્રોસેસર છે
ડાઈરેક્ટીવો.

1857
01:34:39,560 --> 01:34:42,030
આ વસ્તુઓ છે કે જે છે
પૂર્વ પ્રોસેસર કાળજી લે છે.

1858
01:34:42,030 --> 01:34:43,680
>> તેથી પૂર્વ પ્રોસેસર શું કરે છે?

1859
01:34:43,680 --> 01:34:44,850
તે ખરેખર મૂક વાત છે.

1860
01:34:44,850 --> 01:34:49,380
તે સક્ષમ છે આ તમામ તમામ છે
નકલ, અને કટ, અને પેસ્ટ કામગીરી.

1861
01:34:49,380 --> 01:34:51,790
>> તેથી હેશ પ્રમાણભૂત i0 ડોટ ક છે.

1862
01:34:51,790 --> 01:34:52,990
કરી કે શું છે?

1863
01:34:52,990 --> 01:34:56,610
તે પ્રમાણભૂત i0 ડોટ ક પડતો છે
ફાઇલ અને ટોચ માં પેસ્ટ

1864
01:34:56,610 --> 01:34:58,960
ત્યાં તે હેશ સમાવેશ થાય છે
પ્રમાણભૂત i0 ડોટ ક.

1865
01:34:58,960 --> 01:35:02,480
>> અને કોઈ પણ હેશ અમે કર્યું છે કે વ્યાખ્યાયિત
જોવા મળે છે, શું કરવાનું છે કે?

1866
01:35:02,480 --> 01:35:06,730
તેના હેશ કિંમત છે કે જે નકલ
અને પેસ્ટ વ્યાખ્યાયિત વ્યાખ્યાયિત કરેલ છે

1867
01:35:06,730 --> 01:35:08,500
ત્યાં તમે કિંમત ઉપયોગ કરી રહ્યા છો.

1868
01:35:08,500 --> 01:35:13,400
તેથી preprocessor માત્ર ખરેખર કરે
સાદી લખાણ આધારિત કામગીરી.

1869
01:35:13,400 --> 01:35:15,870
તે સ્માર્ટ કંઈ નથી.

1870
01:35:15,870 --> 01:35:18,920
તેથી બીજું બધું છે
વધુ જટિલ.

1871
01:35:18,920 --> 01:35:22,970
>> તેથી હવે કે preprocessor છે
પૂર્ણ, અમે ખરેખર કમ્પાઇલ.

1872
01:35:22,970 --> 01:35:24,320
તેથી કમ્પાઇલ શું અર્થ છે?

1873
01:35:24,320 --> 01:35:27,310
હવે અમે સી કોડ માંથી રહ્યા છીએ
વિધાનસભા કોડ છે.

1874
01:35:27,310 --> 01:35:27,570
અરે વાહ?

1875
01:35:27,570 --> 01:35:28,820
>> AUDIENCE: [અશ્રાવ્ય]?

1876
01:35:28,820 --> 01:35:32,390

1877
01:35:32,390 --> 01:35:34,220
>> રોબ: અરે વાહ, અમે તે નહીં.

1878
01:35:34,220 --> 01:35:36,880

1879
01:35:36,880 --> 01:35:38,660
તેથી સંકલન.

1880
01:35:38,660 --> 01:35:40,310
અમે વિધાનસભા માટે કેચ માંથી જઈ રહ્યાં છો.

1881
01:35:40,310 --> 01:35:42,470
તેથી આ એક વાસ્તવિક ભાષા ફેરફાર છે.

1882
01:35:42,470 --> 01:35:45,240
પોતે સંકલન જઈને અર્થ એ થાય
માટે એક ઉચ્ચ સ્તર ભાષા

1883
01:35:45,240 --> 01:35:47,340
નીચા સ્તર ભાષા.

1884
01:35:47,340 --> 01:35:50,720
>> અને સી ઊંચા સ્તર ભાષા છે
વિધાનસભા સરખામણીમાં.

1885
01:35:50,720 --> 01:35:52,320
વિધાનસભા શું છે?

1886
01:35:52,320 --> 01:35:56,440
છે કે તેના સૂચનો ખૂબ
ખૂબ, તમારા CPU માટે કરી હતી.

1887
01:35:56,440 --> 01:35:59,130
પરંતુ તમારા કમ્પ્યુટર હજુ પણ કરે છે
વિધાનસભા સમજી નથી.

1888
01:35:59,130 --> 01:36:01,570
તે માત્ર ત્યારે જ મુદ્દાઓ અને zeros સમજે છે.

1889
01:36:01,570 --> 01:36:06,160
તેથી આગામી પગલું, એસેમ્બલ આવે છે, જે
આ સૂચનો અમને લાવે છે કે જે

1890
01:36:06,160 --> 01:36:08,760
તમારા CPU સમજે છે અને ખરેખર
માટે, તેમને અનુવાદ

1891
01:36:08,760 --> 01:36:10,820
આ મુદ્દાઓ અને zeros.

1892
01:36:10,820 --> 01:36:13,570
>> બાઈનરી વિધાનસભા સી તેથી.

1893
01:36:13,570 --> 01:36:15,870
પરંતુ હું હજુ સુધી એક એક્ઝેક્યુટેબલ નથી.

1894
01:36:15,870 --> 01:36:19,550
તેથી CS50 પુસ્તકાલય લાગે છે.

1895
01:36:19,550 --> 01:36:23,070
અમે દ્વિસંગી માટે સાથે તમે પૂરી પાડવામાં આવી છે
GetString છે આ CS50 પુસ્તકાલય,

1896
01:36:23,070 --> 01:36:24,400
અને GetInt અને તે તમામ.

1897
01:36:24,400 --> 01:36:25,700
>> પરંતુ CS50 પુસ્તકાલય

1898
01:36:25,700 --> 01:36:27,650
અને પોતે ના એક્ઝેક્યુટેબલ નથી.

1899
01:36:27,650 --> 01:36:29,570
તે એક મુખ્ય કાર્ય નથી.

1900
01:36:29,570 --> 01:36:32,230
તે બાઈનરી માત્ર એક ટોળું છે
તમે ઉપયોગ કરી શકો છો.

1901
01:36:32,230 --> 01:36:41,730
તેથી લિંક અમે સાથે બધા લાવે છે કેવી રીતે છે
આ વિવિધ બાઈનરી ફાઈલો

1902
01:36:41,730 --> 01:36:43,110
એક વાસ્તવિક એક્ઝેક્યુટેબલ માં.

1903
01:36:43,110 --> 01:36:45,900
તમે ટાઈપ કરી શકો છો કે જે એક
કોઈ કોઈ બહાર સ્લેશ.

1904
01:36:45,900 --> 01:36:51,660
>> તેથી આ ફાઇલ જેવું છે કે તમે
લખ્યું હતું - જે તમારા કાર્યક્રમ ઠીક

1905
01:36:51,660 --> 01:36:53,620
Ceaser ડોટ સી.

1906
01:36:53,620 --> 01:36:55,100
પરંતુ હવે તે સંકલિત કરવામાં આવ્યું
બાઈનરી નીચે.

1907
01:36:55,100 --> 01:36:56,480
તેથી Ceaser ડોટ ઓ.

1908
01:36:56,480 --> 01:36:59,620
અને આ અમારી CS50 બાઈનરી લાઈબ્રેરીઓ છે.

1909
01:36:59,620 --> 01:37:02,284
અને તેઓ સંયુક્ત આવી રહી રહ્યા છો
એક એક્ઝેક્યુટેબલ માં.

1910
01:37:02,284 --> 01:37:02,758
અરે વાહ?

1911
01:37:02,758 --> 01:37:04,008
>> AUDIENCE: [અશ્રાવ્ય]?

1912
01:37:04,008 --> 01:37:08,800

1913
01:37:08,800 --> 01:37:12,710
>> રોબ: તેથી પ્રથમ સમાવેશ થાય છે, યાદ રાખો કે,
સમાવેશ થાય છે ખરેખર એક છે હેશ

1914
01:37:12,710 --> 01:37:13,810
પૂર્વ પ્રોસેસર પગલું.

1915
01:37:13,810 --> 01:37:14,750
પરંતુ તે અલગ છે.

1916
01:37:14,750 --> 01:37:20,730
તમે કોઈપણ કાર્યો ઉપયોગ કરી રહ્યાં છો કે
પછી તમારા એક ફાઈલ બહાર હો,

1917
01:37:20,730 --> 01:37:26,100
ના, તમે કંઈપણ લિંક કરવાની જરૂર નથી
તમે બધું હોય છે.

1918
01:37:26,100 --> 01:37:30,310
>> તેણે કહ્યું, કે printf સાથે જોડાયેલા કરવામાં આવી રહી છે.

1919
01:37:30,310 --> 01:37:32,820
તમે ક્યારેય printf વાપરવા માટે, કે જે કંઈક છે
કે સાથે જોડાયેલા કરવાની જરૂર છે

1920
01:37:32,820 --> 01:37:35,740
તમે તે લખવા ન હતી કારણ કે.

1921
01:37:35,740 --> 01:37:39,530
અને, હકીકતમાં, printf આપોઆપ છે
સાથે જોડાયેલા.

1922
01:37:39,530 --> 01:37:42,760
તમે જાણો છો કે કેવી રીતે આદેશ વાક્ય પર અથવા જ્યારે
તમે તેને હોય છે, જુઓ બનાવવા લખો

1923
01:37:42,760 --> 01:37:46,690
કડી છે કે જે આડંબર એલ CS50,
આ CS50 પુસ્તકાલય?

1924
01:37:46,690 --> 01:37:49,070
કે Printf, અને સામગ્રી, રહ્યું છે
આપોઆપ સાથે જોડાયેલા છે.

1925
01:37:49,070 --> 01:37:51,730

1926
01:37:51,730 --> 01:37:53,930
બાબતની કોઈપણ અન્ય પ્રશ્નો છે?

1927
01:37:53,930 --> 01:37:56,280
>> AUDIENCE: [અશ્રાવ્ય]?

1928
01:37:56,280 --> 01:37:58,300
>> રોબ: લિંક?

1929
01:37:58,300 --> 01:38:03,450
અમે સંપૂર્ણ જથ્થો છે
વિવિધ બાઈનરી ફાઈલો.

1930
01:38:03,450 --> 01:38:06,410
આ પ્રમાણભૂત ઉદાહરણ છે
અમે વાપરો કે જે CS50 પુસ્તકાલય છે.

1931
01:38:06,410 --> 01:38:09,960
અમે સંકલિત અને તમે કરવા માટે આપવામાં આવ્યું છે
આ CS50 પુસ્તકાલય માટે બાઈનરી.

1932
01:38:09,960 --> 01:38:12,410
>> તમે GetString ઉપયોગ કરવા માંગો છો
તમારા કાર્યક્રમ.

1933
01:38:12,410 --> 01:38:14,750
તેથી જો તમે જાઓ અને GetString ઉપયોગ કરે છે.

1934
01:38:14,750 --> 01:38:19,700
પરંતુ મારા બાઈનરી કોડ વિના
GetString, તમે તમારા કોડ કમ્પાઇલ જ્યારે

1935
01:38:19,700 --> 01:38:23,140
નીચે, તમે ખરેખર ચલાવી શકો નહિં તમારા
કાર્યક્રમ GetString શબ્દમાળા છે, કારણ કે

1936
01:38:23,140 --> 01:38:25,080
હજુ સુધી સંપૂર્ણપણે વ્યાખ્યાયિત નથી.

1937
01:38:25,080 --> 01:38:29,220
>> તમે મારા દ્વિસંગી લિંક જ્યારે તે માત્ર ત્યારે જ છે
કે બધા, કે હવે GetString છે

1938
01:38:29,220 --> 01:38:31,130
અધિકાર, હું ખરેખર આ કરી શકો છો
GetString ચલાવો.

1939
01:38:31,130 --> 01:38:32,330
મારા ફાઈલ સંપૂર્ણ છે.

1940
01:38:32,330 --> 01:38:34,208
અને હું આ ચલાવી શકો છો.

1941
01:38:34,208 --> 01:38:34,697
અરે વાહ?

1942
01:38:34,697 --> 01:38:37,631
>> પ્રેક્ષક: કન્વર્ટ લિંક નથી
બાઈનરી એક્ઝેક્યુટેબલ માટે?

1943
01:38:37,631 --> 01:38:42,032
તમે અન્ય નથી તેથી તો પણ
પુસ્તકાલયો, તે હજુ પણ નહીં હોય

1944
01:38:42,032 --> 01:38:44,477
અનુવાદ કરવા જરૂરી
[અશ્રાવ્ય]?

1945
01:38:44,477 --> 01:38:48,640
>> રોબ: તેથી એક્ઝિક્યુટેબલ
બાઈનરી હજુ પણ છે.

1946
01:38:48,640 --> 01:38:51,750
તે માત્ર એક સંપૂર્ણ સંયોજન છે
દ્વિસંગીઓ ઓફ ટોળું.

1947
01:38:51,750 --> 01:38:55,124

1948
01:38:55,124 --> 01:38:56,591
>> પ્રેક્ષક: તમે ખૂબ આભાર.

1949
01:38:56,591 --> 01:38:58,560
>> રોબ: કોઈ સમસ્યા નથી.

1950
01:38:58,560 --> 01:38:59,540
કોઈપણ અન્ય પ્રશ્નો છે?

1951
01:38:59,540 --> 01:39:02,001
અન્યથા, અમે બધા સુયોજિત કરી રહ્યાં છો.

1952
01:39:02,001 --> 01:39:02,690
અધિકાર છે.

1953
01:39:02,690 --> 01:39:02,990
આભાર.

1954
01:39:02,990 --> 01:39:03,590
>> [વધાવી]

1955
01:39:03,590 --> 01:39:04,490
>> પ્રેક્ષક: આભાર.

1956
01:39:04,490 --> 01:39:05,740
>> રોબ: અરે વાહ.

1957
01:39:05,740 --> 01:39:06,582