1
00:00:07,010 --> 00:00:09,640
[Powered by Google Translate] કાર્યો કોડ વિભાગો મોટી કાર્યક્રમ અંદર ઉપયોગ થાય છે

2
00:00:09,640 --> 00:00:11,430
ચોક્કસ કાર્ય કરે છે.

3
00:00:11,430 --> 00:00:15,060
તેઓ પણ પ્રક્રિયાઓ, સબરુટીનો, અને subprograms તરીકે ઓળખવામાં આવે છે,

4
00:00:15,060 --> 00:00:18,320
કારણ કે તેઓ ખરેખર કાર્યક્રમો અંદર માત્ર મિની કાર્યક્રમો છે.

5
00:00:18,320 --> 00:00:20,340
છતાં પણ તમે જોયું ન શકે,

6
00:00:20,340 --> 00:00:24,090
તમે સૌથી ચોક્કસપણે કાર્યો ઉપયોગ પહેલેથી જો તમે સી માં પ્રોગ્રામ કર્યા છે

7
00:00:24,090 --> 00:00:26,770
, જ્યારે તમે printf મદદથી સ્ક્રીન પર સામગ્રી લખી

8
00:00:26,770 --> 00:00:29,380
તમે ખરેખર printf કહેવાય કાર્ય ઉપયોગ કરી રહ્યાં છો.

9
00:00:29,380 --> 00:00:33,760
તેવી જ રીતે, GetInt અને GetString વિધેયો કે CS50 તમે પૂરી પાડે છે.

10
00:00:33,760 --> 00:00:37,750
પ્રોગ્રામરો, અમે સંખ્યાબંધ કારણો માટે વિધેયો વાપરે છે.

11
00:00:37,750 --> 00:00:41,240
>> કાર્યો કર્યા સ્ક્રીન પર લખવા જેવી સામાન્ય ક્રિયાઓ

12
00:00:41,240 --> 00:00:44,480
અને ઇનપુટ માટે વપરાશકર્તાને પૂછવાની અમને સાચવે છે ત્યારે પ્રોગ્રામિંગ.

13
00:00:44,480 --> 00:00:47,510
તે જરૂરી કોડ લખવા માટે તે જ બાબતો કરી નથી

14
00:00:47,510 --> 00:00:49,520
કારણ કે તેઓ પહેલેથી જ અમને માટે કરી રહ્યા છો.

15
00:00:49,520 --> 00:00:54,580
તે પણ જરૂરી અમારા માટે સમજવા માટે ચોક્કસ રૂપે કેવી રીતે તે વિધેયો આંતરિક કામ નથી.

16
00:00:54,580 --> 00:00:58,880
તેના બદલે, અમે હમણાં જ ખબર કેવી રીતે ઉપયોગ કરવો અથવા કૉલ તેમને અમારી કાર્યક્રમોમાં છે.

17
00:00:58,880 --> 00:01:02,040
તે પણ મદદરૂપ મોટા કાર્યક્રમો કાર્યો લખી

18
00:01:02,040 --> 00:01:04,330
જો તમે આવી રહી અન્ય તેમને વાપરવા પર આયોજન કરી રહ્યાં છો,

19
00:01:04,330 --> 00:01:06,830
હમણાં હાથ પર મોટા કાર્ય વિભાજીત કરવા માટે.

20
00:01:06,830 --> 00:01:11,910
આ રીતે, તમે તમારા કોડ માટે માળખું આપી ખૂબ જેવા તમે માળખું એક નિબંધ આપવા માંગો છો,

21
00:01:11,910 --> 00:01:15,180
અને ખરેખર વિશાળ પ્રોજેક્ટ સાથે તમે બહુવિધ લોકોને સક્ષમ કરો

22
00:01:15,180 --> 00:01:16,730
એ જ સમયે જુદા જુદા ભાગો પર કામ

