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

2
00:00:02,000 --> 00:00:04,000
[Christopher Bartolomeu - Universiteti i Harvardit]

3
00:00:04,000 --> 00:00:07,000
[Kjo është CS50 - CS50.TV]

4
00:00:07,000 --> 00:00:11,000
Një tipar i dobishëm për një program është të pranojë të dhëna përdoruesi.

5
00:00:11,000 --> 00:00:15,000
Deri tani, ne kemi hulumtuar disa funksione brenda bibliotekës CS50

6
00:00:15,000 --> 00:00:18,000
të pranojë të dhëna përdoruesi, të tilla si "të marrë string"

7
00:00:18,000 --> 00:00:23,000
e cila bën përdorues, ndërsa aplikimi është i rrjedhshëm, për një varg.

8
00:00:23,000 --> 00:00:28,000
>> Megjithatë, ka raste ku ju doni të japin kontributin tuaj program

9
00:00:28,000 --> 00:00:30,000
para se ajo është në fakt running.

10
00:00:30,000 --> 00:00:34,000
Në këtë mënyrë, ju nuk keni nevojë të kërkojë informata shtesë nga përdoruesit tuaj

11
00:00:34,000 --> 00:00:38,000
ndërsa ekzekutimin e një detyrë e thjeshtë.

12
00:00:38,000 --> 00:00:42,000
Merrni, për shembull, TM ose komandën lëvizin në UNIX.

13
00:00:42,000 --> 00:00:49,000
Kjo komandë lejon përdoruesin për të lëvizur një skedë nga një vend në një tjetër.

14
00:00:49,000 --> 00:00:55,000
Sipas të faqeve manuale, mv pranon dy argumente command line:

15
00:00:55,000 --> 00:01:00,000
file që është duke lëvizur dhe vendndodhjen file është duke u lëvizur për të.

16
00:01:00,000 --> 00:01:06,000
Pra ky shembull ka një komandë me dy argumente.

17
00:01:06,000 --> 00:01:14,000
Pra, si nuk kemi treguar C programin tonë për të shfrytëzuar këto argumente command-line?

18
00:01:14,000 --> 00:01:20,000
>> E pra, del se kryesore, të cilat ne i përdorim në të gjitha programet C, ka një sekret.

19
00:01:20,000 --> 00:01:26,000
Kryesore pranon dy parametra: argc dhe argv.

20
00:01:26,000 --> 00:01:28,000
Le të shkojë mbi këto terma.

21
00:01:28,000 --> 00:01:33,000
>> Parametri i parë, argc, i cili qëndron për numërimin argumentit,

22
00:01:33,000 --> 00:01:36,000
ka një lloj të dhënave të numër të plotë.

23
00:01:36,000 --> 00:01:42,000
Parametri argc përmban numrin e argumenteve, duke përfshirë komandën.

24
00:01:42,000 --> 00:01:47,000
Në komandën tonë të lëvizë, edhe pse ne kemi vetëm dy argumente shfaqet,

25
00:01:47,000 --> 00:01:50,000
vlera argc do të jetë 3.

26
00:01:50,000 --> 00:01:56,000
Parametri i dytë, argv, i cili qëndron për vektor argumentit,

27
00:01:56,000 --> 00:02:01,000
është një grup i pointers char që tregojnë për vargjet.

28
00:02:01,000 --> 00:02:06,000
>> Kjo do të thotë që çdo element në argv, duke filluar nga zero,

29
00:02:06,000 --> 00:02:09,000
përmban komandën dhe argumentet.

30
00:02:09,000 --> 00:02:16,000
Për shembull, argv [0], të cilën unë do të referohen si argv zero,

31
00:02:16,000 --> 00:02:20,000
gjithmonë do të përmbajë urdhrin që është duke u drejtuar -

32
00:02:20,000 --> 00:02:22,000
në këtë rast, mv.

33
00:02:22,000 --> 00:02:28,000
argv [1] do të përmbajë argumentin e parë, file.txt,

34
00:02:28,000 --> 00:02:37,000
dhe argv [2] do të përmbajë Argumenti i dytë, ~ / CS50 /.

35
00:02:37,000 --> 00:02:42,000
Argumenti i fundit i argv do të jetë gjithmonë null.

36
00:02:42,000 --> 00:02:46,000
Pra, le të zbatojë këto argumente command-line.

37
00:02:46,000 --> 00:02:53,000
Në ushtrimet e mëparshme, ne kemi vendosur pavlefshëm, do të thotë asgjë, si parametër kryesor.

38
00:02:53,000 --> 00:02:57,000
Megjithatë, në mënyrë që ne të përdorim argumente command-line,

39
00:02:57,000 --> 00:03:12,000
ne kemi nevojë për të hequr dhe vendin void brenda int argc kryesore, char * argv [].

40
00:03:12,000 --> 00:03:17,000
Tani, për të hyrë në elementin tërë nga argv, të cilat janë argumentet tuaja,

