1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [દલીલો કમાન્ડ લાઇન]

2
00:00:02,000 --> 00:00:04,000
[ક્રિસ્ટોફર Bartholomew - હાર્વર્ડ યુનિવર્સિટી]

3
00:00:04,000 --> 00:00:07,000
[- CS50.TV આ CS50 છે]

4
00:00:07,000 --> 00:00:11,000
એક કાર્યક્રમ માટે ઉપયોગી લક્ષણ વપરાશકર્તા ઈનપુટ સ્વીકારતું નથી.

5
00:00:11,000 --> 00:00:15,000
આમ અત્યાર સુધીમાં અમે CS50 પુસ્તકાલય અંદર કેટલાક કાર્યો સંશોધન કર્યું છે

6
00:00:15,000 --> 00:00:18,000
માટે જેમ કે વપરાશકર્તા ઈનપુટ સ્વીકાર, "શબ્દમાળા મેળવવા માટે,"

7
00:00:18,000 --> 00:00:23,000
જે વપરાશકર્તા પૂછે છે, જ્યારે અરજી ચાલી રહ્યું છે એક શબ્દમાળા માટે.

8
00:00:23,000 --> 00:00:28,000
>> જો કે, ત્યાં કિસ્સાઓ છે કે જ્યાં તમે તમારા કાર્યક્રમ ઇનપુટ આપવા માંગો છો

9
00:00:28,000 --> 00:00:30,000
પહેલાં તે વાસ્તવમાં ચાલી રહી છે.

10
00:00:30,000 --> 00:00:34,000
આ રીતે, તમે તમારા વપરાશકર્તા પાસેથી વધારાની માહિતી પૂછી જરૂર નથી

11
00:00:34,000 --> 00:00:38,000
જ્યારે એ સાદી ક્રિયા ચલાવવા.

12
00:00:38,000 --> 00:00:42,000
ઉદાહરણ તરીકે લો, કે mv અથવા UNIX માં ચાલ આદેશ.

13
00:00:42,000 --> 00:00:49,000
આ આદેશ વપરાશકર્તા એક સ્થળેથી બીજા એક ફાઇલ ખસેડવા માટે પરવાનગી આપે છે.

14
00:00:49,000 --> 00:00:55,000
જાતે પૃષ્ઠો અનુસાર, mv બે આદેશ વાક્ય દલીલો સ્વીકારે છે:

15
00:00:55,000 --> 00:01:00,000
તે ફાઇલ ખસેડવામાં આવી રહ્યો છે અને સ્થાન માટે ફાઈલ ખસેડવામાં આવી રહ્યો છે.

16
00:01:00,000 --> 00:01:06,000
તેથી આ ઉદાહરણ બે દલીલો સાથે આદેશ છે.

17
00:01:06,000 --> 00:01:14,000
તેથી અમે કેવી રીતે અમારી સી કાર્યક્રમને કહેવું નથી આ આદેશ વાક્ય દલીલો ઉપયોગ કરે છે?

18
00:01:14,000 --> 00:01:20,000
>> વેલ, તે તારણ છે કે જે મુખ્ય છે, જે અમે તમામ સી કાર્યક્રમો ઉપયોગ એક ગુપ્ત હોય છે.

19
00:01:20,000 --> 00:01:26,000
Argc અને argv: મુખ્ય બે પરિમાણો સ્વીકારે છે.

20
00:01:26,000 --> 00:01:28,000
ચાલો આ શબ્દો પર જાઓ.

21
00:01:28,000 --> 00:01:33,000
>> પ્રથમ પરિમાણ, argc, જે દલીલ ગણતરી માટે વપરાય છે,

22
00:01:33,000 --> 00:01:36,000
પૂર્ણાંક એક માહિતી પ્રકાર છે.

23
00:01:36,000 --> 00:01:42,000
આ argc પરિમાણ દલીલો સંખ્યા આદેશ સમાવેશ થાય છે, સમાવે છે.

24
00:01:42,000 --> 00:01:47,000
અમારા ચાલ આદેશ, જો કે અમે માત્ર બે દલીલો દર્શાવી છે,

25
00:01:47,000 --> 00:01:50,000
માતાનો argc કિંમત 3 હશે.

26
00:01:50,000 --> 00:01:56,000
બીજા પરિમાણ, argv, જે દલીલ વેક્ટર માટે વપરાય છે,

27
00:01:56,000 --> 00:02:01,000
ઘરનાં પરચૂરણ કામો પોઇંટરો કે શબ્દમાળાઓ માટે નિર્દેશ ઝાકઝમાળ છે.