23
00:01:16,730 --> 00:01:20,480
કારણ કે તે સ્પષ્ટ છે જ્યાં એક વ્યક્તિ કામ પૂર્ણ થાય અને અન્ય શરૂ થાય છે.

24
00:01:20,480 --> 00:01:26,530
>> કાર્યો ખાસ કરીને 1 અથવા વધુ ઇનપુટ્સ, દલીલો અથવા પરિમાણો તરીકે ઓળખાય ચાલુ છે,

25
00:01:26,530 --> 00:01:30,520
એક આઉટપુટ કિંમત છે કે પછી પાછા ફર્યા છે માં તે ઇનપુટ્સ રૂપાંતરિત.

26
00:01:30,520 --> 00:01:34,950
જોકે, તે પણ શક્ય વિધેયો કે જે કોઈપણ ઇનપુટ દલીલો વાપરો નહિં હોય

27
00:01:34,950 --> 00:01:36,400
અને એક આઉટપુટ નથી પાછા નથી.

28
00:01:36,400 --> 00:01:38,790
ઠીક છે, આ રુંવાટીવાળું સામગ્રી સાથે પૂરતી.

29
00:01:38,790 --> 00:01:41,790
ચાલો સી કેટલાક વાસ્તવિક વિધેયો પર એક નજર

30
00:01:41,790 --> 00:01:45,570
>> અહીં અમે એક ચોરસ કહેવાય છે કે, તે માને છે કે નહિં કાર્ય હોય છે,

31
00:01:45,570 --> 00:01:47,570
ઇનપુટ ચોરસ ગણતરી કરે છે.

32
00:01:47,570 --> 00:01:49,490
ચાલો તેને ની સિન્ટેક્ષ વિશ્લેષણ કરવું.

33
00:01:49,490 --> 00:01:51,860
પ્રથમ શબ્દ તમે કાર્ય જુઓ, પૂર્ણાંક,

34
00:01:51,860 --> 00:01:57,460
આ કાર્યમાં પરત પ્રકાર સ્પષ્ટ; એટલે કે, તે કાર્ય આઉટપુટ ના સી પ્રકાર.

35
00:01:57,460 --> 00:02:00,370
આ કાર્ય પ્રકાર પૂર્ણાંક સાથે કિંમત બનાવવામાં આવશે.

36
00:02:00,370 --> 00:02:04,100
આગામી શબ્દ તમે જુઓ કાર્ય નું નામ પણ, આ કિસ્સામાં ચોરસ છે.

37
00:02:04,100 --> 00:02:07,390
વિધેયો યોગ્ય નામકરણ ખાસ કરીને મહત્વનું છે

38
00:02:07,390 --> 00:02:11,260
કારણ કે તે કદાચ કાર્ય શું કરે છે સૌથી દૃશ્યમાન દસ્તાવેજીકરણ છે.

39
00:02:11,260 --> 00:02:14,880
તે આ કાર્ય shazam અથવા booyah નામ ઠંડી હોઇ શકે છે,

40
00:02:14,880 --> 00:02:18,340
પરંતુ અમને કાર્ય શું કરે છે તે વિશે કશું કહ્યું ન હોત.

41
00:02:18,340 --> 00:02:23,470
>> પગલે વિધેય નામ કામગીરી, દલીલો કરવા માટે ઇનપુટ્સ આવે છે.

42
00:02:23,470 --> 00:02:26,380
તેઓ કૌંસ સમૂહ અંદર યાદી થયેલ છે

43
00:02:26,380 --> 00:02:30,160
બંને તેમના પ્રકાર અને એ વિધેય શરીર અંદર તેમના માટે ઉપયોગ નામ સાથે.

44
00:02:30,160 --> 00:02:34,030
સ્ક્વેર ચોરસ ફક્ત 1 દલીલ છે, પૂર્ણાંક લે છે,

45
00:02:34,030 --> 00:02:36,160
હું નામ આપવાનું નક્કી કર્યું છે કે જે એક્સ.

46
00:02:36,160 --> 00:02:40,760
આ કાર્ય જાહેરાત અથવા પ્રોટોટાઇપ અંત થાય છે.

