1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Argumenty wiersza polecenia]

2
00:00:02,000 --> 00:00:04,000
[Christopher Bartholomew - Harvard University]

3
00:00:04,000 --> 00:00:07,000
[To jest CS50 - CS50.TV]

4
00:00:07,000 --> 00:00:11,000
Przydatna funkcja dla programu jest, aby zaakceptować wprowadzone przez użytkownika.

5
00:00:11,000 --> 00:00:15,000
Jak dotąd, mamy zbadać pewne funkcje w CS50 bibliotece

6
00:00:15,000 --> 00:00:18,000
aby zaakceptować wprowadzone przez użytkownika, takie jak "dostać ciąg"

7
00:00:18,000 --> 00:00:23,000
który pyta użytkownika, podczas gdy aplikacja jest uruchomiona, na sznurku.

8
00:00:23,000 --> 00:00:28,000
>> Istnieją jednak przypadki, gdy chcesz zapewnić swój wkład programu

9
00:00:28,000 --> 00:00:30,000
zanim zostanie ona uruchomiona.

10
00:00:30,000 --> 00:00:34,000
W ten sposób, nie trzeba prosić o dodatkowe informacje od użytkownika

11
00:00:34,000 --> 00:00:38,000
podczas wykonywania prostego zadania.

12
00:00:38,000 --> 00:00:42,000
Weźmy, na przykład, MV lub polecenia poruszać się w systemie UNIX.

13
00:00:42,000 --> 00:00:49,000
Polecenie to pozwala użytkownikowi przenieść plik z jednego miejsca do drugiego.

14
00:00:49,000 --> 00:00:55,000
Według stron podręcznika, mv przyjmuje dwa argumenty wiersza poleceń:

15
00:00:55,000 --> 00:01:00,000
Plik, który jest w ruchu i lokalizacji plik jest przeniesiony do.

16
00:01:00,000 --> 00:01:06,000
Więc ten przykład ma polecenie z dwoma argumentami.

17
00:01:06,000 --> 00:01:14,000
Jak więc powiedzieć nasz program C wykorzystać te argumenty wiersza polecenia?

18
00:01:14,000 --> 00:01:20,000
>> Cóż, okazuje się, że główną, którego używamy we wszystkich programach w C, ma sekret.

19
00:01:20,000 --> 00:01:26,000
Główne dwa parametry: argc i argv.

20
00:01:26,000 --> 00:01:28,000
Chodźmy na te warunki.

21
00:01:28,000 --> 00:01:33,000
>> Pierwszy parametr, argc, co jest skrótem od liczby argumentów,

22
00:01:33,000 --> 00:01:36,000
ma typ danych integer.

23
00:01:36,000 --> 00:01:42,000
Argc parametr zawiera liczbę argumentów, w tym poleceniu.

24
00:01:42,000 --> 00:01:47,000
W naszym polecenia przesunięcia, choć mamy tylko dwa argumenty wyświetlane,

25
00:01:47,000 --> 00:01:50,000
wartość argc będzie wynosić 3.

26
00:01:50,000 --> 00:01:56,000
Drugi parametr, argv, co oznacza wektor argumentów,

27
00:01:56,000 --> 00:02:01,000
jest tablicą char wskaźniki które wskazują na strunach.

28
00:02:01,000 --> 00:02:06,000
>> Oznacza to, że każdy element argv począwszy od zera,

29
00:02:06,000 --> 00:02:09,000
zawiera polecenia i argumenty.

30
00:02:09,000 --> 00:02:16,000
Na przykład, argv [0], które ja określam jako argv zero

31
00:02:16,000 --> 00:02:20,000
zawsze zawiera polecenie, które zostało uruchomione -

32
00:02:20,000 --> 00:02:22,000
w tym przypadku, mV.

33
00:02:22,000 --> 00:02:28,000
argv [1] będzie zawierać pierwszy argument, plik.txt,

34
00:02:28,000 --> 00:02:37,000
i argv [2] należy do drugiego argumentu, ~ / CS50 /.

35
00:02:37,000 --> 00:02:42,000
Ostatni argument argv zawsze będzie null.

36
00:02:42,000 --> 00:02:46,000
Warto więc wdrożyć te argumenty wiersza poleceń.

37
00:02:46,000 --> 00:02:53,000
W poprzednich ćwiczeniach, umieściliśmy pustkę, czyli nic, jako parametr funkcji main.

38
00:02:53,000 --> 00:02:57,000
Jednakże, w celu dla nas do wykorzystania argumentów linii poleceń,

39
00:02:57,000 --> 00:03:12,000
musimy usunąć wewnętrzną pustkę i miejsce głównej int argc, char * argv [].

40
00:03:12,000 --> 00:03:17,000
Teraz, by przejść cały element z argv, które są twoje argumenty,

