1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Käsurea argumendid]

2
00:00:02,000 --> 00:00:04,000
[Christopher Bartholomew - Harvardi Ülikool]

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

4
00:00:07,000 --> 00:00:11,000
Kasulik funktsioon on programmi kasutaja andmeid sisestada.

5
00:00:11,000 --> 00:00:15,000
Siiani oleme vaadelnud mõningaid funktsioone CS50 raamatukogu

6
00:00:15,000 --> 00:00:18,000
saaks kasutaja andmeid sisestada, näiteks "saada stringi"

7
00:00:18,000 --> 00:00:23,000
mis küsib kasutaja, kui rakendus töötab, sest string.

8
00:00:23,000 --> 00:00:28,000
>> Siiski esineb juhtumeid, kus soovite anda oma programmi sisend

9
00:00:28,000 --> 00:00:30,000
enne kui see tegelikult töötab.

10
00:00:30,000 --> 00:00:34,000
Nii, sa ei pea küsima lisainformatsiooni oma kasutajanime

11
00:00:34,000 --> 00:00:38,000
samas täidesaatev lihtne ülesanne.

12
00:00:38,000 --> 00:00:42,000
Võtame näiteks, mv või liigub käsk UNIX.

13
00:00:42,000 --> 00:00:49,000
See käsk võimaldab kasutajal liikuda faili ühest kohast teise.

14
00:00:49,000 --> 00:00:55,000
Vastavalt manuaal lehti, mv võtab kaks käsurea argumente:

15
00:00:55,000 --> 00:01:00,000
faili on liigutatud ja asukoht fail on kolinud.

16
00:01:00,000 --> 00:01:06,000
Nii et see näide on käsu kaks argumenti.

17
00:01:06,000 --> 00:01:14,000
Niisiis, kuidas me ütleme meie C programmi kasutada neid käsurea argumendid?

18
00:01:14,000 --> 00:01:20,000
>> Noh, tuleb välja, et peamine, mis me kasutame kõiki C programme, on saladus.

19
00:01:20,000 --> 00:01:26,000
Peamised võtab kaks parameetrit: argc ja argv.

20
00:01:26,000 --> 00:01:28,000
Lähme üle nende tingimustega.

21
00:01:28,000 --> 00:01:33,000
>> Esimene parameeter, argc, mis tähistab argument loota,

22
00:01:33,000 --> 00:01:36,000
on andmete tüüpi täisarv.

23
00:01:36,000 --> 00:01:42,000
Argc parameeter sisaldab mitmeid argumente, sealhulgas oskus.

24
00:01:42,000 --> 00:01:47,000
Meie move käsu, kuigi meil on ainult kaks argumenti kuvata,

25
00:01:47,000 --> 00:01:50,000
argc väärtus saab olema 3.

26
00:01:50,000 --> 00:01:56,000
Teine parameeter, argv, mis tähistab argument vektor,

27
00:01:56,000 --> 00:02:01,000
on array char vihjeid, mis viitavad stringid.

28
00:02:01,000 --> 00:02:06,000
>> See tähendab, et iga element argv, alates nullist,

29
00:02:06,000 --> 00:02:09,000
sisaldab käsku ja argumente.

30
00:02:09,000 --> 00:02:16,000
Näiteks argv [0], mis ma viidata kui argv null,

31
00:02:16,000 --> 00:02:20,000
sisaldab alati käsk, kus peal töötab -

32
00:02:20,000 --> 00:02:22,000
sel juhul MV.

33
00:02:22,000 --> 00:02:28,000
argv [1] peab sisaldama esimene argument, fail.txt,

34
00:02:28,000 --> 00:02:37,000
ja argv [2] sisaldab teist argumenti, ~ / cs50 /.

35
00:02:37,000 --> 00:02:42,000
Viimane argument argv on alati null.

36
00:02:42,000 --> 00:02:46,000
Nii et olgem rakendada neid käsurea argumente.

37
00:02:46,000 --> 00:02:53,000
Varasematel harjutusi, panime tühine, mis tähendab midagi, kui peamine parameetri.

38
00:02:53,000 --> 00:02:57,000
Kuid selleks, et me kasutame käsurea argumendid,

39
00:02:57,000 --> 00:03:12,000
peame kõrvaldama tühine ja koht sees peamine int argc, char * argv [].

