1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Komandrindas argumenti]

2
00:00:02,000 --> 00:00:04,000
[Christopher Bērtuli - Hārvarda]

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

4
00:00:07,000 --> 00:00:11,000
Noderīgs līdzeklis programmai ir pieņemt lietotāja ievadi.

5
00:00:11,000 --> 00:00:15,000
Līdz šim mēs esam izpētīt dažas funkcijas ietvaros CS50 bibliotēkā

6
00:00:15,000 --> 00:00:18,000
pieņemt lietotāja ievadi, piemēram, "get virkne,"

7
00:00:18,000 --> 00:00:23,000
kas liek lietotājam, kamēr darbojas programma, par virkni.

8
00:00:23,000 --> 00:00:28,000
>> Tomēr ir gadījumi, kad jūs vēlaties, lai nodrošinātu jūsu programma ievadi

9
00:00:28,000 --> 00:00:30,000
pirms tas faktiski darbojas.

10
00:00:30,000 --> 00:00:34,000
Tādā veidā, jums nav nepieciešams pieprasīt papildu informāciju no sava lietotāja

11
00:00:34,000 --> 00:00:38,000
vienlaikus izpildot vienkāršu uzdevumu.

12
00:00:38,000 --> 00:00:42,000
Veikt, piemēram, MV vai pārvietotu komandu UNIX.

13
00:00:42,000 --> 00:00:49,000
Šī komanda ļauj lietotājam pārvietoties failu no vienas vietas uz citu.

14
00:00:49,000 --> 00:00:55,000
Saskaņā ar manuālo lapām, MV akceptē divi komandrindas argumentus:

15
00:00:55,000 --> 00:01:00,000
fails, kas tiek pārvietots un atrašanās fails tiek pārvietots uz.

16
00:01:00,000 --> 00:01:06,000
Tātad šis piemērs ir komandu ar diviem argumentiem.

17
00:01:06,000 --> 00:01:14,000
Tātad, kā mēs pateikt mūsu C programmu izmantot šīs komandrindas argumentus?

18
00:01:14,000 --> 00:01:20,000
>> Nu, izrādās, ka galvenais, ko mēs izmantot visu C programmās, ir noslēpums.

19
00:01:20,000 --> 00:01:26,000
Galvenais akceptē divi parametri: argc un argv.

20
00:01:26,000 --> 00:01:28,000
Iesim pa šiem noteikumiem.

21
00:01:28,000 --> 00:01:33,000
>> Pirmais parametrs, argc, kas apzīmē arguments skaits,

22
00:01:33,000 --> 00:01:36,000
ir datu tipu skaitlim.

23
00:01:36,000 --> 00:01:42,000
The argc parametrs satur vairākus argumentus, tostarp komandu.

24
00:01:42,000 --> 00:01:47,000
Mūsu komandu Pārvietot, lai gan mums ir tikai divi argumenti redzams,

25
00:01:47,000 --> 00:01:50,000
argc vērtība būs 3.

26
00:01:50,000 --> 00:01:56,000
Otrs rādītājs, argv, kas apzīmē arguments vektors,

27
00:01:56,000 --> 00:02:01,000
ir masīvs char norādes, kas norāda uz stīgas.

28
00:02:01,000 --> 00:02:06,000
>> Tas nozīmē, ka katrs argv elements, sākot no nulles,

29
00:02:06,000 --> 00:02:09,000
satur komandu un argumentus.

30
00:02:09,000 --> 00:02:16,000
Piemēram, argv [0], ko es ņemšu uz kā nulles argv,

31
00:02:16,000 --> 00:02:20,000
vienmēr satur komandu, kas tiek īstenots -

32
00:02:20,000 --> 00:02:22,000
Šajā gadījumā, MV.

33
00:02:22,000 --> 00:02:28,000
argv [1] jānorāda pirmo argumentu, file.txt,

34
00:02:28,000 --> 00:02:37,000
un argv [2] jānorāda uz otro argumentu, ~ / CS50 /.

35
00:02:37,000 --> 00:02:42,000
Pēdējais arguments argv vienmēr būs nulle.

36
00:02:42,000 --> 00:02:46,000
Tāpēc pieņemsim ieviest šīs komandrindas argumentus.

37
00:02:46,000 --> 00:02:53,000
Iepriekšējās vingrinājumus, mēs ievietots tukšumu, kas nozīmē neko, jo Main s parametrs.

38
00:02:53,000 --> 00:02:57,000
Tomēr, lai mēs varētu izmantot komandrindas argumentus,

39
00:02:57,000 --> 00:03:12,000
Mums ir nepieciešams, lai novērstu neesošu un vieta iekšpusē galveno int argc, char * argv [].

40
00:03:12,000 --> 00:03:17,000
Tagad, lai piekļūtu visu elementu no argv, kas ir jūsu argumenti,

