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  -  CS50.TV]

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
举个例子，在UNIX的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
那么，我们如何告诉我们的C程序来使用这些命令行参数？

18
00:01:14,000 --> 00:01:20,000
>> 哦，原来是主要的，这是我们在所有的C程序中使用，有一个秘密。

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
在这种情况下，毫伏。

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
，里面的主的身体，我们要继续前进，然后键入一个for循环：

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
然后输入输出（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
然后，在第一个for循环，

60
00:05:13,000 --> 00:05:15,000
我们要添加一个额外的循环。

61
00:05:15,000 --> 00:05:28,000
因此，对于（J = 0，N = strlen的（的argv []）

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
是：％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
>> 而我们的最后一个参数为输出的参数是实际的字符

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]