41
00:03:17,000 --> 00:03:21,000
ju thjesht mund të iterate, ose loop, nëpërmjet rrjet si kjo.

42
00:03:21,000 --> 00:03:27,000
Pra, brenda e trupit kryesor, ne jemi duke shkuar për të shkuar përpara dhe të shtypni një për lak:

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

44
00:03:37,000 --> 00:03:41,000
>> Ne nuk kemi nevojë për një mbajtëse kaçurrel këtu, sepse ne jemi vetëm ekzekutimin e një linjë të kodit

45
00:03:41,000 --> 00:03:44,000
brenda trupit të këtë lak.

46
00:03:44,000 --> 00:03:47,000
Ne do të shkojnë përpara dhe e goditi tab herë,

47
00:03:47,000 --> 00:03:57,000
pastaj shtypni printf ("argv [% d], për të përfaqësuar një vlerë numër të plotë,

48
00:03:57,000 --> 00:04:06,000
është% s, për vargun, atëherë karakter të ri vijë.

49
00:04:06,000 --> 00:04:12,000
Pastaj ne të sigurojë printf i për përsëritje aktuale të lak

50
00:04:12,000 --> 00:04:18,000
dhe argv [i] për përfaqësimin harqesh e argumentit aktual command-line.

51
00:04:18,000 --> 00:04:25,000
Kur ne të drejtuar atë me dy argumente, ne do të shohim argumentet duke u shfaqur në terminalin.

52
00:04:34,000 --> 00:04:38,000
Më herët kemi thënë se argv mbajtur një rrjet të char pointers.

53
00:04:38,000 --> 00:04:45,000
>> Pra, në qoftë se ky është rasti, atëherë si nuk kemi qasje individuale në secilën karakteret argument?

54
00:04:45,000 --> 00:04:51,000
Për shembull, çfarë nëse kam kërkuar për të shikoni për një karakter të veçantë në argumentin e parë?

55
00:04:51,000 --> 00:04:55,000
Well, përgjigja është se ne kemi nevojë për të aplikuar një lak mbivendosur

56
00:04:55,000 --> 00:04:59,000
se pastaj do iterate nëpër secilën prej elementeve në vargun e argumentit.

57
00:04:59,000 --> 00:05:02,000
Kjo është se si ju të bëjë atë.

58
00:05:02,000 --> 00:05:10,000
>> Së pari, ne jemi duke shkuar për të bërë një kopje të example2.c.

59
00:05:10,000 --> 00:05:13,000
Pastaj, brenda të parë për lak,

60
00:05:13,000 --> 00:05:15,000
ne jemi duke shkuar për të shtuar një shtesë për lak.

61
00:05:15,000 --> 00:05:28,000
Pra, për (int j = 0, n = strlen (argv [i]),

62
00:05:28,000 --> 00:05:32,000
të cilat pastaj na jep gjatësinë e argumentit aktual,

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

64
00:05:39,000 --> 00:05:43,000
Ne jemi duke shkuar për të shtypur lokacionin e çdo karakter

65
00:05:43,000 --> 00:05:47,000
brenda argumentit aktual duke përdorur printf.

66
00:05:47,000 --> 00:05:57,000
Pra, printf ("argv [% d], për të përfaqësuar indeksin e argumentit aktual,

67
00:05:57,000 --> 00:06:05,000
pastaj [% d] edhe një herë, për të përfaqësuar karakterin aktual të argumentit aktual,

68
00:06:05,000 --> 00:06:13,000
është: c%, për karakter aktuale në argumentit.

69
00:06:13,000 --> 00:06:20,000
Së fundi, ne ofrojme printf me indeksin e lak e jashtme, i,

70
00:06:20,000 --> 00:06:22,000
atëherë indeksi i lak brendshme.

71
00:06:22,000 --> 00:06:28,000
>> Dhe argumenti ynë i fundit për të printf është karakteri aktuale nga argumenti kusht

72
00:06:28,000 --> 00:06:31,000
në rreshtin e komandave.

73
00:06:31,000 --> 00:06:37,000
Tani, sepse kam përdorur funksionin string strlen për të marrë gjatësinë e një varg,

74
00:06:37,000 --> 00:06:43,000
Unë gjithashtu duhet të shtoni bibliotekë string në krye të përfshinë tonë.

75
00:06:43,000 --> 00:06:50,000
Pra, për të bërë këtë, ne do të shkojnë lart, dhe vetëm nën stdio.h, ne jemi duke shkuar për të bërë

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

77
00:06:57,000 --> 00:07:02,000
>> Pra, le të hartojnë dhe të drejtuar dhe të sigurojë asaj një argument të vërtetë.

78
00:07:09,000 --> 00:07:18,000
>> Dhe, si ne mund të shohim, tani ne kemi vendndodhjen e saktë të çdo char individuale në argument.

79
00:07:18,000 --> 00:07:23,000
Pra, kjo është ajo. Unë jam Christopher Bartolomeu; kjo është CS50.

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