1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Komando-Linio Argumentoj]

2
00:00:02,000 --> 00:00:04,000
[Christopher Bartolomé - Universitato Harvard]

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

4
00:00:07,000 --> 00:00:11,000
Utila trajto por programo estas akcepti uzanto enigo.

5
00:00:11,000 --> 00:00:15,000
Tiel nun, ni esploris iuj funkcioj ene de la CS50 biblioteko

6
00:00:15,000 --> 00:00:18,000
akcepti uzanto enigo, ekzemple "get kordoj,"

7
00:00:18,000 --> 00:00:23,000
kiu pelas la uzanto, dum la apliko kuras, por linio.

8
00:00:23,000 --> 00:00:28,000
>> Tamen, estas kazoj kie vi volas provizi vian programon enigo

9
00:00:28,000 --> 00:00:30,000
antaŭ ol ĝi estas efektive kurante.

10
00:00:30,000 --> 00:00:34,000
Tiel vi ne devas demandi pliajn informojn de via uzanto

11
00:00:34,000 --> 00:00:38,000
dum ekzekuti simpla tasko.

12
00:00:38,000 --> 00:00:42,000
Prenu, ekzemple, la mv aŭ movado komandon en Unikso.

13
00:00:42,000 --> 00:00:49,000
Tiu komando ebligas al la uzanto movas dosiero de unu loko al alia.

14
00:00:49,000 --> 00:00:55,000
Laŭ la manlibro paĝoj, mv akceptas du komandlinio argumentoj:

15
00:00:55,000 --> 00:01:00,000
la dosieron kiu estas movita kaj la situo de la dosiero estas kopiita por.

16
00:01:00,000 --> 00:01:06,000
Do tiu ekzemplo havas komandon kun du argumentojn.

17
00:01:06,000 --> 00:01:14,000
Nu do kiel ni diru nia C programon por uzi ĉi tiuj komand-linio argumentoj?

18
00:01:14,000 --> 00:01:20,000
>> Nu, tio rezultas ke ĉefaj, kiuj ni uzas en ĉiuj C programoj, havas sekreton.

19
00:01:20,000 --> 00:01:26,000
Ĉefa akceptas du parametrojn: argc kaj argv.

20
00:01:26,000 --> 00:01:28,000
Ni iru sur tiuj terminoj.

21
00:01:28,000 --> 00:01:33,000
>> La unua parametro, argc, kiu staras por argumento grafo,

22
00:01:33,000 --> 00:01:36,000
havas datumtipo de entjero.

23
00:01:36,000 --> 00:01:42,000
La argc parametro enhavas la nombro de argumentoj, kiel la komando.

24
00:01:42,000 --> 00:01:47,000
En nia movado komando, kvankam ni nur du argumentojn montrata,

25
00:01:47,000 --> 00:01:50,000
argc valoro estos 3.

26
00:01:50,000 --> 00:01:56,000
La dua parametro, argv, kiu staras por argumento vektoro,

27
00:01:56,000 --> 00:02:01,000
estas tabelo de char punteros ke indikas kordoj.

28
00:02:01,000 --> 00:02:06,000
>> Tio signifas, ke ĉiu elemento en argv, ekde nulo,

29
00:02:06,000 --> 00:02:09,000
enhavas la komando kaj argumentoj.

30
00:02:09,000 --> 00:02:16,000
Ekzemple, argv [0], kiu mi aludas al kiel argv nulo,

31
00:02:16,000 --> 00:02:20,000
ĉiam enhavi la komando kiu estas kuri -

32
00:02:20,000 --> 00:02:22,000
en ĉi tiu kazo, mv.

33
00:02:22,000 --> 00:02:28,000
argv [1] enhavos la unua argumento, file.txt,

34
00:02:28,000 --> 00:02:37,000
kaj argv [2] enhavos la dua argumento, ~ / cs50 /.

35
00:02:37,000 --> 00:02:42,000
La lasta argumento de argv ĉiam estos nula.

36
00:02:42,000 --> 00:02:46,000
Do ni apliki tiujn komand-linio argumentoj.

37
00:02:46,000 --> 00:02:53,000
En antaŭaj ekzercoj, ni metis malplena, signifanta nenion, kiel ĉefa La parametro.

38
00:02:53,000 --> 00:02:57,000
Tamen, por ke ni uzu komand-linio argumentoj,

39
00:02:57,000 --> 00:03:12,000
ni bezonas forigi malplena kaj loko ene de ĉefa int argc, char * argv [].

40
00:03:12,000 --> 00:03:17,000
Nun, por aliri la tutan elementon de argv, kiuj estas via argumentoj,

