1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Command-Line érvei]

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

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

4
00:00:07,000 --> 00:00:11,000
A hasznos funkció a program célja, hogy fogadja el a felhasználó bemenet.

5
00:00:11,000 --> 00:00:15,000
Eddig, már feltárt bizonyos funkciók a CS50 könyvtár

6
00:00:15,000 --> 00:00:18,000
elfogadni felhasználói bevitel, például "kap string,"

7
00:00:18,000 --> 00:00:23,000
amely figyelmezteti a felhasználót, miközben az alkalmazás fut, egy string.

8
00:00:23,000 --> 00:00:28,000
>> Vannak azonban olyan esetek, amikor azt szeretnénk, hogy a program input

9
00:00:28,000 --> 00:00:30,000
mielőtt azt ténylegesen fut.

10
00:00:30,000 --> 00:00:34,000
Így nem kell kérni további adatokat a felhasználói

11
00:00:34,000 --> 00:00:38,000
míg a végrehajtó egyszerű feladat.

12
00:00:38,000 --> 00:00:42,000
Vegyük például a mv vagy áthelyezni parancs UNIX.

13
00:00:42,000 --> 00:00:49,000
Ez a parancs lehetővé teszi a felhasználó számára, hogy mozog egy fájlt egyik helyről a másikra.

14
00:00:49,000 --> 00:00:55,000
Szerint a kézikönyv oldalakat, mv fogad 2 parancssori argumentumok:

15
00:00:55,000 --> 00:01:00,000
A fájl mozgatása és a helyét a fájl költöztették.

16
00:01:00,000 --> 00:01:06,000
Így ez a példa egy parancsot két argumentummal.

17
00:01:06,000 --> 00:01:14,000
Szóval hogyan lehet mondjuk a C program kihasználni ezeket a parancssori argumentumok?

18
00:01:14,000 --> 00:01:20,000
>> Nos, kiderült, hogy a legfontosabb, amit használ az összes C program, van egy titka.

19
00:01:20,000 --> 00:01:26,000
Main elfogadja két paraméter: argc és argv.

20
00:01:26,000 --> 00:01:28,000
Menjünk át ezeket a feltételeket.

21
00:01:28,000 --> 00:01:33,000
>> Az első paraméter argc, amely áll a vita számítanak,

22
00:01:33,000 --> 00:01:36,000
egy adattípusa integer.

23
00:01:36,000 --> 00:01:42,000
A argc paraméter tartalmazza az argumentumok számát, beleértve a parancsot.

24
00:01:42,000 --> 00:01:47,000
A mi move parancs, bár csak két érv jelenik meg,

25
00:01:47,000 --> 00:01:50,000
argc értéke 3 lesz.

26
00:01:50,000 --> 00:01:56,000
A második paraméter, argv, amely áll a vita vektor,

27
00:01:56,000 --> 00:02:01,000
egy tömb char mutatókat, hogy mutassanak szálakat.

28
00:02:01,000 --> 00:02:06,000
>> Ez azt jelenti, hogy minden egyes eleme argv, nullától kezdve

29
00:02:06,000 --> 00:02:09,000
tartalmazza a parancsot és érveket.

30
00:02:09,000 --> 00:02:16,000
Például, argv [0], amely fogok hivatkozni, mint argv nulla,

31
00:02:16,000 --> 00:02:20,000
mindig tartalmazza a parancs éppen fut -

32
00:02:20,000 --> 00:02:22,000
ebben az esetben, mv.

33
00:02:22,000 --> 00:02:28,000
argv [1] tartalmazza az első érv, file.txt,

34
00:02:28,000 --> 00:02:37,000
és argv [2] tartalmazza a második érvet ~ / CS50 /.

35
00:02:37,000 --> 00:02:42,000
Az utolsó érve argv mindig null.

36
00:02:42,000 --> 00:02:46,000
Szóval végre ezeket a parancssori argumentumok.

37
00:02:46,000 --> 00:02:53,000
A korábbi gyakorlatok, mi hozott semmis, vagyis semmit, mint fő a paraméter.

38
00:02:53,000 --> 00:02:57,000
Ahhoz azonban, hogy számunkra, hogy parancssori argumentumok,

39
00:02:57,000 --> 00:03:12,000
el kell távolítani void helye és belső fő int argc, char * argv [].

