1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Naredbenog retka argumente]

2
00:00:02,000 --> 00:00:04,000
[Christopher Bartolomej - Sveučilište Harvard]

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

4
00:00:07,000 --> 00:00:11,000
Korisna značajka za program je prihvatiti korisničkog unosa.

5
00:00:11,000 --> 00:00:15,000
Dosad smo istražili neke funkcije unutar CS50 knjižnici

6
00:00:15,000 --> 00:00:18,000
prihvatiti korisničkog unosa, kao što su "dobili niz"

7
00:00:18,000 --> 00:00:23,000
koji traži od korisnika, a aplikacija je trčanje, za niz.

8
00:00:23,000 --> 00:00:28,000
>> Međutim, postoje slučajevi u kojima želite dati svoj doprinos programa

9
00:00:28,000 --> 00:00:30,000
prije nego što zapravo radi.

10
00:00:30,000 --> 00:00:34,000
Na taj način, ne morate tražiti dodatne informacije od svog korisnika

11
00:00:34,000 --> 00:00:38,000
dok izvršavanju jednostavan zadatak.

12
00:00:38,000 --> 00:00:42,000
Uzmite, na primjer, SN ili premjestiti naredbu u UNIX.

13
00:00:42,000 --> 00:00:49,000
Ova naredba omogućuje korisniku premjestiti datoteku s jednog mjesta na drugo.

14
00:00:49,000 --> 00:00:55,000
Prema priručniku stranicama, mv prihvaća dva argumenta naredbenog retka:

15
00:00:55,000 --> 00:01:00,000
datoteku koja se preselila i mjesto je datoteka se preselio.

16
00:01:00,000 --> 00:01:06,000
Dakle, ovo je primjer ima naredbu s dva argumenta.

17
00:01:06,000 --> 00:01:14,000
Pa kako ćemo reći naš C program koristiti ove naredbenog retka argumente?

18
00:01:14,000 --> 00:01:20,000
>> Pa, ispada da glavni, koji ćemo koristiti u svim programima C, ima tajnu.

19
00:01:20,000 --> 00:01:26,000
Glavni prihvaća dva parametra: argc i argv.

20
00:01:26,000 --> 00:01:28,000
Idemo nad tim uvjetima.

21
00:01:28,000 --> 00:01:33,000
>> Prvi parametar, argc, koja se zalaže za argument count,

22
00:01:33,000 --> 00:01:36,000
ima vrstu podataka cijeli broj.

23
00:01:36,000 --> 00:01:42,000
The argc parametar sadrži niz argumenata, uključujući naredbe.

24
00:01:42,000 --> 00:01:47,000
U našem potez naredbe, iako smo samo dva argumenta prikazana,

25
00:01:47,000 --> 00:01:50,000
argc je vrijednost će biti tri.

26
00:01:50,000 --> 00:01:56,000
Drugi parametar, argv, koja se zalaže za argument vektora,

27
00:01:56,000 --> 00:02:01,000
je niz char upućuje da ukazuju na žice.

28
00:02:01,000 --> 00:02:06,000
>> To znači da svaki element u argv, počevši od nule,

29
00:02:06,000 --> 00:02:09,000
sadrži naredbu i argumente.

30
00:02:09,000 --> 00:02:16,000
Na primjer, argv [0], što ću nazivaju argv nula,

31
00:02:16,000 --> 00:02:20,000
uvijek će sadržavati naredbu da se pokrenuti -

32
00:02:20,000 --> 00:02:22,000
u ovom slučaju, mv.

33
00:02:22,000 --> 00:02:28,000
argv [1] će sadržavati prvi argument file.txt,

34
00:02:28,000 --> 00:02:37,000
i argv [2] će sadržavati drugi argument, ~ / cs50 /.

35
00:02:37,000 --> 00:02:42,000
Posljednji argument argv uvijek će biti nula.

36
00:02:42,000 --> 00:02:46,000
Tako ćemo provesti ove naredbenog retka argumente.

37
00:02:46,000 --> 00:02:53,000
U prethodnim vježbama, smo stavili prazninu, što znači ništa, kao glavni je parametar.

38
00:02:53,000 --> 00:02:57,000
Međutim, kako bi za nas da koriste naredbenog retka argumente,

39
00:02:57,000 --> 00:03:12,000
moramo ukloniti šupljikave i mjesto unutar glavnog int argc, char * argv [].