40
00:03:12,000 --> 00:03:17,000
Nüüd juurdepääsu kogu elemendi argv, mis on oma argumendid,

41
00:03:17,000 --> 00:03:21,000
siis saad lihtsalt kinnitada, või silmus, läbi massiivi niimoodi.

42
00:03:21,000 --> 00:03:27,000
Niisiis, sees peamine keha, me ei kavatse minna ja kirjuta jaoks silmus:

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

44
00:03:37,000 --> 00:03:41,000
>> Me ei vaja lokkis traksidega siin, sest me ainult selle ühe rida koodi

45
00:03:41,000 --> 00:03:44,000
kehas see silmus.

46
00:03:44,000 --> 00:03:47,000
Me läheme edasi ja vajuta lingile kord,

47
00:03:47,000 --> 00:03:57,000
tippige printf ("argv [% d], kes esindab täisarv,

48
00:03:57,000 --> 00:04:06,000
on% s, keelpilliorkestrile, siis reavahetusmärki.

49
00:04:06,000 --> 00:04:12,000
Siis pakume printf i jooksva iteratsiooni loop

50
00:04:12,000 --> 00:04:18,000
ja argv [i] jaoks string esindatuse praeguse käsurea argument.

51
00:04:18,000 --> 00:04:25,000
Kui võtame seda kaks argumenti, näeme argumente, kuvatakse terminali.

52
00:04:34,000 --> 00:04:38,000
Varem ütlesime, et argv toimunud massiivi char suunanäitajaks.

53
00:04:38,000 --> 00:04:45,000
>> Niisiis, kui see on nii, kuidas me siis pääseda üksikute märkide iga argument?

54
00:04:45,000 --> 00:04:51,000
Näiteks kui ma tahtsin otsida eripära esimeses argument?

55
00:04:51,000 --> 00:04:55,000
Noh, vastus on, et me peame taotlema nested loop

56
00:04:55,000 --> 00:04:59,000
et siis kinnitada, läbi iga elementi argument string.

57
00:04:59,000 --> 00:05:02,000
See, kuidas sa seda teed.

58
00:05:02,000 --> 00:05:10,000
>> Esiteks, me ei kavatse teha koopia example2.c.

59
00:05:10,000 --> 00:05:13,000
Seejärel sees esimese jaoks silmus,

60
00:05:13,000 --> 00:05:15,000
me kavatseme lisada täiendavaid jaoks silmus.

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

62
00:05:28,000 --> 00:05:32,000
mis siis annab meile pikkus praegune argument,

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

64
00:05:39,000 --> 00:05:43,000
Me läheme printida asukoht iga märk

65
00:05:43,000 --> 00:05:47,000
sees praegune argument kasutades printf.

66
00:05:47,000 --> 00:05:57,000
Nii printf ("argv [% d], kes esindab indeks praegune argument,

67
00:05:57,000 --> 00:06:05,000
siis [% d] taas, et kajastada praegust iseloomu praegune argument,

68
00:06:05,000 --> 00:06:13,000
on:% c, praeguse iseloomuga argument.

69
00:06:13,000 --> 00:06:20,000
Lõpuks anname printf koos indeksi välimine silmus, i,

70
00:06:20,000 --> 00:06:22,000
siis indeks sisemise silmus.

71
00:06:22,000 --> 00:06:28,000
>> Ja meie viimane argument printf on tegelik tegelasele argument ette

72
00:06:28,000 --> 00:06:31,000
käsureal.

73
00:06:31,000 --> 00:06:37,000
Nüüd, kuna ma kasutasin string funktsioon strlen saada pikkus string,

74
00:06:37,000 --> 00:06:43,000
Pean ka lisama string.h raamatukogu tippu meie hulka.

75
00:06:43,000 --> 00:06:50,000
Niisiis, mida teha, et me läheme üles ja napilt stdio.h, me teeme

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

77
00:06:57,000 --> 00:07:02,000
>> Niisiis, oletame, kompileerida ja käivitada ning anda see tegelik argument.

78
00:07:09,000 --> 00:07:18,000
>> Ja nagu näeme, on meil nüüd täpset asukohta iga char argument.

79
00:07:18,000 --> 00:07:23,000
Nii ongi. Ma olen Christopher Bartolomeus, see on CS50.

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