1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Příkazového řádku Argumenty]

2
00:00:02,000 --> 00:00:04,000
[Christopher Bartoloměje - 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
Užitečná funkce pro program je přijmout vstup od uživatele.

5
00:00:11,000 --> 00:00:15,000
Dosud jsme prozkoumali některé funkce v rámci CS50 knihovně

6
00:00:15,000 --> 00:00:18,000
přijímat vstup uživatele, jako je například "dostat řetězec,"

7
00:00:18,000 --> 00:00:23,000
které vyzve uživatele, zatímco je aplikace spuštěna, pro řetězec.

8
00:00:23,000 --> 00:00:28,000
>> Nicméně, existují případy, kdy chcete, aby váš program vstup

9
00:00:28,000 --> 00:00:30,000
předtím, než je ve skutečnosti běží.

10
00:00:30,000 --> 00:00:34,000
Tímto způsobem, nemusíte se ptát další informace z vašeho uživatele

11
00:00:34,000 --> 00:00:38,000
Při provádění jednoduchý úkol.

12
00:00:38,000 --> 00:00:42,000
Vezměme si například, MV nebo přesunout příkaz v UNIXu.

13
00:00:42,000 --> 00:00:49,000
Tento příkaz umožňuje uživateli přesunout soubor z jednoho místa na druhé.

14
00:00:49,000 --> 00:00:55,000
Podle manuálových stránek, mv přijímá dva argumenty příkazového řádku:

15
00:00:55,000 --> 00:01:00,000
soubor, který se přesouvá a umístění souboru je přesunuta do.

16
00:01:00,000 --> 00:01:06,000
Takže tento příklad má příkaz se dvěma argumenty.

17
00:01:06,000 --> 00:01:14,000
Tak jak jsme se říci, náš C program využít tyto argumenty příkazového řádku?

18
00:01:14,000 --> 00:01:20,000
>> No, ukázalo se, že hlavní, které používáme ve všech programech C, má nějaké tajemství.

19
00:01:20,000 --> 00:01:26,000
Hlavní přijímá dva parametry: argc a argv.

20
00:01:26,000 --> 00:01:28,000
Pojďme nad těmito podmínkami.

21
00:01:28,000 --> 00:01:33,000
>> První parametr, argc, což je zkratka pro počet argumentů,

22
00:01:33,000 --> 00:01:36,000
má datový typ integer.

23
00:01:36,000 --> 00:01:42,000
The argc parametr obsahuje počet argumentů, včetně příkazu.

24
00:01:42,000 --> 00:01:47,000
V našem pohybu příkazu, i když máme jen dva argumenty zobrazí,

25
00:01:47,000 --> 00:01:50,000
argc je hodnota bude 3.

26
00:01:50,000 --> 00:01:56,000
Druhý parametr, argv, což je zkratka pro argumentu vektoru,

27
00:01:56,000 --> 00:02:01,000
je pole char ukazatelů, které ukazují na řetězce.

28
00:02:01,000 --> 00:02:06,000
>> To znamená, že každý prvek v argv, počínaje od nuly,

29
00:02:06,000 --> 00:02:09,000
obsahuje příkaz a argumenty.

30
00:02:09,000 --> 00:02:16,000
Například, argv [0], které budu odkazovat jako argv nulové,

31
00:02:16,000 --> 00:02:20,000
bude vždy obsahovat příkaz, který je spuštěn -

32
00:02:20,000 --> 00:02:22,000
v tomto případě, mv.

33
00:02:22,000 --> 00:02:28,000
argv [1] bude obsahovat první argument, soubor.txt,

34
00:02:28,000 --> 00:02:37,000
a argv [2] bude obsahovat druhý argument, ~ / cs50 /.

35
00:02:37,000 --> 00:02:42,000
Poslední argument argv bude vždy null.

36
00:02:42,000 --> 00:02:46,000
Takže pojďme zavést tyto argumenty příkazového řádku.

37
00:02:46,000 --> 00:02:53,000
V předchozích cvičeních, jsme umístili neplatné, což znamená, nic, je jako parametr hlavní je.

38
00:02:53,000 --> 00:02:57,000
Aby se však pro nás používat argumenty příkazového řádku,

39
00:02:57,000 --> 00:03:12,000
musíme odstranit neplatné a místo uvnitř hlavního int argc, char * argv [].

40
00:03:12,000 --> 00:03:17,000
Nyní, přístup na celý prvek z argv, které jsou vaše argumenty,

41
00:03:17,000 --> 00:03:21,000
můžete jednoduše iteraci, nebo smyčka, přes pole, jako je to.

42
00:03:21,000 --> 00:03:27,000
Takže, uvnitř těla hlavních je, že budeme pokračovat a zadejte pro smyčce:

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
>> My nepotřebujeme složená závorka tady, protože jsme jen vykonávající jeden řádek kódu

45
00:03:41,000 --> 00:03:44,000
v těle tohoto smyčky.

46
00:03:44,000 --> 00:03:47,000
Budeme pokračovat a stiskněte kartu jednou,

47
00:03:47,000 --> 00:03:57,000
zadejte printf ("argv [% d], představují celočíselnou hodnotu,

48
00:03:57,000 --> 00:04:06,000
% s, pro řetězec, pak nového řádku.

49
00:04:06,000 --> 00:04:12,000
Pak nabízíme printf i pro aktuální iteraci smyčky

50
00:04:12,000 --> 00:04:18,000
a argv [i] pro řetězcové vyjádření současného argument příkazového řádku.

51
00:04:18,000 --> 00:04:25,000
Když jsme se spustit s dvěma argumenty, uvidíme argumenty jsou zobrazené v terminálu.

52
00:04:34,000 --> 00:04:38,000
Dříve jsme si řekli, že argv držel řadu char ukazatelů.

53
00:04:38,000 --> 00:04:45,000
>> Takže, pokud je to váš případ, jak jsme pak přístup k jednotlivým znaky v každém argumentu?

54
00:04:45,000 --> 00:04:51,000
Například, co když jsem chtěl hledat konkrétní znak v prvním argumentu?

55
00:04:51,000 --> 00:04:55,000
No, odpověď je, že musíme použít vnořené smyčky

56
00:04:55,000 --> 00:04:59,000
že se pak iteraci každý z prvků v argumentu řetězce.

57
00:04:59,000 --> 00:05:02,000
To je, jak to udělat.

58
00:05:02,000 --> 00:05:10,000
>> Za prvé, budeme dělat kopii example2.c.

59
00:05:10,000 --> 00:05:13,000
Pak, uvnitř první pro smyčce,

60
00:05:13,000 --> 00:05:15,000
budeme přidávat další smyčky for.

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

62
00:05:28,000 --> 00:05:32,000
který pak nám dává délku aktuálního argumentu,

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

64
00:05:39,000 --> 00:05:43,000
Budeme vytisknout umístění každého znaku

65
00:05:43,000 --> 00:05:47,000
uvnitř stávajícího argumentu pomocí printf.

66
00:05:47,000 --> 00:05:57,000
Takže, printf ("argv [% d], reprezentovat index aktuálního argumentu,

67
00:05:57,000 --> 00:06:05,000
pak [% d] a znovu se představují aktuální charakter současného argumentu,

68
00:06:05,000 --> 00:06:13,000
je:% c, pro aktuální znak v argumentu.

69
00:06:13,000 --> 00:06:20,000
Konečně, zajišťujeme printf s indexem vnějšího cyklu, i,

70
00:06:20,000 --> 00:06:22,000
pak index vnitřní smyčce.

71
00:06:22,000 --> 00:06:28,000
>> A naše poslední argument funkce printf je skutečná postava z poskytnutých argumentu

72
00:06:28,000 --> 00:06:31,000
na příkazovém řádku.

73
00:06:31,000 --> 00:06:37,000
Teď, protože jsem použil řetězec funkce strlen získat délku řetězce,

74
00:06:37,000 --> 00:06:43,000
Musím také přidat string.h knihovnu na vrchol našeho obsahuje.

75
00:06:43,000 --> 00:06:50,000
Takže, k tomu, že, půjdeme nahoru, a těsně pod stdio.h, budeme dělat

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

77
00:06:57,000 --> 00:07:02,000
>> Takže, pojďme kompilovat a spouštět, a poskytne mu skutečnou argumentaci.

78
00:07:09,000 --> 00:07:18,000
>> A jak vidíme, máme nyní přesnou polohu jednotlivých char v argumentu.

79
00:07:18,000 --> 00:07:23,000
Tak to je to. Jsem Christopher Bartoloměj, to je CS50.

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