1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [ఆదేశ పంక్తి వాదనలు]

2
00:00:02,000 --> 00:00:04,000
[క్రిస్టోఫర్ బర్తలోమ్యోవ్ - హార్వర్డ్ యూనివర్శిటీ]

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
మేము ప్రధాన Int argc, చార్ * argv [] యొక్క తప్ప మరియు స్థానం లోపల తొలగించాలి.

40
00:03:12,000 --> 00:03:17,000
ఇప్పుడు, మీ వాదనలు ఇది argv నుండి మొత్తం మూలకం, యాక్సెస్ చెయ్యడానికి,

41
00:03:17,000 --> 00:03:21,000
మీరు ఈ విధంగా అమరిక ద్వారా, iterate, లేదా లూప్ చేయవచ్చు.

42
00:03:21,000 --> 00:03:27,000
కాబట్టి, లోపల ప్రధాన శరీరం, మేము ముందుకు వెళ్లి, లూప్ ఒక టైప్ చూడాలని:

43
00:03:27,000 --> 00:03:37,000
కోసం (Int i = 0; i <argc; i + +).

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
Well, సమాధానం మేము ఒక సమూహ లూప్ దరఖాస్తు అవసరం ఉంది

56
00:04:55,000 --> 00:04:59,000
ఆ తర్వాత వాదన స్ట్రింగ్ లో అంశాల ప్రతి ద్వారా iterate కనిపిస్తుంది.

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
కాబట్టి కోసం (ఇంట్ J = 0, n = strlen (argv [i]),

62
00:05:28,000 --> 00:05:32,000
ఇది, మాకు ప్రస్తుత వాదన యొక్క పొడవు ఇస్తుంది

63
00:05:32,000 --> 00:05:39,000
; J <n; j + +)

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
ఉంది:% సి, వాదన ప్రస్తుత పాత్ర కోసం.

69
00:06:13,000 --> 00:06:20,000
చివరగా, మేము బయటి లూప్ యొక్క ఇండెక్స్ తో printf అందించడానికి, i,

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
కాబట్టి అంతే. నేను క్రిస్టోఫర్ బర్తలోమ్యోవ్ ఉన్నాను; ఈ CS50 ఉంది.

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