41
00:03:17,000 --> 00:03:21,000
vi povas simple persisti, aŭ ciklo, tra la tabelo kiel ĉi tio.

42
00:03:21,000 --> 00:03:27,000
Do, ene de ĉefaj la korpo, ni iras al antaŭeniri kaj tajpu a por buklo:

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

44
00:03:37,000 --> 00:03:41,000
>> Ni ne bezonas frizita streĉa tie ĉar ni nur ekzekuti unu linio de kodo

45
00:03:41,000 --> 00:03:44,000
ene de la korpo de ĉi ciklo.

46
00:03:44,000 --> 00:03:47,000
Ni iru antaŭen kaj batis langeto fojo,

47
00:03:47,000 --> 00:03:57,000
tiam tajpi printf ("argv [% d], por reprezenti entjero valoro,

48
00:03:57,000 --> 00:04:06,000
estas% s, por kordoj, tiam la nova linio karaktero.

49
00:04:06,000 --> 00:04:12,000
Tiam ni ofertas printf i por la aktuala ripeto de la ciklo

50
00:04:12,000 --> 00:04:18,000
kaj argv [i] por la kordo reprezento de la nuna komand-linio argumento.

51
00:04:18,000 --> 00:04:25,000
Kiam ni ruli ĝin kun du argumentoj, ni vidos la argumentoj esti montrata en la terminalo.

52
00:04:34,000 --> 00:04:38,000
Antaŭe ni diris ke la argv tenis serion de char punteros.

53
00:04:38,000 --> 00:04:45,000
>> Do, se ĉi tiu estas la kazo, kiel ni tiam aliro individua karakteroj en ĉiu argumento?

54
00:04:45,000 --> 00:04:51,000
Ekzemple, kio se mi volis serĉi specifan karakteron en la unua argumento?

55
00:04:51,000 --> 00:04:55,000
Nu, la respondo estas, ke ni bezonas apliki anidadas buklo

56
00:04:55,000 --> 00:04:59,000
ke estos tiam persisti tra ĉiu el la elementoj en la argumento kordoj.

57
00:04:59,000 --> 00:05:02,000
Jen kiel vi faru.

58
00:05:02,000 --> 00:05:10,000
>> Unue, ni tuj faros kopion de example2.c.

59
00:05:10,000 --> 00:05:13,000
Tiam, ene de la unua por ciklo,

60
00:05:13,000 --> 00:05:15,000
nin tuj aldoni plia por buklo.

61
00:05:15,000 --> 00:05:28,000
Do por (_int_ j = 0, n = strlen (argv [i]),

62
00:05:28,000 --> 00:05:32,000
kiuj tiam donas al ni la longo de la nuna diskuto,

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

64
00:05:39,000 --> 00:05:43,000
Ni tuj presi la situon de ĉiu karaktero

65
00:05:43,000 --> 00:05:47,000
ene de la nuna argumento uzante printf.

66
00:05:47,000 --> 00:05:57,000
Do, printf ("argv [% d], por reprezenti la indekso de la nuna diskuto,

67
00:05:57,000 --> 00:06:05,000
tiam [% d] denove, por reprezenti la nuna karaktero de la nuna diskuto,

68
00:06:05,000 --> 00:06:13,000
estas:% c, por la nuna karaktero en la argumento.

69
00:06:13,000 --> 00:06:20,000
Fine, ni ofertas printf kun la indico de la ekstera iteracio, i,

70
00:06:20,000 --> 00:06:22,000
tiam la indekso de la interna ciklo.

71
00:06:22,000 --> 00:06:28,000
>> Kaj nia lasta argumento por printf estas la efektiva karaktero de la argumento provizita

72
00:06:28,000 --> 00:06:31,000
ĉe la komandlinio.

73
00:06:31,000 --> 00:06:37,000
Nun, ĉar mi uzis la kordo funkcio strlen akiri la longo de kordoj,

74
00:06:37,000 --> 00:06:43,000
Mi devas aldoni ankaŭ la string.h biblioteko sur la supron de nia inkluzivas.

75
00:06:43,000 --> 00:06:50,000
Do, por fari tion, ni iru, kaj ĝuste sub stdio.h, ni faros

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

77
00:06:57,000 --> 00:07:02,000
>> Do, ni kompilos kaj kuras kaj havigi ĝin reala argumento.

78
00:07:09,000 --> 00:07:18,000
>> Kaj, kiel ni povas vidi, ni nun havas la ĝustan lokon de ĉiu individuo char en la argumento.

79
00:07:18,000 --> 00:07:23,000
Do jen ĝi. Mi Christopher Bartolomeo, ĉi tiu estas CS50.

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