40
00:03:12,000 --> 00:03:17,000
Sada, da biste pristupili cijeli element iz argv, koji su vaši argumenti,

41
00:03:17,000 --> 00:03:21,000
možete jednostavno ponoviti, ili petlja kroz niz ovako.

42
00:03:21,000 --> 00:03:27,000
Dakle, unutar glavnih tijela, idemo ići naprijed i upišite for petlje:

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

44
00:03:37,000 --> 00:03:41,000
>> Mi ne treba kovrčavu braće ovdje, jer mi samo ti izvršavanju jedan redak koda

45
00:03:41,000 --> 00:03:44,000
unutar tijela ovoj petlji.

46
00:03:44,000 --> 00:03:47,000
Mi ćemo ići naprijed i udario tab jednom,

47
00:03:47,000 --> 00:03:57,000
zatim upišite printf ("argv [% d], da predstavlja cijeli broj,

48
00:03:57,000 --> 00:04:06,000
je% s, za niz, onda je nova linija lik.

49
00:04:06,000 --> 00:04:12,000
Onda smo pružiti printf ja za tekuću iteraciju petlje

50
00:04:12,000 --> 00:04:18,000
i argv [i] za gudački reprezentacije tekućeg naredbenog retka argument.

51
00:04:18,000 --> 00:04:25,000
Kada smo ga pokrenuti s dva argumenta, vidjet ćemo argumente koji se prikazuju u terminalu.

52
00:04:34,000 --> 00:04:38,000
Ranije smo rekli da je argv održao niz char upućuje.

53
00:04:38,000 --> 00:04:45,000
>> Dakle, ako je to slučaj, kako onda možemo pristupiti pojedinačne znakove u svakoj argument?

54
00:04:45,000 --> 00:04:51,000
Na primjer, što ako sam htio tražiti određeni lik u prvom argumentu?

55
00:04:51,000 --> 00:04:55,000
Pa, odgovor je da moramo primijeniti ugniježđene petlje

56
00:04:55,000 --> 00:04:59,000
koji će potom ponoviti kroz svaki od elemenata u nizu argumenata.

57
00:04:59,000 --> 00:05:02,000
Ovo je način kako ćete to učiniti.

58
00:05:02,000 --> 00:05:10,000
>> Prvo, idemo napraviti kopiju example2.c.

59
00:05:10,000 --> 00:05:13,000
Zatim, unutar prva for petlja,

60
00:05:13,000 --> 00:05:15,000
idemo dodati dodatni for petlje.

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

62
00:05:28,000 --> 00:05:32,000
koji je tada nam daje duljinu trenutne argumenta,

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

64
00:05:39,000 --> 00:05:43,000
Mi ćemo ispisati mjesto svakog lika

65
00:05:43,000 --> 00:05:47,000
unutar postojećeg argumenta pomoću printf.

66
00:05:47,000 --> 00:05:57,000
Dakle, printf ("argv [% d], predstavljaju indeks trenutne argumenta,

67
00:05:57,000 --> 00:06:05,000
zatim [% d] opet, da predstavljaju trenutni karakter trenutne argumenta,

68
00:06:05,000 --> 00:06:13,000
je:% c, za tekuću lik u argument.

69
00:06:13,000 --> 00:06:20,000
Na kraju, možemo pružiti printf s indeksom vanjskog petlje, ja,

70
00:06:20,000 --> 00:06:22,000
zatim indeks unutarnje petlje.

71
00:06:22,000 --> 00:06:28,000
>> I naš posljednji argument printf da je stvarni lik iz argumenta uvjetom

72
00:06:28,000 --> 00:06:31,000
u zapovjednoj liniji.

73
00:06:31,000 --> 00:06:37,000
Sada, jer sam koristio niz funkcija strlen dobiti duljinu niza,

74
00:06:37,000 --> 00:06:43,000
Također moram dodati string.h knjižnicu na vrhu naše uključuje.

75
00:06:43,000 --> 00:06:50,000
Dakle, za to, mi ćemo ići gore, i samo pod stdio.h, idemo napraviti

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

77
00:06:57,000 --> 00:07:02,000
>> Dakle, neka je sastaviti i pokrenuti i pružiti mu stvarni argument.

78
00:07:09,000 --> 00:07:18,000
>> I, kao što možemo vidjeti, mi sada imamo točnu lokaciju svakog pojedinog char u argument.

79
00:07:18,000 --> 00:07:23,000
Dakle, to je to. Ja sam Christopher Bartolomej, ovo je CS50.

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