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.

13
00:00:42,000 --> 00:00:49,000
Эта команда позволяет пользователю перемещать файлы из одного места в другое.

14
00:00:49,000 --> 00:00:55,000
По словам руководства страниц, М. В. принимает два аргумента командной строки:

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
>> Первый параметр, агдс, что означает количество аргументов,

22
00:01:33,000 --> 00:01:36,000
имеет тип данных целое число.

23
00:01:36,000 --> 00:01:42,000
Агдс параметр содержит число аргументов, в том числе команды.

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
нам нужно удалить недействительным и место внутри основного Int агдс, символ * 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 = 0; 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
затем введите Е ("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 [я] для строковое представление текущего аргумента командной строки.

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
Таким образом, для (Int J = 0, п = StrLen (ARGV [я]),

62
00:05:28,000 --> 00:05:32,000
, который затем дает нам длину текущего аргумента,

63
00:05:32,000 --> 00:05:39,000
, J <п, 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
Таким образом, Е ("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
Так вот оно что. Я Кристофера Варфоломей, это CS50.

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