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

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

3
00:00:04,000 --> 00:00:07,000
[Detta är CS50 - CS50.TV]

4
00:00:07,000 --> 00:00:11,000
En användbar funktion för ett program är att acceptera användarinmatning.

5
00:00:11,000 --> 00:00:15,000
Hittills har vi utforskat vissa funktioner inom CS50 biblioteket

6
00:00:15,000 --> 00:00:18,000
att acceptera användarinmatning, såsom "få sträng,"

7
00:00:18,000 --> 00:00:23,000
som uppmanar användaren, medan programmet körs, för en sträng.

8
00:00:23,000 --> 00:00:28,000
>> Det finns dock fall där man vill ge ditt program ingång

9
00:00:28,000 --> 00:00:30,000
innan den faktiskt körs.

10
00:00:30,000 --> 00:00:34,000
På så sätt behöver du inte be ytterligare uppgifter från ditt användarnamn

11
00:00:34,000 --> 00:00:38,000
samtidigt utför en enkel uppgift.

12
00:00:38,000 --> 00:00:42,000
Ta till exempel mv eller flytta kommando i UNIX.

13
00:00:42,000 --> 00:00:49,000
Detta kommando gör det möjligt för användaren att flytta en fil från en plats till en annan.

14
00:00:49,000 --> 00:00:55,000
Enligt manualsidorna accepterar mv två kommandoradsargument:

15
00:00:55,000 --> 00:01:00,000
den fil som flyttas och platsen som filen flyttas till.

16
00:01:00,000 --> 00:01:06,000
Så detta exempel har ett kommando med två argument.

17
00:01:06,000 --> 00:01:14,000
Så hur berättar vi vår C-program för att använda dessa kommandoradsargument?

18
00:01:14,000 --> 00:01:20,000
>> Tja, visar det sig att huvud, som vi använder i alla C-program, har en hemlighet.

19
00:01:20,000 --> 00:01:26,000
Huvud accepterar två parametrar: argc och argv.

20
00:01:26,000 --> 00:01:28,000
Låt oss gå över dessa villkor.

21
00:01:28,000 --> 00:01:33,000
>> Den första parametern, argc, som står för argumentet räkna,

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

23
00:01:36,000 --> 00:01:42,000
Den argc parametern innehåller många argument, bland annat kommandot.

24
00:01:42,000 --> 00:01:47,000
I vår flytt kommando, även om vi bara har två argument visas,

25
00:01:47,000 --> 00:01:50,000
argc värde blir 3.

26
00:01:50,000 --> 00:01:56,000
Den andra parametern, argv, som står för argumentet vektor,

27
00:01:56,000 --> 00:02:01,000
är en rad röding pekare som pekar på strängar.

28
00:02:01,000 --> 00:02:06,000
>> Detta innebär att varje element i argv, utgående från noll,

29
00:02:06,000 --> 00:02:09,000
innehåller kommandot och argument.

30
00:02:09,000 --> 00:02:16,000
Till exempel argv [0], som jag ska hänvisa till som argv noll,

31
00:02:16,000 --> 00:02:20,000
alltid innehåller det kommando som körs -

32
00:02:20,000 --> 00:02:22,000
i detta fall, mv.

33
00:02:22,000 --> 00:02:28,000
argv [1] kommer att innehålla det första argumentet, file.txt,

34
00:02:28,000 --> 00:02:37,000
och argv [2] kommer att innehålla det andra argumentet, ~ / CS50 /.

35
00:02:37,000 --> 00:02:42,000
Den sista argument argv kommer alltid att vara noll.

36
00:02:42,000 --> 00:02:46,000
Så låt oss genomföra dessa kommandoradsargument.

37
00:02:46,000 --> 00:02:53,000
I tidigare övningar, placerade vi ogiltiga, dvs ingenting, som huvudsaklig s parameter.

38
00:02:53,000 --> 00:02:57,000
Men för att vi använder kommandoradsargument,

39
00:02:57,000 --> 00:03:12,000
Vi måste ta bort ogiltiga och plats inuti huvud int argc, char * argv [].