47
00:02:40,760 --> 00:02:43,320
આ સર્પાકાર કામગીરી બાકીના આસપાસના કૌંસ

48
00:02:43,320 --> 00:02:45,870
શરૂઆત અને કાર્ય શરીરના ઓવરને દર્શાવવા,

49
00:02:45,870 --> 00:02:48,320
આ કાર્ય પોતાની વ્યાખ્યા.

50
00:02:48,320 --> 00:02:50,300
સ્ક્વેર એક સુંદર, સરળ કાર્ય છે.

51
00:02:50,300 --> 00:02:54,100
તે માત્ર ત્યારે જ રેખા 1 મળ્યું છે, કારણ કે તમામ અમે હોય તો પોતે દ્વારા એક્સ વધવું છે.

52
00:02:54,100 --> 00:02:59,250
આ શબ્દ વળતર આઉટપુટ કિંમત સ્પષ્ટ અને કાર્ય ઓવરને શકે છે.

53
00:02:59,250 --> 00:03:03,430
માટે ચોરસ વિધેય વાપરી, અમે યોગ્ય ઇનપુટ્સ સપ્લાય કરવાની જરૂર

54
00:03:03,430 --> 00:03:05,310
અને પછી એ આઉટપુટ પકડી.

55
00:03:05,310 --> 00:03:08,140
અહીં, તમે જે રીતે એક દંપતી જુઓ.

56
00:03:08,140 --> 00:03:13,600
અમે કાચા પૂર્ણાંક પાસ, 6 જેવા કરી શકો છો, અથવા આપણે જેમ એક ચલ પાસ કરી શકો છો.

57
00:03:13,600 --> 00:03:15,700
નોંધ કરો કે દરેક સમય અમે ચોરસ કહી,

58
00:03:15,700 --> 00:03:18,330
અમે ચલ માં ઉત્પાદન મેળવે છે અને પછી તેને છાપો.

59
00:03:18,330 --> 00:03:22,690
જો કે, અમે એક ચલ માં પરત કિંમત સંગ્રહિત અને પછી પ્રિન્ટ નથી.

60
00:03:22,690 --> 00:03:27,090
અમે હમણાં જ તે સીધી રીતે મોકલી શકે છે printf માટે આપણે શું કરવું જ્યારે અમે 10 ચોરસ,

61
00:03:27,090 --> 00:03:30,580
પરંતુ આ અર્થ એ નથી કે અમે 10 ચોરસ પરત કિંમત ઍક્સેસ નથી

62
00:03:30,580 --> 00:03:32,230
અન્યત્ર કોડ છે.

63
00:03:32,230 --> 00:03:34,890
ચાલો અન્ય સરળ ઉદાહરણ જુઓ.

64
00:03:34,890 --> 00:03:38,750
>> આ સમયે, અમે 2 ફ્લોટ્સ સાથે મળીને કે જેથી અમે જોઈ શકો છો કાર્ય શું લાગે સરવાળો પડશે

65
00:03:38,750 --> 00:03:41,220
જ્યારે તે ફક્ત 1 બદલે 2 ઇનપુટ્સ મળ્યું છે.

66
00:03:41,220 --> 00:03:43,950
જેમ તમે જોઈ શકો, તો તે ખૂબ અલગ નથી.

67
00:03:43,950 --> 00:03:47,330
બધા અમે નથી 2 જી દલીલ, એક બોલ્ડ નામવાળી ફ્લોટ માં ઉમેરવા માટે,

68
00:03:47,330 --> 00:03:51,820
આ દલીલ અલ્પવિરામ મદદથી તે પ્રથમ દલીલ અલગ યાદી માટે તરતા રહે છે.

69
00:03:51,820 --> 00:03:55,550
જેથી, અમારા ચોરસ અને રકમ કાર્યો ખૂબ સમજવા માટે સરળ છે