41
00:03:17,000 --> 00:03:21,000
Jūs varat vienkārši atkārtot, vai cilpa, caur masīvu kā šis.

42
00:03:21,000 --> 00:03:27,000
Tātad, iekšpusē no galvenajiem ķermeņa, mēs ejam, lai iet uz priekšu un rakstīt par cilpu:

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

44
00:03:37,000 --> 00:03:41,000
>> Mums nav vajadzīga cirtaini lencēm šeit, jo mēs esam tikai izpildot vienu rindiņu kodu

45
00:03:41,000 --> 00:03:44,000
organismā šī cilpa.

46
00:03:44,000 --> 00:03:47,000
Mēs iesim uz priekšu un hit cilni vienreiz,

47
00:03:47,000 --> 00:03:57,000
ierakstiet printf ("argv [% d], lai pārstāvētu veselu vērtību,

48
00:03:57,000 --> 00:04:06,000
ir% s, virknes, tad jaunā līnija raksturs.

49
00:04:06,000 --> 00:04:12,000
Tad mēs piedāvājam printf I pašreizējā atkārtojuma no cilpas

50
00:04:12,000 --> 00:04:18,000
un argv [i] par stīgu pārstāvību pašreizējās komandrindas arguments.

51
00:04:18,000 --> 00:04:25,000
Kad mēs palaist to ar diviem argumentiem, mēs redzēsim argumentus tiek parādītas terminālā.

52
00:04:34,000 --> 00:04:38,000
Agrāk mēs teicām, ka argv notika masīvs char norādes.

53
00:04:38,000 --> 00:04:45,000
>> Tātad, ja tas ir gadījumā, kā mēs pēc tam piekļūt atsevišķas rakstzīmes katrā argumentu?

54
00:04:45,000 --> 00:04:51,000
Piemēram, kas notiks, ja es gribēju meklēt īpaša rakstura pirmo argumentu?

55
00:04:51,000 --> 00:04:55,000
Nu, atbilde ir tāda, ka mums jāpiemēro Nested cilpas

56
00:04:55,000 --> 00:04:59,000
ka tad atkārtot, izmantojot katru no argumenta virknē elementiem.

57
00:04:59,000 --> 00:05:02,000
Tas ir, kā jūs to darīt.

58
00:05:02,000 --> 00:05:10,000
>> Pirmkārt, mēs esam gatavojas veikt kopiju example2.c.

59
00:05:10,000 --> 00:05:13,000
Tad iekšpusē pirmā cilpa,

60
00:05:13,000 --> 00:05:15,000
mēs esam gatavojas pievienot papildu cilpa.

61
00:05:15,000 --> 00:05:28,000
Tātad par (int j = 0, n = strlen (argv [i]),

62
00:05:28,000 --> 00:05:32,000
kas tad dod mums garumu pašreizējā argumentu,

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

64
00:05:39,000 --> 00:05:43,000
Mēs ejam, lai drukātu, kur atrodas katra rakstura

65
00:05:43,000 --> 00:05:47,000
iekšpusē pašreizējo argumentu izmantojot printf.

66
00:05:47,000 --> 00:05:57,000
Tātad, printf ("argv [% d], lai pārstāvētu indeksu pašreizējā argumentu,

67
00:05:57,000 --> 00:06:05,000
tad [% d] vēlreiz, lai pārstāvētu pašreizējo raksturu pašreizējā argumentu,

68
00:06:05,000 --> 00:06:13,000
ir:% c, par pašreizējo rakstura argumentu.

69
00:06:13,000 --> 00:06:20,000
Visbeidzot, mēs piedāvājam printf ar indeksu ārējā cilpas, es,

70
00:06:20,000 --> 00:06:22,000
tad indekss iekšējās cilpas.

71
00:06:22,000 --> 00:06:28,000
>> Un mūsu pēdējais arguments, lai printf ir faktiskais raksturs no sniegto argumentu

72
00:06:28,000 --> 00:06:31,000
pie komandrindas.

73
00:06:31,000 --> 00:06:37,000
Tagad, jo es izmanto virknes funkciju strlen iegūt garumu virknes,

74
00:06:37,000 --> 00:06:43,000
Man ir arī pievienot string.h bibliotēku uz augšu mūsu ietver.

75
00:06:43,000 --> 00:06:50,000
Tātad, lai to izdarītu, mēs iet uz augšu, un tikai zem stdio.h, mēs esam gatavojas darīt

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

77
00:06:57,000 --> 00:07:02,000
>> Tātad, pieņemsim apkopot un palaist, un nodrošināt to faktisko argumentu.

78
00:07:09,000 --> 00:07:18,000
>> Un, kā mēs varam redzēt, mums tagad ir noteikt precīzu atrašanās vietu katra atsevišķā char pamatots arguments.

79
00:07:18,000 --> 00:07:23,000
Tāpēc, ka tas arī viss. Es esmu Kristofers Bērtuli, tas ir CS50.

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