41
00:03:17,000 --> 00:03:21,000
można po prostu iteracyjne lub pętla, przez tablicę jak ta.

42
00:03:21,000 --> 00:03:27,000
Tak, wewnątrz korpusu głównego, my będziemy iść dalej i wpisz pętli for:

43
00:03:27,000 --> 00:03:37,000
for (int i = 0; i <argc; i + +).

44
00:03:37,000 --> 00:03:41,000
>> My nie potrzebujemy nawias klamrowy tutaj, ponieważ jesteśmy tylko wykonanie jednej linii kodu

45
00:03:41,000 --> 00:03:44,000
w części tej pętli.

46
00:03:44,000 --> 00:03:47,000
Idziemy do przodu i uderzył kartę raz,

47
00:03:47,000 --> 00:03:57,000
następnie wpisz printf ("argv [% d], do reprezentowania wartość całkowitą,

48
00:03:57,000 --> 00:04:06,000
% s, na łańcuch, a następnie znak nowego wiersza.

49
00:04:06,000 --> 00:04:12,000
Następnie dostarcza printf I dla bieżącej iteracji

50
00:04:12,000 --> 00:04:18,000
i argv [i] dla reprezentacji ciąg bieżącego argument wiersza polecenia.

51
00:04:18,000 --> 00:04:25,000
Kiedy go uruchomić z dwoma argumentami, zobaczymy argumenty są wyświetlane w panelu.

52
00:04:34,000 --> 00:04:38,000
Wcześniej powiedział, że argv odbyło tablicę char wskaźniki.

53
00:04:38,000 --> 00:04:45,000
>> Tak więc, jeśli jest to przypadek, w jaki sposób, a następnie dostęp do poszczególnych znaków w każdym argument?

54
00:04:45,000 --> 00:04:51,000
Na przykład, co jeśli chcę szukać szczególnym charakterze pierwszego argumentu?

55
00:04:51,000 --> 00:04:55,000
Cóż, odpowiedź jest taka, że ​​musimy zastosować pętlę zagnieżdżoną

56
00:04:55,000 --> 00:04:59,000
które będą następnie iterację wszystkich elementów w argumencie.

57
00:04:59,000 --> 00:05:02,000
Jest to, jak to zrobić.

58
00:05:02,000 --> 00:05:10,000
>> Po pierwsze, mamy zamiar zrobić kopię example2.c.

59
00:05:10,000 --> 00:05:13,000
Potem, w środku pierwszej pętli for

60
00:05:13,000 --> 00:05:15,000
mamy zamiar dodać dodatkowe pętli for.

61
00:05:15,000 --> 00:05:28,000
Tak for (int j = 0, n = strlen (argv [i]),

62
00:05:28,000 --> 00:05:32,000
które następnie daje nam długość bieżącego argumentu

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

64
00:05:39,000 --> 00:05:43,000
Mamy zamiar wydrukować położenie każdego znaku

65
00:05:43,000 --> 00:05:47,000
wewnątrz bieżącego argumentu używając printf.

66
00:05:47,000 --> 00:05:57,000
Więc, printf ("argv [% d], do reprezentowania indeksu bieżącego argumentu

67
00:05:57,000 --> 00:06:05,000
następnie [% d] po raz kolejny, do reprezentowania aktualny znak aktualnego argumentu

68
00:06:05,000 --> 00:06:13,000
to: c%, w bieżącym znaku w argumencie.

69
00:06:13,000 --> 00:06:20,000
Wreszcie, oferujemy printf z indeksu zewnętrznej pętli, i,

70
00:06:20,000 --> 00:06:22,000
to indeks pętli wewnętrznej.

71
00:06:22,000 --> 00:06:28,000
>> I nasz ostatni argument printf jest rzeczywistą postać z dostarczonej argumentu

72
00:06:28,000 --> 00:06:31,000
w wierszu poleceń.

73
00:06:31,000 --> 00:06:37,000
Teraz, ponieważ użyłem funkcji ciąg strlen uzyskać długość łańcucha,

74
00:06:37,000 --> 00:06:43,000
Muszę również dodać string.h bibliotekę do góry nasz obejmuje.

75
00:06:43,000 --> 00:06:50,000
Tak więc, aby to zrobić, pójdziemy w górę i tuż pod stdio.h, będziemy robić

76
00:06:50,000 --> 00:06:57,000
# Include <string.h>.

77
00:06:57,000 --> 00:07:02,000
>> No to skompilować i uruchomić i zapewnić mu rzeczywistą argument.

78
00:07:09,000 --> 00:07:18,000
>> I, jak widać, mamy dokładną lokalizację każdego znaku w argumencie.

79
00:07:18,000 --> 00:07:23,000
Więc to jest to. Jestem Krzysztof Bartłomiej, to CS50.

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