1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Command-Line Arguments]

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

3
00:00:04,000 --> 00:00:07,000
[Dies ist CS50 - CS50.TV]

4
00:00:07,000 --> 00:00:11,000
Eine nützliche Funktion für ein Programm ist auf Benutzereingaben akzeptieren.

5
00:00:11,000 --> 00:00:15,000
Bisher haben wir einige Funktionen innerhalb der CS50-Bibliothek erkundet

6
00:00:15,000 --> 00:00:18,000
Benutzereingaben, wie anzunehmen "get Zeichenfolge"

7
00:00:18,000 --> 00:00:23,000
die den Benutzer auffordert, während die Anwendung ausgeführt wird, für einen String.

8
00:00:23,000 --> 00:00:28,000
>> Es gibt jedoch Fälle, in denen Sie Ihr Programm Input liefern wollen

9
00:00:28,000 --> 00:00:30,000
bevor es tatsächlich läuft.

10
00:00:30,000 --> 00:00:34,000
Auf diese Weise brauchen Sie nicht, um zusätzliche Informationen von Ihrem Benutzer fragen

11
00:00:34,000 --> 00:00:38,000
während der Ausführung eine einfache Aufgabe.

12
00:00:38,000 --> 00:00:42,000
Nehmen Sie zum Beispiel die mv oder MOVE-Befehl in UNIX.

13
00:00:42,000 --> 00:00:49,000
Dieser Befehl ermöglicht es dem Benutzer, eine Datei von einem Ort zum anderen zu bewegen.

14
00:00:49,000 --> 00:00:55,000
Nach den Handbuchseiten akzeptiert mv zwei Kommandozeilen-Argumente:

15
00:00:55,000 --> 00:01:00,000
Die Datei, die bewegt und die Lage der Datei wird verschoben.

16
00:01:00,000 --> 00:01:06,000
So dieses Beispiel einen Befehl mit zwei Argumenten.

17
00:01:06,000 --> 00:01:14,000
Wie können wir also sagen, unser C-Programm, um diese Befehlszeilenargumente nutzen?

18
00:01:14,000 --> 00:01:20,000
>> Nun stellt sich heraus, dass die wichtigsten, die wir in allen C-Programme, ein Geheimnis hat.

19
00:01:20,000 --> 00:01:26,000
Haupt akzeptiert zwei Parameter: argc und argv.

20
00:01:26,000 --> 00:01:28,000
Lasst uns über diese Begriffe gehen.

21
00:01:28,000 --> 00:01:33,000
>> Der erste Parameter, argc, die für argument count steht,

22
00:01:33,000 --> 00:01:36,000
hat einen Datentyp Integer.

23
00:01:36,000 --> 00:01:42,000
Die argc Parameter enthält die Anzahl der Argumente, einschließlich des Befehls.

24
00:01:42,000 --> 00:01:47,000
In unserem Fahrbefehl, obwohl wir nur haben zwei Argumente angezeigt,

25
00:01:47,000 --> 00:01:50,000
argc den Wert 3 sein.

26
00:01:50,000 --> 00:01:56,000
Der zweite Parameter, argv, die für Argument-Vektor steht,

27
00:01:56,000 --> 00:02:01,000
ist ein Array von char-Zeiger, die auf Strings.

28
00:02:01,000 --> 00:02:06,000
>> Dies bedeutet, daß jedes Element in argv, von null beginnend,

29
00:02:06,000 --> 00:02:09,000
enthält den Befehl und Argumente.

30
00:02:09,000 --> 00:02:16,000
Zum Beispiel, argv [0], die ich als argv Null beziehen,

31
00:02:16,000 --> 00:02:20,000
enthält immer den Befehl, der ausgeführt wird -

32
00:02:20,000 --> 00:02:22,000
in diesem Fall mv.

33
00:02:22,000 --> 00:02:28,000
argv [1] enthält das erste Argument, file.txt,

34
00:02:28,000 --> 00:02:37,000
und argv [2] wird das zweite Argument enthalten, ~ / CS50 /.

35
00:02:37,000 --> 00:02:42,000
Das letzte Argument argv wird immer null.

36
00:02:42,000 --> 00:02:46,000
Also lasst uns bei der Umsetzung dieser Kommandozeilen-Argumente.

37
00:02:46,000 --> 00:02:53,000
In vorangegangenen Übungen, legten wir nichtig, also nichts, als Haupt der Parameter.

38
00:02:53,000 --> 00:02:57,000
Um jedoch für uns zu nutzen Befehlszeilenargumente,

39
00:02:57,000 --> 00:03:12,000
wir brauchen für nichtig und im Inneren der wichtigsten int argc, char * argv [] entfernen.