70
00:03:55,550 --> 00:03:58,930
કારણ કે તેઓ વિધેયો કે જે તમે ગણિત વર્ગ પહેલા જોયેલા માટે સમકક્ષ છો.

71
00:03:58,930 --> 00:04:01,610
હવે, ચાલો એક કાર્ય છે કે જે થોડું અલગ છે જુઓ.

72
00:04:01,610 --> 00:04:04,620
તેના બદલે એક કિંમત પાછા, તે રાજ્ય સુધારે.

73
00:04:04,620 --> 00:04:07,260
આ એક બાજુ અસર હોવા તરીકે ઓળખવામાં આવે છે.

74
00:04:07,260 --> 00:04:10,750
આ કાર્યક્રમ માં, printf_fudd_style કાર્ય

75
00:04:10,750 --> 00:04:13,410
પરત પ્રકાર છે કે અમે ખાલીપણુ, પહેલાં જોઈ હોય તો.

76
00:04:13,410 --> 00:04:16,730
>> રદબાતલ કહે છે કે એક કાર્ય કંઈપણ નહિં આપે વપરાય છે.

77
00:04:16,730 --> 00:04:19,410
ત્યાં પ્રકાર રદબાતલ કોઈ ચલો છે,

78
00:04:19,410 --> 00:04:22,760
તેથી જો તમે printf_fudd_style જેમ કાર્ય માંથી કંઈક પરત પ્રયત્ન કરો,

79
00:04:22,760 --> 00:04:24,290
આ કમ્પાઈલર તમે કિકિયારી આવશે.

80
00:04:24,290 --> 00:04:29,390
Printf_fudd_style અંદર, અમે જુઓ કે જ્યારે કાર્ય હજી પણ કાર્ય કરે છે,

81
00:04:29,390 --> 00:04:31,890
એટલે કે, WS બધા રૂ. સ્વિચ,

82
00:04:31,890 --> 00:04:36,380
આ કાર્ય તે બિંદુ માટે શબ્દમાળા સુધારવા અને પછી સ્ક્રીન પર તેને છાપી ગઈ છે,

83
00:04:36,380 --> 00:04:39,400
કાર્યક્રમના રાજ્ય બદલવા બદલે પરિણામે ફર્યા હતા.

84
00:04:39,400 --> 00:04:43,700
આ ફંક્શનનો ઉપયોગ કરીને અમારા ચોરસ અને રકમ વિધેયો મદદથી જેમ ખૂબ ખૂબ છે,

85
00:04:43,700 --> 00:04:46,950
સિવાય અમે ચલ માં પરિણામ નથી સ્ટોર નથી અથવા તે અન્ય કાર્ય માટે આ બોલ પસાર

86
00:04:46,950 --> 00:04:49,520
કારણ કે કોઈ વાત પરિણામ છે.

87
00:04:49,520 --> 00:04:53,180
તેથી, જ્યારે અમે કમ્પાઇલ અને અમારા એલ્મર ફુડ કાર્યક્રમ ચલાવો

88
00:04:53,180 --> 00:04:56,970
કે જે તમને "તમે દુષ્ટતાથી સસલા!" જુઓ નહીં જમણી પરિવર્તન

89
00:04:56,970 --> 00:04:58,730
"તમે wascally wabbit!"

90
00:04:58,730 --> 00:05:02,250
>> છેલ્લે, ત્યાં ચર્ચા વર્થ 1 વધુ કાર્ય છે

91
00:05:02,250 --> 00:05:06,810
કારણ કે તમે દરેક સી કાર્યક્રમ તમે ક્યારેય તેવા પરચૂરણ ખર્ચ કર્યો છે કરવામાં કર્યું છે કે તે વાપરી રહ્યા હોય, મુખ્ય.

92
00:05:06,810 --> 00:05:09,450
મુખ્ય કોઈપણ અન્ય જેમ જ એક કાર્ય છે.

93
00:05:09,450 --> 00:05:13,580
તે વળતર પ્રકાર, નામ, દલીલો યાદી છે, અને શરીર મળ્યું છે.

