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 funksjon for et program er å akseptere brukerens input.

5
00:00:11,000 --> 00:00:15,000
Så langt har vi utforsket noen funksjoner innenfor CS50 bibliotek

6
00:00:15,000 --> 00:00:18,000
å akseptere brukerens input, for eksempel "få streng,"

7
00:00:18,000 --> 00:00:23,000
som ber brukeren, mens programmet kjører, for en streng.

8
00:00:23,000 --> 00:00:28,000
>> Men det er tilfeller hvor du ønsker å gi programmet innspill

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

10
00:00:30,000 --> 00:00:34,000
Denne måten, trenger du ikke å spørre tilleggsinformasjon fra brukeren din

11
00:00:34,000 --> 00:00:38,000
mens utføre en enkel oppgave.

12
00:00:38,000 --> 00:00:42,000
Ta for eksempel MV eller flytte kommando i UNIX.

13
00:00:42,000 --> 00:00:49,000
Denne kommandoen lar brukeren å flytte en fil fra ett sted til et annet.

14
00:00:49,000 --> 00:00:55,000
Ifølge de manuelle sider, aksepterer mv to kommandolinjeargumenter:

15
00:00:55,000 --> 00:01:00,000
filen som flyttes og plasseringen filen blir flyttet til.

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

17
00:01:06,000 --> 00:01:14,000
Så hvordan forteller vi våre C-program for å utnytte disse kommandolinjeargumenter?

18
00:01:14,000 --> 00:01:20,000
>> Vel, det viser seg at main, som vi bruker i alle C-programmer, har en hemmelighet.

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

20
00:01:26,000 --> 00:01:28,000
La oss gå over disse vilkårene.

21
00:01:28,000 --> 00:01:33,000
>> Den første parameteren, argc, som står for argument teller,

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

23
00:01:36,000 --> 00:01:42,000
Den argc parameteren inneholder antall argumenter, inkludert kommandoen.

24
00:01:42,000 --> 00:01:47,000
I vår flytte kommandoen, selv om vi bare har to argumenter vises,

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

26
00:01:50,000 --> 00:01:56,000
Den andre parameteren, argv, som står for argument vektor,

27
00:01:56,000 --> 00:02:01,000
er en rekke røye pekere som peker til strenger.

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

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

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

31
00:02:16,000 --> 00:02:20,000
vil alltid inneholde kommandoen som blir kjørt -

32
00:02:20,000 --> 00:02:22,000
i dette tilfellet, mv.

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

34
00:02:28,000 --> 00:02:37,000
og argv [2] vil inneholde det andre argumentet, ~ / CS50 /.

35
00:02:37,000 --> 00:02:42,000
Den siste argumentet argv vil alltid være null.

36
00:02:42,000 --> 00:02:46,000
Så la oss gjennomføre disse kommandolinjeargumenter.

37
00:02:46,000 --> 00:02:53,000
I tidligere øvelser, la vi ugyldig, betyr ingenting, som viktigste parameter.

38
00:02:53,000 --> 00:02:57,000
Men for at vi skal bruke kommandolinjeargumenter,

39
00:02:57,000 --> 00:03:12,000
Vi må fjerne ugyldig og plass inne i main int argc, char * argv [].

40
00:03:12,000 --> 00:03:17,000
Nå, for å få tilgang til hele elementet fra argv, som er dine argumenter,

41
00:03:17,000 --> 00:03:21,000
kan du bare iterate, eller sløyfe gjennom rekken som dette.

42
00:03:21,000 --> 00:03:27,000
Så, på innsiden av hoved kropp, kommer vi til å gå videre og skrive en for loop:

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 trenger ikke en krøllete brace her fordi vi bare gjennomføre en linje med kode

45
00:03:41,000 --> 00:03:44,000
i kroppen av denne sløyfen.

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

47
00:03:47,000 --> 00:03:57,000
skriv deretter printf ("argv [% d], for å representere et heltall,

48
00:03:57,000 --> 00:04:06,000
er% s, for streng, og deretter den nye linjen tegnet.

49
00:04:06,000 --> 00:04:12,000
Så vi gir printf jeg for den aktuelle iterasjonen av loopen

50
00:04:12,000 --> 00:04:18,000
og argv [i] for streng representasjon av gjeldende kommandolinje-argument.

51
00:04:18,000 --> 00:04:25,000
Når vi kjører det med to argumenter, vil vi se argumentene som vises i terminalen.

52
00:04:34,000 --> 00:04:38,000
Tidligere sa vi at argv holdt en rekke røye pekere.

53
00:04:38,000 --> 00:04:45,000
>> Så hvis dette er tilfelle, hvordan vi da tilgang individuelle tegn i hvert argument?

54
00:04:45,000 --> 00:04:51,000
For eksempel, hva om jeg ønsket å se etter et bestemt tegn i det første argumentet?

55
00:04:51,000 --> 00:04:55,000
Vel, svaret er at vi må bruke en nestet løkke

56
00:04:55,000 --> 00:04:59,000
som vil da iterate gjennom hvert av elementene i argumentet strengen.

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

58
00:05:02,000 --> 00:05:10,000
>> Først skal vi lage en kopi av example2.c.

59
00:05:10,000 --> 00:05:13,000
Deretter, på innsiden av den første for-løkken,

60
00:05:13,000 --> 00:05:15,000
Vi kommer til å legge en ekstra for loop.

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 gir oss da lengden på gjeldende argumentet,

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

64
00:05:39,000 --> 00:05:43,000
Vi kommer til å skrive ut plasseringen av hvert tegn

65
00:05:43,000 --> 00:05:47,000
innsiden av gjeldende argumentet ved hjelp printf.

66
00:05:47,000 --> 00:05:57,000
Så printf ("argv [% d], til å representere indeksen for nåværende argument,

67
00:05:57,000 --> 00:06:05,000
deretter [% d] en gang, å representere den nåværende karakter av dagens argument,

68
00:06:05,000 --> 00:06:13,000
er:% c, for strømmen tegnet i argumentet.

69
00:06:13,000 --> 00:06:20,000
Til slutt gir vi printf i indeksen til den ytre loop,, jeg

70
00:06:20,000 --> 00:06:22,000
vil indeks av den indre sløyfen.

71
00:06:22,000 --> 00:06:28,000
>> Og vår siste argument til er printf selve tegnet fra argumentasjonsrekker

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

73
00:06:31,000 --> 00:06:37,000
Nå, fordi jeg brukte strengfunksjon strlen å få lengden på en streng,

74
00:06:37,000 --> 00:06:43,000
Jeg må også legge til string.h biblioteket til toppen av vår omfatter.

75
00:06:43,000 --> 00:06:50,000
Så, for å gjøre det, vil vi gå opp, og i underkant av stdio.h, vi kommer til å gjøre

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

77
00:06:57,000 --> 00:07:02,000
>> Så, la oss kompilere og kjøre og gi det en faktisk argument.

78
00:07:09,000 --> 00:07:18,000
>> Og, som vi kan se, har vi nå den nøyaktige plasseringen av hver enkelt røye i argumentet.

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

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