40
00:03:12,000 --> 00:03:17,000
Nun, um das gesamte Element von argv, die Ihre Argumente sind zuzugreifen,

41
00:03:17,000 --> 00:03:21,000
Sie können einfach durchlaufen, oder eine Schleife durch das Array wie folgt.

42
00:03:21,000 --> 00:03:27,000
Also, im Inneren der wichtigsten Körper, wir gehen voran gehen und geben Sie eine for-Schleife:

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
>> Wir brauchen keine geschweiften Klammer hier, weil wir nur die Ausführung sind eine Zeile Code

45
00:03:41,000 --> 00:03:44,000
innerhalb des Körpers dieser Schleife.

46
00:03:44,000 --> 00:03:47,000
Wir machen weiter und traf Registerkarte einmal,

47
00:03:47,000 --> 00:03:57,000
dann printf geben ("argv [% d], um einen Integer-Wert repräsentieren,

48
00:03:57,000 --> 00:04:06,000
ist% s, für Streichquartett, dann wird die neue Zeile.

49
00:04:06,000 --> 00:04:12,000
Dann bieten wir printf i für die aktuelle Iteration der Schleife

50
00:04:12,000 --> 00:04:18,000
und argv [i] für die String-Darstellung des aktuellen Kommandozeilen-Argument.

51
00:04:18,000 --> 00:04:25,000
Wenn wir es laufen mit zwei Argumenten, dann sehen wir die Argumente, die im Terminal angezeigt.

52
00:04:34,000 --> 00:04:38,000
Früher haben wir gesagt, dass die argv ein Array von char-Zeiger statt.

53
00:04:38,000 --> 00:04:45,000
>> Also, wenn dies der Fall ist, wie können wir dann Zugriff auf einzelne Zeichen in jedem Argument?

54
00:04:45,000 --> 00:04:51,000
Zum Beispiel, was passiert, wenn ich für ein bestimmtes Zeichen im ersten Argument aussehen wollte?

55
00:04:51,000 --> 00:04:55,000
Nun, die Antwort ist, dass wir eine verschachtelte Schleife anwenden müssen

56
00:04:55,000 --> 00:04:59,000
das wird dann durch jedes der Elemente im Argument String durchlaufen.

57
00:04:59,000 --> 00:05:02,000
Dies ist, wie Sie es tun.

58
00:05:02,000 --> 00:05:10,000
>> Zunächst werden wir eine Kopie der beispiel2.c machen.

59
00:05:10,000 --> 00:05:13,000
Dann Innenseite der ersten zur Schleife,

60
00:05:13,000 --> 00:05:15,000
werden wir eine zusätzliche for-Schleife hinzuzufügen.

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

62
00:05:28,000 --> 00:05:32,000
das gibt uns dann die Länge des aktuellen Argument,

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

64
00:05:39,000 --> 00:05:43,000
Wir werden die Position der einzelnen Zeichen gedruckt

65
00:05:43,000 --> 00:05:47,000
Innenseite der aktuelle Argument mit printf.

66
00:05:47,000 --> 00:05:57,000
Also, printf ("argv [% d], um den Index des aktuellen Argument vertreten,

67
00:05:57,000 --> 00:06:05,000
dann [% d] noch einmal, um das aktuelle Zeichen des aktuellen Argument vertreten,

68
00:06:05,000 --> 00:06:13,000
ist:% C, für das aktuelle Zeichen das Argument.

69
00:06:13,000 --> 00:06:20,000
Schließlich sehen wir printf mit dem Index der äußeren Schleife, i,

70
00:06:20,000 --> 00:06:22,000
dann wird der Index der inneren Schleife.

71
00:06:22,000 --> 00:06:28,000
>> Und unser letztes Argument printf ist der eigentliche Charakter der Argumentation

72
00:06:28,000 --> 00:06:31,000
auf der Kommandozeile.

73
00:06:31,000 --> 00:06:37,000
Nun, da habe ich die String-Funktion strlen die Länge einer Zeichenkette zu erhalten,

74
00:06:37,000 --> 00:06:43,000
Ich muss auch noch die string.h Bibliothek der Spitze unserer enthält.

75
00:06:43,000 --> 00:06:50,000
So, das zu tun, wir gehen auf, und knapp stdio.h, wir tun

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

77
00:06:57,000 --> 00:07:02,000
>> Also, lasst uns kompilieren und laufen und es ein tatsächliches Argument.

78
00:07:09,000 --> 00:07:18,000
>> Und, wie wir sehen können, haben wir nun die genaue Position jedes einzelnen char in der Argumentation.

79
00:07:18,000 --> 00:07:23,000
Das ist es also. Ich bin Christopher Bartholomäus; dies CS50.

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