94
00:05:13,580 --> 00:05:16,110
મુખ્ય પરત પ્રકાર હંમેશા પૂર્ણાંક છે,

95
00:05:16,110 --> 00:05:19,120
અને આ int પર કાર્યક્રમ સ્થિતિ વાતચીત જ્યારે તે સમાપ્ત કરવા માટે વપરાય છે.

96
00:05:19,120 --> 00:05:23,360
>> શું તે સફળતાપૂર્વક ચલાવવા માટે, અથવા તો તે ભૂલ કારણે અંત?

97
00:05:23,360 --> 00:05:26,390
શૂન્ય પરત સફળ રન સૂચવે છે,

98
00:05:26,390 --> 00:05:29,510
અને કોઈપણ કિંમત બિન શૂન્ય પરત ભૂલ દર્શાવે છે.

99
00:05:29,510 --> 00:05:31,950
કાર્યક્રમ જે પ્રકારનું તમે લખી રહ્યાં પર આધાર રાખીને,

100
00:05:31,950 --> 00:05:34,960
વિવિધ ભૂલો માટે અલગ કોડ પરત મદદરૂપ થઈ શકે છે

101
00:05:34,960 --> 00:05:37,210
લોકો તમારા કાર્યક્રમ પર પછીથી વાપરવા માટે.

102
00:05:37,210 --> 00:05:40,220
મુખ્ય દલીલો થોડી વધુ જટિલ હોય છે.

103
00:05:40,220 --> 00:05:42,150
>> આ દલીલ યાદી ક્યાં ખાલી હોઇ શકે છે,

104
00:05:42,150 --> 00:05:45,330
જે અમે કૌંસ વચ્ચે રદબાતલ લખીને દર્શાવે છે,

105
00:05:45,330 --> 00:05:50,220
પૂર્ણાંક અને કોલસો બનાવો * ઓ ઝાકઝમાળ: અથવા યાદી 2 દલીલો કરી શકે છે.

106
00:05:50,220 --> 00:05:52,820
આ જ્યારે તમારા કાર્યક્રમ વાપરવા માટે ઇરાદો વપરાય છે

107
00:05:52,820 --> 00:05:56,490
દલીલો આદેશ વાક્ય પર પસાર જ્યારે કાર્યક્રમ ચલાવી છે.

108
00:05:56,490 --> 00:05:59,690
આ પૂર્ણાંક દલીલ ખાસ argc કહે છે,

109
00:05:59,690 --> 00:06:03,300
અને તે ચાર રચે છે * ઍરેની સમાન લંબાઇ, argv તરીકે ઓળખાય છે.

110
00:06:03,300 --> 00:06:07,080
Argv આદેશ વાક્ય કાર્યક્રમમાંથી પસાર દલીલો સમાવે છે.

111
00:06:07,080 --> 00:06:11,440
અન્ય ટૂંકમાં, અમે કેવી રીતે વધુ વિગત આ ચલો ઉપયોગ કરવા વિશે વાત કરશે.

112
00:06:11,440 --> 00:06:15,220
હવે, તમે મુખ્ય ક્યાં માર્ગ જાહેર નિઃસંકોચ કરી શકો છો.

113
00:06:15,220 --> 00:06:19,410
હું ખાસ તે લખી બહાર કોઈ દલીલો, જ્યારે શક્ય હોય ત્યારે સાથે ટૂંકા માર્ગ પસંદ કરો.

114
00:06:19,410 --> 00:06:22,230
>> હવે તમને ખબર કેવી રીતે કાર્ય કરે છે લખવા માટે

115
00:06:22,230 --> 00:06:25,030
તમે તમારા વિશાળ, વધુ જટિલ કાર્યક્રમો વિકસાવવા માટે માર્ગ પર તેમજ છો.

116
00:06:25,030 --> 00:06:29,740
મારું નામ Nate Hardison છે. આ CS50 છે.