1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Ukazni vrstici nekaj argumentov]

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

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

4
00:00:07,000 --> 00:00:11,000
Uporabna funkcija za program, je, da sprejme vnos uporabnika.

5
00:00:11,000 --> 00:00:15,000
Doslej smo raziskali nekatere funkcije v knjižnici CS50

6
00:00:15,000 --> 00:00:18,000
sprejeti vnos uporabnika, kot so "dobili niz"

7
00:00:18,000 --> 00:00:23,000
ki od uporabnika zahteva, medtem ko teče aplikacija za niz.

8
00:00:23,000 --> 00:00:28,000
>> Vendar pa obstajajo primeri, ko želite zagotoviti svoj prispevek programa

9
00:00:28,000 --> 00:00:30,000
preden se dejansko izvaja.

10
00:00:30,000 --> 00:00:34,000
Na ta način, vam ni treba vprašati dodatne informacije od svojega uporabnika

11
00:00:34,000 --> 00:00:38,000
medtem ko je izvršilni preprosto nalogo.

12
00:00:38,000 --> 00:00:42,000
Vzemimo za primer, MV ali ukaz Premakni v UNIX.

13
00:00:42,000 --> 00:00:49,000
Ta ukaz omogoča uporabniku, da premakne datoteko z ene lokacije na drugo.

14
00:00:49,000 --> 00:00:55,000
Glede na straneh man, mv sprejme dva argumenta ukazne vrstice:

15
00:00:55,000 --> 00:01:00,000
datoteka, ki se premakne, in njena lokacija se datoteka premakne.

16
00:01:00,000 --> 00:01:06,000
Torej ta primer je ukaz z dvema trditvama.

17
00:01:06,000 --> 00:01:14,000
Torej, kako bomo povem našo C program, ki uporabljajo te v ukazni vrstici argumenti?

18
00:01:14,000 --> 00:01:20,000
>> No, izkazalo se je, da je glavni, ki ga uporabljamo v vseh programih C, je skrivnost.

19
00:01:20,000 --> 00:01:26,000
Glavna sprejme dva parametra: argc in argv.

20
00:01:26,000 --> 00:01:28,000
Pojdimo nad temi pogoji.

21
00:01:28,000 --> 00:01:33,000
>> Prvi parameter, argc, ki stoji za štetje argumenta,

22
00:01:33,000 --> 00:01:36,000
ima celo vrsto podatkov.

23
00:01:36,000 --> 00:01:42,000
The argc parameter vsebuje številne argumente, vključno s poveljstvom.

24
00:01:42,000 --> 00:01:47,000
V našem gibanju ukaz, čeprav smo le dva argumenta prikaže,

25
00:01:47,000 --> 00:01:50,000
vrednost argc je bo 3.

26
00:01:50,000 --> 00:01:56,000
Drugi parameter, argv, ki stoji za msgstr,

27
00:01:56,000 --> 00:02:01,000
je niz char kazalcev, ki kažejo na strune.

28
00:02:01,000 --> 00:02:06,000
>> To pomeni, da je vsak element v argv, od nič,

29
00:02:06,000 --> 00:02:09,000
Vsebuje ukaz in argumenti.

30
00:02:09,000 --> 00:02:16,000
Na primer, argv [0], v katerem bom imenujemo argv nič,

31
00:02:16,000 --> 00:02:20,000
bo vedno vsebovala ukaz, da se zažene -

32
00:02:20,000 --> 00:02:22,000
V tem primeru je mv.

33
00:02:22,000 --> 00:02:28,000
argv bo [1] so s prvim argumentom, datoteka.txt,

34
00:02:28,000 --> 00:02:37,000
in argv [2], bo vsebovala drugo trditvijo, ~ / cs50 /.

35
00:02:37,000 --> 00:02:42,000
Zadnji argument argv bo vedno nič.

36
00:02:42,000 --> 00:02:46,000
Torej, kaj je izvajanje teh ukazni vrstici nekaj argumentov.

37
00:02:46,000 --> 00:02:53,000
V prejšnjih vajah smo dali neveljavna, kar pomeni ničesar, saj je glavni parameter.

38
00:02:53,000 --> 00:02:57,000
Vendar, da bi za nas, da v ukazni vrstici nekaj argumentov,

39
00:02:57,000 --> 00:03:12,000
moramo odpraviti praznino in kraj notranjost glavnega int argc, char * argv [].

