1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Kommandolinjeargumenter]

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

3
00:00:04,000 --> 00:00:07,000
[Dette er CS50 - CS50.TV]

4
00:00:07,000 --> 00:00:11,000
En nyttig funktion for et program er at acceptere brugerinput.

5
00:00:11,000 --> 00:00:15,000
Indtil videre har vi undersøgt nogle funktioner inden for CS50 biblioteket

6
00:00:15,000 --> 00:00:18,000
at acceptere brugerinput, såsom "få strengen"

7
00:00:18,000 --> 00:00:23,000
som beder brugeren, mens programmet kører, efter en streng.

8
00:00:23,000 --> 00:00:28,000
>> Men der er tilfælde, hvor du ønsker at give dit program input

9
00:00:28,000 --> 00:00:30,000
før det rent faktisk kører.

10
00:00:30,000 --> 00:00:34,000
På denne måde behøver du ikke at spørge yderligere oplysninger fra din bruger

11
00:00:34,000 --> 00:00:38,000
under udførelse af en enkel opgave.

12
00:00:38,000 --> 00:00:42,000
Tag for eksempel mv eller flytte kommandoen i UNIX.

13
00:00:42,000 --> 00:00:49,000
Denne kommando gør det muligt at flytte en fil fra et sted til et andet.

14
00:00:49,000 --> 00:00:55,000
Ifølge de manualsider, accepterer mv to kommandolinjeargumenter:

15
00:00:55,000 --> 00:01:00,000
den fil, der flyttes, og placeringen af ​​filen bliver flyttet til.

16
00:01:00,000 --> 00:01:06,000
Så dette eksempel har en kommando med to argumenter.

17
00:01:06,000 --> 00:01:14,000
Så hvordan kan vi fortælle vores C-program til at udnytte disse kommandolinjeargumenter?

18
00:01:14,000 --> 00:01:20,000
>> Tja, det viser sig, at main, som vi bruger i alle C-programmer, har en hemmelighed.

19
00:01:20,000 --> 00:01:26,000
Main accepterer to parametre: argc og argv.

20
00:01:26,000 --> 00:01:28,000
Lad os gå over disse vilkår.

21
00:01:28,000 --> 00:01:33,000
>> Den første parameter, argc, der står for argument tæller,

22
00:01:33,000 --> 00:01:36,000
har en datatype heltal.

23
00:01:36,000 --> 00:01:42,000
Den argc parameter indeholder antallet af argumenter, herunder kommando.

24
00:01:42,000 --> 00:01:47,000
I vores flytte kommandoen, selvom vi kun har to argumenter vist

25
00:01:47,000 --> 00:01:50,000
argc værdi vil være 3.

26
00:01:50,000 --> 00:01:56,000
Den anden parameter, argv, der står for argument vektor,

27
00:01:56,000 --> 00:02:01,000
er en vifte af char pegepinde, der peger på strenge.

28
00:02:01,000 --> 00:02:06,000
>> Dette betyder, at hvert element i argv, fra nul,

29
00:02:06,000 --> 00:02:09,000
indeholder kommandoen og argumenter.

30
00:02:09,000 --> 00:02:16,000
For eksempel, argv [0], som jeg vil henvise til som argv nul,

31
00:02:16,000 --> 00:02:20,000
vil altid indeholde kommandoen der køres -

32
00:02:20,000 --> 00:02:22,000
i dette tilfælde. mv

33
00:02:22,000 --> 00:02:28,000
argv [1] vil indeholde det første argument, file.txt,

34
00:02:28,000 --> 00:02:37,000
og argv [2] vil indeholde det andet argument, ~ / CS50 /.

35
00:02:37,000 --> 00:02:42,000
Den sidste argument argv vil altid være null.

36
00:02:42,000 --> 00:02:46,000
Så lad os gennemføre disse kommandolinjeargumenter.

37
00:02:46,000 --> 00:02:53,000
I tidligere øvelser, placeret vi ugyldig, betyder ingenting, som vigtigste er parameter.

38
00:02:53,000 --> 00:02:57,000
Men for for os at bruge kommandolinje-argumenter,

39
00:02:57,000 --> 00:03:12,000
vi nødt til at fjerne ugyldige og sted inde i main int argc, char * argv [].

40
00:03:12,000 --> 00:03:17,000
Nu, at få adgang til hele elementet fra argv, som er dine argumenter,

