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 या यूनिक्स चाल में आदेश.

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
>> 1 पैरामीटर, 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
इस मामले में, एमवी.

33
00:02:22,000 --> 00:02:28,000
argv [1] 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
आप बस पुनरावृति कर सकते हैं या इस तरह सरणी के माध्यम से पाश.

42
00:03:21,000 --> 00:03:27,000
तो, मुख्य शरीर के अंदर हम आगे जाना है और पाश के लिए एक प्रकार की जा रहे हैं:

43
00:03:27,000 --> 00:03:37,000
के लिए (int i = 0, मैं + +, मैं <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
% है, स्ट्रिंग के लिए, तो नई लाइन चरित्र.

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
फिर, अंदर पाश के लिए 1,

60
00:05:13,000 --> 00:05:15,000
हम पाश के लिए एक अतिरिक्त जोड़ने के लिए जा रहे हैं.

61
00:05:15,000 --> 00:05:28,000
तो के लिए (int j = 0, n = strlen (argv [मैं]),

62
00:05:28,000 --> 00:05:32,000
जो फिर हमें वर्तमान तर्क की लंबाई देता है,

63
00:05:32,000 --> 00:05:39,000
, जे.एन. <; 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 प्रदान करते हैं, मैं,

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]