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
Според справочните страници, 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
>> Е, оказва се, че основното, което ние използваме във всички програми на 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
ние трябва да премахнете невалидни и място за вътрешността на главния 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; 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
след това въведете ФОРМАТ ("argv [% г], да представлява цяло число стойност,

48
00:03:57,000 --> 00:04:06,000
%, за низ, а след това новата линия характер.

49
00:04:06,000 --> 00:04:12,000
Тогава ние предлагаме ФОРМАТ за текущата итерация на цикъла

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, N = strlen (argv []),

62
00:05:28,000 --> 00:05:32,000
които след това ни дава дължината на текущата аргумент,

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

64
00:05:39,000 --> 00:05:43,000
Отиваме да отпечатате местоположението на всеки един от героите

65
00:05:43,000 --> 00:05:47,000
във вътрешността на текущия спор с помощта ФОРМАТ.

66
00:05:47,000 --> 00:05:57,000
Така че, ФОРМАТ ("argv [% г], да представлява индексът на текущата аргумент,

67
00:05:57,000 --> 00:06:05,000
[% г] отново, за да представят на текущия символ на текущия спор,

68
00:06:05,000 --> 00:06:13,000
е:% C, за текущия символ в спора.

69
00:06:13,000 --> 00:06:20,000
На последно място, ние предлагаме ФОРМАТ с индекса на външния контур, аз

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]