40
00:03:12,000 --> 00:03:17,000
Zdaj, za dostop do celotnega element iz argv, ki so vaši argumenti,

41
00:03:17,000 --> 00:03:21,000
lahko preprosto izbirate, ali zanka, skozi niz, kot je ta.

42
00:03:21,000 --> 00:03:27,000
Torej, v notranjosti telesa je glavni, bomo iti naprej in vpišite v zanko:

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
>> Mi ne potrebujemo kodraste opornico sem, ker smo samo izvedbo eno vrstico kode

45
00:03:41,000 --> 00:03:44,000
v telesu te zanke.

46
00:03:44,000 --> 00:03:47,000
Mi bomo iti naprej in zadeti kartico enkrat,

47
00:03:47,000 --> 00:03:57,000
vnesite printf ("argv [% d], ki predstavlja celo število,

48
00:03:57,000 --> 00:04:06,000
je% s za niz, nato pa je nova linija znak.

49
00:04:06,000 --> 00:04:12,000
Potem nudimo printf i za tekoče ponovitev zanke

50
00:04:12,000 --> 00:04:18,000
in argv [i] za godalni zastopanje trenutno ukazno vrstico argumenta.

51
00:04:18,000 --> 00:04:25,000
Ko smo ga pognali z dvema trditvama, bomo videli argumente, ki so prikazane v terminalu.

52
00:04:34,000 --> 00:04:38,000
Prej smo rekli, da je argv potekal niz char kazalca.

53
00:04:38,000 --> 00:04:45,000
>> Torej, če je temu tako, kako bomo potem dostop do posameznih znakov v vsak argument?

54
00:04:45,000 --> 00:04:51,000
Na primer, kaj če sem hotel, da si za določen lik v prvem argumentu?

55
00:04:51,000 --> 00:04:55,000
No, odgovor je, da moramo uporabiti ugnezdeno zanko

56
00:04:55,000 --> 00:04:59,000
, ki bo nato Ponovil skozi vse elemente v argumentu niz.

57
00:04:59,000 --> 00:05:02,000
To je, kako si to naredil.

58
00:05:02,000 --> 00:05:10,000
>> Najprej bomo narediti kopijo example2.c.

59
00:05:10,000 --> 00:05:13,000
Potem, znotraj prvega za zanke,

60
00:05:13,000 --> 00:05:15,000
bomo dodali dodatno za zanko.

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

62
00:05:28,000 --> 00:05:32,000
kar pa nam daje dolžino trenutnega trditev,

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

64
00:05:39,000 --> 00:05:43,000
Bomo natisnili lokacijo vsake značaja

65
00:05:43,000 --> 00:05:47,000
znotraj sedanje trditve z printf.

66
00:05:47,000 --> 00:05:57,000
Torej, printf ("argv [% d], ki predstavlja indeks trenutnega trditev,

67
00:05:57,000 --> 00:06:05,000
potem [% d] še enkrat, da predstavljajo trenutno značaj sedanje trditve,

68
00:06:05,000 --> 00:06:13,000
je:% c za tekoče znaka v argumentu.

69
00:06:13,000 --> 00:06:20,000
Nazadnje, nudimo printf z indeksom zunanjega zanke, i,

70
00:06:20,000 --> 00:06:22,000
Nato indeks notranje zanke.

71
00:06:22,000 --> 00:06:28,000
>> In naš zadnji argument printf je dejanski učinek iz predloženih trditev

72
00:06:28,000 --> 00:06:31,000
v ukazni vrstici.

73
00:06:31,000 --> 00:06:37,000
Zdaj, ker sem uporabil niz funkcijo strlen pridobiti dolžino niza,

74
00:06:37,000 --> 00:06:43,000
Moram tudi dodati string.h knjižnico na vrhu naše vključuje.

75
00:06:43,000 --> 00:06:50,000
Torej, za to, da bomo šli gor, in samo pod stdio.h, bomo narediti

76
00:06:50,000 --> 00:06:57,000
# Vključujejo <string.h>.

77
00:06:57,000 --> 00:07:02,000
>> Torej, kaj je pripraviti in voditi in zagotoviti njeno dejansko argument.

78
00:07:09,000 --> 00:07:18,000
>> In, kot smo lahko videli, sedaj imamo točno lokacijo posameznega char v argumentu.

79
00:07:18,000 --> 00:07:23,000
Torej, to je to. Sem Christopher Jerneja, to je CS50.

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