41
00:03:17,000 --> 00:03:21,000
kan du blot gentage, eller loop gennem arrayet som denne.

42
00:03:21,000 --> 00:03:27,000
Så inde i hoved krop, vil vi gå videre og skriv en for-løkke:

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
>> Vi har ikke brug for en klammeparentes her, fordi vi kun udføre én linje kode

45
00:03:41,000 --> 00:03:44,000
inden i legemet af denne sløjfe.

46
00:03:44,000 --> 00:03:47,000
Vi vil gå videre og ramte fanen én gang,

47
00:03:47,000 --> 00:03:57,000
derefter skrive printf ("argv [% d], til at repræsentere et heltal værdi,

48
00:03:57,000 --> 00:04:06,000
er% s, for streng, så den nye linje karakter.

49
00:04:06,000 --> 00:04:12,000
Så vi giver printf i for den aktuelle iteration af løkken

50
00:04:12,000 --> 00:04:18,000
og argv [i] efter strengen repræsentation af den aktuelle kommando-line argument.

51
00:04:18,000 --> 00:04:25,000
Når vi kører den med to argumenter, vil vi se de argumenter, der vises i terminalen.

52
00:04:34,000 --> 00:04:38,000
Tidligere sagde vi, at argv holdt en række char pointers.

53
00:04:38,000 --> 00:04:45,000
>> Så hvis dette er tilfældet, hvordan kan vi så få adgang til enkelte tegn i hvert argument?

54
00:04:45,000 --> 00:04:51,000
For eksempel, hvad hvis jeg ønskede at lede efter et bestemt tegn i den første argument

55
00:04:51,000 --> 00:04:55,000
Tja, svaret er, at vi er nødt til at anvende en indlejret løkke

56
00:04:55,000 --> 00:04:59,000
der vil så gentage gennem hver af elementerne i argumentet strengen.

57
00:04:59,000 --> 00:05:02,000
Dette er, hvordan du gør det.

58
00:05:02,000 --> 00:05:10,000
>> Først vil vi lave en kopi af example2.c.

59
00:05:10,000 --> 00:05:13,000
Derefter indersiden af ​​den første for-løkken,

60
00:05:13,000 --> 00:05:15,000
vi vil tilføje en ekstra for-løkke.

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

62
00:05:28,000 --> 00:05:32,000
som derefter giver os længden af ​​den aktuelle argument,

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

64
00:05:39,000 --> 00:05:43,000
Vi kommer til at udskrive placeringen af ​​hvert tegn

65
00:05:43,000 --> 00:05:47,000
indersiden af ​​den aktuelle argument ved hjælp printf.

66
00:05:47,000 --> 00:05:57,000
Så printf ("argv [% d], til at repræsentere indekset for den aktuelle argument,

67
00:05:57,000 --> 00:06:05,000
derefter [% d] igen for at repræsentere den aktuelle karakter af den nuværende argument,

68
00:06:05,000 --> 00:06:13,000
er:% c, for det aktuelle tegn i argumentet.

69
00:06:13,000 --> 00:06:20,000
Endelig giver vi printf med indekset for den ydre løkke, i,

70
00:06:20,000 --> 00:06:22,000
derefter indekset for den indre sløjfes.

71
00:06:22,000 --> 00:06:28,000
>> Og vores sidste argument til printf er den faktiske tegn fra den argument

72
00:06:28,000 --> 00:06:31,000
på kommandolinjen.

73
00:06:31,000 --> 00:06:37,000
Nu, fordi jeg brugte den streng funktionen strlen at få længden af ​​en streng,

74
00:06:37,000 --> 00:06:43,000
Jeg må også tilføje string.h bibliotek til toppen af ​​vores inkluderer.

75
00:06:43,000 --> 00:06:50,000
Så for at gøre det, vil vi gå op, og lige under stdio.h, vi vil gøre

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

77
00:06:57,000 --> 00:07:02,000
>> Så lad os kompilere og køre og give det et virkeligt argument.

78
00:07:09,000 --> 00:07:18,000
>> Og som vi kan se, har vi nu den nøjagtige placering af hver enkelt char i argumentet.

79
00:07:18,000 --> 00:07:23,000
Så det er det. Jeg er Christopher Bartholomew, det er CS50.

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