40
00:03:12,000 --> 00:03:17,000
Nu, för att komma åt hela element från argv, som är dina argument,

41
00:03:17,000 --> 00:03:21,000
Du kan enkelt iterera eller slinga, genom uppsättningen så här.

42
00:03:21,000 --> 00:03:27,000
Så inne i huvud kropp, kommer vi att gå vidare och skriva en for-loop:

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

44
00:03:37,000 --> 00:03:41,000
>> Vi behöver inte en klammerparentes här eftersom vi bara exekvera en rad kod

45
00:03:41,000 --> 00:03:44,000
i kroppen av denna slinga.

46
00:03:44,000 --> 00:03:47,000
Vi ska gå vidare och träffa flik gång,

47
00:03:47,000 --> 00:03:57,000
skriv printf ("argv [% d], för att representera ett heltal,

48
00:03:57,000 --> 00:04:06,000
är% s, för sträng och sedan den nya linjen tecknet.

49
00:04:06,000 --> 00:04:12,000
Sedan ger vi printf i för den aktuella iteration av slingan

50
00:04:12,000 --> 00:04:18,000
och argv [i] för sträng representation av den aktuella kommandoraden argument.

51
00:04:18,000 --> 00:04:25,000
När vi kör den med två argument, vi får se de argument som visas i terminalen.

52
00:04:34,000 --> 00:04:38,000
Vi har tidigare sagt att argv höll en rad röding pekare.

53
00:04:38,000 --> 00:04:45,000
>> Så, om detta är fallet, hur ska vi komma då enskilda tecken i varje argument?

54
00:04:45,000 --> 00:04:51,000
Till exempel, om jag ville leta efter ett visst tecken i det första argumentet?

55
00:04:51,000 --> 00:04:55,000
Jo, svaret är att vi måste tillämpa en kapslad slinga

56
00:04:55,000 --> 00:04:59,000
som sedan kommer att iterera igenom alla element i argumentet strängen.

57
00:04:59,000 --> 00:05:02,000
Det är hur du gör det.

58
00:05:02,000 --> 00:05:10,000
>> Först ska vi göra en kopia av example2.c.

59
00:05:10,000 --> 00:05:13,000
Därefter, insidan av den första for-slingan,

60
00:05:13,000 --> 00:05:15,000
vi kommer att lägga till en extra för slinga.

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
vilket ger oss sedan längden av den aktuella argumentet,

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

64
00:05:39,000 --> 00:05:43,000
Vi kommer att skriva ut platsen för varje tecken

65
00:05:43,000 --> 00:05:47,000
insidan av nuvarande argumentet med printf.

66
00:05:47,000 --> 00:05:57,000
Så printf ("argv [% d], för att representera index för den aktuella argumentet,

67
00:05:57,000 --> 00:06:05,000
sedan [% d] en gång för att representera det aktuella tecknet för den aktuella argumentet,

68
00:06:05,000 --> 00:06:13,000
är:% c, för den aktuella tecknet i argumentet.

69
00:06:13,000 --> 00:06:20,000
Slutligen ger vi printf med index för den yttre slingan,, jag

70
00:06:20,000 --> 00:06:22,000
då index för den inre slingan.

71
00:06:22,000 --> 00:06:28,000
>> Och vår sista argument för att printf är den faktiska karaktär från den medföljande argumentet

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

73
00:06:31,000 --> 00:06:37,000
Nu, eftersom jag använde strängen funktionen strlen att erhålla längden på en sträng,

74
00:06:37,000 --> 00:06:43,000
Jag måste också tillägga att string.h biblioteket till toppen av vår ingår.

75
00:06:43,000 --> 00:06:50,000
Så, för att göra det, vi går upp, och knappt stdio.h, vi kommer att göra

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

77
00:06:57,000 --> 00:07:02,000
>> Så, låt oss kompilera och köra och ge det ett aktuellt argument.

78
00:07:09,000 --> 00:07:18,000
>> Och som vi kan se har vi nu den exakta platsen för varje enskild röding i argumentet.

79
00:07:18,000 --> 00:07:23,000
Så det är det. Jag är Christopher Bartholomew, det är CS50.

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