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

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

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

4
00:00:07,000 --> 00:00:11,000
Ang isang kapaki-pakinabang na tampok para sa isang programa upang tanggapin ang pag-input ng user.

5
00:00:11,000 --> 00:00:15,000
Kaya ngayon, ginalugad namin na ang ilang mga function sa loob ng CS50 library

6
00:00:15,000 --> 00:00:18,000
tanggapin ang input ng user, tulad ng "makakuha ng mga string,"

7
00:00:18,000 --> 00:00:23,000
na prompt ng user, habang tumatakbo ang application, para sa isang string.

8
00:00:23,000 --> 00:00:28,000
>> Subalit, may mga kaso kung saan nais mong ibigay ang iyong input sa programa

9
00:00:28,000 --> 00:00:30,000
bago aktwal na ito ay tumatakbo.

10
00:00:30,000 --> 00:00:34,000
Sa ganitong paraan, hindi mo na kailangan upang humingi ng karagdagang impormasyon mula sa iyong user

11
00:00:34,000 --> 00:00:38,000
habang execute ang isang simpleng gawain.

12
00:00:38,000 --> 00:00:42,000
Dalhin, halimbawa, ang mv o ilipat ang utos sa UNIX.

13
00:00:42,000 --> 00:00:49,000
Ang utos na ito ay nagbibigay-daan sa user na ilipat ang isang file mula sa isang lokasyon sa isa pang.

14
00:00:49,000 --> 00:00:55,000
Ayon sa manu-manong mga pahina, mv tumatanggap dalawang argumento sa linya ng command na:

15
00:00:55,000 --> 00:01:00,000
ang file na inilipat at ang lokasyon ng file ay inilipat sa.

16
00:01:00,000 --> 00:01:06,000
Kaya halimbawa na ito ay isang command na may dalawang argumento.

17
00:01:06,000 --> 00:01:14,000
Kaya paano namin sabihin sa aming programa sa C upang gamitin ang mga command-line argumento?

18
00:01:14,000 --> 00:01:20,000
>> Well, lumiliko na ang pangunahing, na ginagamit namin sa lahat ng mga programa C, ay isang lihim.

19
00:01:20,000 --> 00:01:26,000
Pangunahing tumatanggap ng dalawang mga parameter: argc at argv.

20
00:01:26,000 --> 00:01:28,000
Natin pumunta sa mga tuntuning ito.

21
00:01:28,000 --> 00:01:33,000
>> Ang unang parameter, argc, na nakatayo para sa argumento count,

22
00:01:33,000 --> 00:01:36,000
may data uri ng integer.

23
00:01:36,000 --> 00:01:42,000
Ang argc parameter naglalaman ang bilang ng mga argumento, kabilang ang command.

24
00:01:42,000 --> 00:01:47,000
Sa aming ilipat utos, bagaman lamang namin dalawang argumento ipinapakita,

25
00:01:47,000 --> 00:01:50,000
argc ang halaga ay 3.

26
00:01:50,000 --> 00:01:56,000
Ang pangalawang parameter, argv, na nakatayo para sa argumento vector,

27
00:01:56,000 --> 00:02:01,000
ay isang hanay ng magpasinda payo na tumuturo sa string.

28
00:02:01,000 --> 00:02:06,000
>> Nangangahulugan ito na ang bawat elemento sa argv, simula sa zero,

29
00:02:06,000 --> 00:02:09,000
naglalaman ng mga utos at mga argumento.

30
00:02:09,000 --> 00:02:16,000
Halimbawa, argv [0], na kukunin ko na mag-refer sa bilang argv zero,

31
00:02:16,000 --> 00:02:20,000
ay palaging naglalaman ng command na patakbuhin ang -

32
00:02:20,000 --> 00:02:22,000
sa kasong ito, mv.

33
00:02:22,000 --> 00:02:28,000
argv [1] ay naglalaman ng unang argument, file.txt,

34
00:02:28,000 --> 00:02:37,000
at argv [2] ay naglalaman ng pangalawang argumento, ~ / cs50 /.

35
00:02:37,000 --> 00:02:42,000
Ang huling argumento ng argv ay palaging null.

36
00:02:42,000 --> 00:02:46,000
Kaya sabihin ipatupad ang mga command-line argumento.

37
00:02:46,000 --> 00:02:53,000
Sa nakaraang pagsasanay, inilagay namin walang bisa, na nangangahulugang walang, bilang pangunahing ng parameter.

38
00:02:53,000 --> 00:02:57,000
Gayunpaman, upang para sa amin upang gamitin ang command-line na mga argumento,

39
00:02:57,000 --> 00:03:12,000
kailangan namin upang alisin ang walang silbi at lugar sa loob ng pangunahing int argc, magpasinda * argv [].

40
00:03:12,000 --> 00:03:17,000
Ngayon, upang ma-access ang buong elemento mula sa argv, na ang iyong mga argumento,