28
00:02:01,000 --> 00:02:06,000
>> આનો અર્થ એ થાય કે argv દરેક તત્વ, શૂન્યથી શરૂ કરીને,

29
00:02:06,000 --> 00:02:09,000
આદેશ અને દલીલો સમાવે છે.

30
00:02:09,000 --> 00:02:16,000
ઉદાહરણ તરીકે, argv [0] છે, કે જે હું શૂન્ય argv તરીકે નો સંદર્ભ લો પડશે,

31
00:02:16,000 --> 00:02:20,000
હંમેશા આદેશ કે સ્કોર રહી છે સમાવશે -

32
00:02:20,000 --> 00:02:22,000
આ કિસ્સામાં, mv.

33
00:02:22,000 --> 00:02:28,000
argv [1] પ્રથમ દલીલ, file.txt સમાવશે,

34
00:02:28,000 --> 00:02:37,000
અને argv [2] બીજી દલીલ સમાવશે / ~ / cs50.

35
00:02:37,000 --> 00:02:42,000
Argv ના છેલ્લા દલીલ હંમેશાં નલ હશે.

36
00:02:42,000 --> 00:02:46,000
તેથી આપણે આ આદેશ વાક્ય દલીલો અમલ.

37
00:02:46,000 --> 00:02:53,000
અગાઉના કસરતો, અમે રદબાતલ મૂકવામાં, કંઇ જેનો અર્થ એ મુખ્ય પરિમાણ તરીકે.

38
00:02:53,000 --> 00:02:57,000
જોકે, અમારા માટે આદેશ વાક્ય દલીલો ઉપયોગ કરવા માટે,