40
00:03:12,000 --> 00:03:17,000
Most, hogy elérje a teljes elemet argv, amelyek az Ön érveit,

41
00:03:17,000 --> 00:03:21,000
egyszerűen navigálhat, vagy hurok, a tömb, mint ez.

42
00:03:21,000 --> 00:03:27,000
Szóval, belső fő testén, fogunk menni előre, és írja be a hurok:

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
>> Nem kell a kapcsos zárójel itt, mert mi csak a végrehajtó egy sor kód

45
00:03:41,000 --> 00:03:44,000
belül a test ezen hurok.

46
00:03:44,000 --> 00:03:47,000
Megyünk előre, és nyomja tab egyszer,

47
00:03:47,000 --> 00:03:57,000
majd írja printf ("argv [% d], képviseli egy egész értéket,

48
00:03:57,000 --> 00:04:06,000
% s, a string, akkor az új sor karaktert.

49
00:04:06,000 --> 00:04:12,000
Aztán biztosítani printf i az aktuális iteráció a hurok

50
00:04:12,000 --> 00:04:18,000
és argv [i] a karakteres ábrázolása az aktuális parancssori argumentum.

51
00:04:18,000 --> 00:04:25,000
Amikor futtatni két érv, akkor nézze meg az érveket jelenik meg a terminálon.

52
00:04:34,000 --> 00:04:38,000
Korábban azt mondtuk, hogy az argv tartott egy sor char mutatókat.

53
00:04:38,000 --> 00:04:45,000
>> Tehát, ha ez a helyzet, hogyan tudjuk majd elérni egyes karakterek minden érvelés?

54
00:04:45,000 --> 00:04:51,000
Például, mi van, ha akartam nézni egy adott karakter az első argumentum?

55
00:04:51,000 --> 00:04:55,000
Nos, a válasz az, hogy meg kell alkalmazni a beágyazott hurok

56
00:04:55,000 --> 00:04:59,000
hogy majd halad végig az egyes elemek az argumentum sztring.

57
00:04:59,000 --> 00:05:02,000
Ezt hogyan csinálod.

58
00:05:02,000 --> 00:05:10,000
>> Először is, mi megy, hogy egy másolatot example2.c.

59
00:05:10,000 --> 00:05:13,000
Aztán, belül az első a hurok,

60
00:05:13,000 --> 00:05:15,000
fogunk egy további a hurok.

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

62
00:05:28,000 --> 00:05:32,000
amely ezután megadja a hossza a jelenlegi érvelés,

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

64
00:05:39,000 --> 00:05:43,000
Fogunk nyomtatni a helyét minden egyes karakter

65
00:05:43,000 --> 00:05:47,000
belül a jelenlegi érvelés segítségével printf.

66
00:05:47,000 --> 00:05:57,000
Tehát printf ("argv [% d], hogy képviselje az index a jelenlegi érvelés,

67
00:05:57,000 --> 00:06:05,000
majd a [% d] ismételten, hogy képviselje az aktuális karakter a jelenlegi érvelés,

68
00:06:05,000 --> 00:06:13,000
jelentése:% c, az aktuális karakter az érvelés.

69
00:06:13,000 --> 00:06:20,000
Végül, mi az printf az index a külső hurok, i,

70
00:06:20,000 --> 00:06:22,000
akkor az index a belső hurok.

71
00:06:22,000 --> 00:06:28,000
>> És az utolsó argumentum printf a tényleges karakter az érvet szolgáltatott

72
00:06:28,000 --> 00:06:31,000
a parancssorban.

73
00:06:31,000 --> 00:06:37,000
Nos, azért, mert használják a string funkció strlen így a string hossza,

74
00:06:37,000 --> 00:06:43,000
Azt is meg kell hozzá a string.h könyvtár a tetején található.

75
00:06:43,000 --> 00:06:50,000
Szóval, hogy ezt megtehessük, megyünk fel, és alig stdio.h, fogunk csinálni

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

77
00:06:57,000 --> 00:07:02,000
>> Nos, nézzük fordításához és futtatásához, és ez egy valódi érv.

78
00:07:09,000 --> 00:07:18,000
>> És mint látjuk, most már a pontos helyét az egyes char az érvelést.

79
00:07:18,000 --> 00:07:23,000
Szóval ennyi. Én Christopher Bartholomew, ez CS50.

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