41
00:03:17,000 --> 00:03:21,000
Maaari mo lamang umulit, o loop, sa pamamagitan ng array tulad nito.

42
00:03:21,000 --> 00:03:27,000
Kaya, sa loob ng pangunahing ng katawan, kami ay pagpunta sa magpatuloy at i-type ang isang para sa loop:

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

44
00:03:37,000 --> 00:03:41,000
>> Hindi namin kailangan ng kulot suhay dito dahil lamang namin execute ng isang linya ng code

45
00:03:41,000 --> 00:03:44,000
sa loob ng katawan ng loop na ito.

46
00:03:44,000 --> 00:03:47,000
Susubukan naming magpatuloy at pindutin ang tab sabay-sabay,

47
00:03:47,000 --> 00:03:57,000
pagkatapos i-type printf ("argv [% d], upang kumatawan ng isang integer value,

48
00:03:57,000 --> 00:04:06,000
ay% s, para sa string, pagkatapos ay ang bagong linya ng character.

49
00:04:06,000 --> 00:04:12,000
Pagkatapos namin magbigay printf i para sa kasalukuyang pag-ulit ng loop

50
00:04:12,000 --> 00:04:18,000
at argv [i] para sa string na representasyon ng kasalukuyang argumento sa command-line.

51
00:04:18,000 --> 00:04:25,000
Kapag namin patakbuhin ang mga ito sa dalawang argumento, makikita namin makita ang mga argumento na ipinapakita sa terminal.

52
00:04:34,000 --> 00:04:38,000
Mas maaga sinabi namin na ang argv gaganapin isang array ng pansamantalang trabaho pointer.

53
00:04:38,000 --> 00:04:45,000
>> Kaya, kung ito ang kaso, kung paano namin pagkatapos-access ang mga indibidwal na mga character sa bawat argumento?

54
00:04:45,000 --> 00:04:51,000
Halimbawa, ano kung gusto ko upang tumingin para sa isang tiyak na character sa unang argumento?

55
00:04:51,000 --> 00:04:55,000
Well, ang sagot ay na kailangan namin mag-apply ng isang nested loop

56
00:04:55,000 --> 00:04:59,000
na umulit sa pamamagitan ng bawat isa ng ang mga elemento sa string ng argumento.

57
00:04:59,000 --> 00:05:02,000
Ito ay kung paano ito gawin.

58
00:05:02,000 --> 00:05:10,000
>> Una, kami ay pagpunta sa gumawa ng isang kopya ng example2.c.

59
00:05:10,000 --> 00:05:13,000
Pagkatapos, sa loob ng unang para sa loop,

60
00:05:13,000 --> 00:05:15,000
kami ay pagpunta upang magdagdag ng karagdagang para sa loop.

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

62
00:05:28,000 --> 00:05:32,000
na pagkatapos ay nagbibigay sa amin ang haba ng kasalukuyang argument,

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

64
00:05:39,000 --> 00:05:43,000
Kami ay pagpunta sa i-print ang lokasyon ng bawat karakter

65
00:05:43,000 --> 00:05:47,000
sa loob ng kasalukuyang argumento sa pamamagitan ng paggamit ng printf.

66
00:05:47,000 --> 00:05:57,000
Kaya, printf ("argv [% d], upang kumatawan sa index ng kasalukuyang argument,

67
00:05:57,000 --> 00:06:05,000
[% d] muli, upang kumatawan sa kasalukuyang katangian ng ang kasalukuyang argumento,

68
00:06:05,000 --> 00:06:13,000
ay:% c, para sa kasalukuyang character sa argumento.

69
00:06:13,000 --> 00:06:20,000
Panghuli, nagbibigay kami printf gamit ang index ng panlabas na loop, i,

70
00:06:20,000 --> 00:06:22,000
index ng panloob na loop.

71
00:06:22,000 --> 00:06:28,000
>> At ang aming huling argumento sa printf ay ang aktwal na character mula sa argumento na ibinigay

72
00:06:28,000 --> 00:06:31,000
sa linya ng command.

73
00:06:31,000 --> 00:06:37,000
Ngayon, dahil ginamit ko ang string function na strlen upang makuha ang haba ng isang string,

74
00:06:37,000 --> 00:06:43,000
Kailangan ko rin idagdag ang string.h library sa tuktok ng aming mga kasama ang.

75
00:06:43,000 --> 00:06:50,000
Kaya, upang gawin iyon, makikita namin pumunta up, at lamang sa ilalim ng stdio.h, kami ay pagpunta sa gawin

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

77
00:06:57,000 --> 00:07:02,000
>> Kaya, sabihin makatipon at patakbuhin at ibigay ito sa isang aktwal na argumento.

78
00:07:09,000 --> 00:07:18,000
>> At, bilang maaari naming makita, na namin ngayon ay ang eksaktong lokasyon ng bawat indibidwal na magpasinda sa argumento.

79
00:07:18,000 --> 00:07:23,000
Kaya na ito. Ako Christopher Bartholomew, ito ay CS50.

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