39
00:02:57,000 --> 00:03:12,000
અમે મુખ્ય પૂર્ણાંક argc, ચાર * argv] [ઓફ રદબાતલ અને સ્થળ અંદર દૂર કરવાની જરૂર છે.

40
00:03:12,000 --> 00:03:17,000
હવે argv ના સમગ્ર તત્વ છે, કે જે તમારી દલીલો છે ઍક્સેસ,

41
00:03:17,000 --> 00:03:21,000
તમે ખાલી ફરી વળવું શકો છો, અથવા આ લૂપ જેવા એરે મારફતે.

42
00:03:21,000 --> 00:03:27,000
તેથી, તે મુખ્ય શરીરના અંદર, અમે આગળ વધીશું અને લૂપ માટે ટાઇપ જઈ રહ્યાં છો:

43
00:03:27,000 --> 00:03:37,000
માટે (પૂર્ણાંક હું = 0; i + +; i <argc).

44
00:03:37,000 --> 00:03:41,000
>> અમે એક સર્પાકાર તાણવું અહીં જરૂર નથી કારણ કે અમે માત્ર કોડ એક વાક્ય ચલાવવા કરી રહ્યાં છો

45
00:03:41,000 --> 00:03:44,000
આ લૂપની શરીરની અંદર.

46
00:03:44,000 --> 00:03:47,000
અમે આગળ વધીશું અને ટેબ એકવાર ફટકો પડશે,

47
00:03:47,000 --> 00:03:57,000
પછી printf લખો ("argv [% d], એક પૂર્ણાંક કિંમત પ્રતિનિધિત્વ કરે છે,

48
00:03:57,000 --> 00:04:06,000
% s છે, શબ્દમાળા માટે, પછી નવી લીટી પાત્ર.

49
00:04:06,000 --> 00:04:12,000
તો પછી અમે printf પૂરી પાડવા હું લૂપ ના વર્તમાન પુનરાવૃત્તિ માટે

50
00:04:12,000 --> 00:04:18,000
અને argv [i] વર્તમાન દલીલ આદેશ લીટી શબ્દમાળા પ્રતિનિધિત્વ કરે છે.

51
00:04:18,000 --> 00:04:25,000
જ્યારે અમે તે બે દલીલો સાથે ચલાવવા માટે, અમે આવી રહી ટર્મિનલ પ્રદર્શિત દલીલો જોશો.

52
00:04:34,000 --> 00:04:38,000
અગાઉ અમે જણાવ્યું હતું કે argv ઘરનાં પરચૂરણ કામો પોઇંટરો ઝાકઝમાળ યોજાઇ હતી.

53
00:04:38,000 --> 00:04:45,000
>> તેથી, જો આ કિસ્સો હોય, તો અમે તે પછી કેવી રીતે કરી શકું દરેક દલીલ વ્યક્તિગત અક્ષરો ઍક્સેસ?

54
00:04:45,000 --> 00:04:51,000
ઉદાહરણ તરીકે, જો મને પ્રથમ દલીલ ચોક્કસ અક્ષર જોવા માટે માગે છે?

55
00:04:51,000 --> 00:04:55,000
વેલ, તો જવાબ છે કે અમે એક નેસ્ટેડ લૂપ અરજી કરવાની રહેશે

56
00:04:55,000 --> 00:04:59,000
કે પછી દલીલ શબ્દમાળા માં તત્વો દરેક મારફતે ફરી વળવું પડશે.

57
00:04:59,000 --> 00:05:02,000
આ રીતે તમે તે કરી.

58
00:05:02,000 --> 00:05:10,000
>> પ્રથમ, અમે example2.c એક નકલ કરી રહ્યા છીએ.

59
00:05:10,000 --> 00:05:13,000
પછી, અંદર લૂપ માટે પ્રથમ,

60
00:05:13,000 --> 00:05:15,000
અમે લૂપ માટે વધારાની ઉમેરવા જઈ રહ્યાં છો.

61
00:05:15,000 --> 00:05:28,000
તેથી (પૂર્ણાંક જ = 0, એન strlen = (argv [i]),

62
00:05:28,000 --> 00:05:32,000
જે પછી અમને વર્તમાન દલીલ લંબાઈ આપે છે,

63
00:05:32,000 --> 00:05:39,000
; જ ન <; જ + +)

64
00:05:39,000 --> 00:05:43,000
અમે દરેક પાત્ર સ્થાન છાપી રહ્યા છીએ

65
00:05:43,000 --> 00:05:47,000
printf ઉપયોગ કરીને વર્તમાન દલીલ ની અંદર.

66
00:05:47,000 --> 00:05:57,000
તેથી, printf ("argv [% d], તો વર્તમાન દલીલ ઇન્ડેક્સ પ્રતિનિધિત્વ કરે છે,

67
00:05:57,000 --> 00:06:05,000
પછી [% d] ફરી એક વાર કરવા માટે, વર્તમાન દલીલ ચાલુ અક્ષર પ્રતિનિધિત્વ કરે છે,

68
00:06:05,000 --> 00:06:13,000
% c દલીલ માં વર્તમાન પાત્ર માટે, છે.

69
00:06:13,000 --> 00:06:20,000
છેલ્લે, અમે બાહ્ય લૂપની ઇન્ડેક્સ સાથે printf પૂરી પાડે છે, આઇ,

70
00:06:20,000 --> 00:06:22,000
પછી આંતરિક લૂપ ના ઇન્ડેક્સ.

71
00:06:22,000 --> 00:06:28,000
>> અને અમારા છેલ્લા દલીલ printf પ્રદાન દલીલ ના વાસ્તવિક પાત્ર છે

72
00:06:28,000 --> 00:06:31,000
આદેશ વાક્ય પર.

73
00:06:31,000 --> 00:06:37,000
હવે, હું શબ્દમાળા strlen કાર્ય માટે વાપરી શબ્દમાળા લંબાઈ મેળવવા કારણ કે,

74
00:06:37,000 --> 00:06:43,000
હું પણ અમારી સમાવેશ થાય ટોચ માટે string.h પુસ્તકાલય ઉમેરવું જ જોઈએ.

75
00:06:43,000 --> 00:06:50,000
તેથી, કે કરવા માટે, અમે જાઓ, અને પડશે stdio.h હેઠળ માત્ર, અમે કરવા જઈ રહ્યાં છો

76
00:06:50,000 --> 00:06:57,000
# <string.h> સમાવેશ થાય છે.

77
00:06:57,000 --> 00:07:02,000
>> તેથી, ચાલો કમ્પાઇલ અને ચલાવો અને તે વાસ્તવિક દલીલ પૂરી પાડે છે.

78
00:07:09,000 --> 00:07:18,000
>> અને, આપણે જોઈ શકો છો, અમે હવે દલીલ માં દરેક વ્યક્તિગત ઘરનાં પરચૂરણ કામો ની ચોક્કસ સ્થાન હોય છે.

79
00:07:18,000 --> 00:07:23,000
જેથી તે છે. હું ક્રિસ્ટોફર Bartholomew છું; આ CS50 છે.

80
00:07:23,000 --> 00:07:26,000
[CS50.TV]