1
00:00:00,000 --> 00:00:02,480
>> [Muusika mängib]

2
00:00:02,480 --> 00:00:06,460

3
00:00:06,460 --> 00:00:09,350
>> DOUG LLOYD: Okei, nii et olgem
rääkida käsurea argumente.

4
00:00:09,350 --> 00:00:11,800
Nii, siiani käigus päris
palju kõik oma programmid

5
00:00:11,800 --> 00:00:16,360
tõenäoliselt alguse saanud
nagu see-- int main void.

6
00:00:16,360 --> 00:00:18,310
Oleme kogunud
kasutaja sisend, kui me seda vajame

7
00:00:18,310 --> 00:00:21,080
meie programmides nagu
Mario programmi, näiteks

8
00:00:21,080 --> 00:00:22,990
in-programmi juhiseid.

9
00:00:22,990 --> 00:00:25,190
Me ei ole vaja muuta
deklaratsiooni peamine,

10
00:00:25,190 --> 00:00:30,684
sest selle asemel sees peamine me
lihtsalt öelda, siis võib seda nimetada saada int.

11
00:00:30,684 --> 00:00:32,350
Kui suur sa tahad püramiidi olla?

12
00:00:32,350 --> 00:00:34,455
Või siis võib seda nimetada saada
float-- kui palju muutusi

13
00:00:34,455 --> 00:00:36,400
ma peaksin väljund kasutaja?

14
00:00:36,400 --> 00:00:38,630
>> On veel üks viis küll,
ja kui me tahame, et meie kasutajad

15
00:00:38,630 --> 00:00:40,580
olema võimelised andma
andmed meie programmi

16
00:00:40,580 --> 00:00:43,320
käivitamisel asemel samas
programm töötab,

17
00:00:43,320 --> 00:00:45,910
peen vahet, kuid
mõnikord väga kasulik oon,

18
00:00:45,910 --> 00:00:48,120
Vajame uut vormi kuulutatakse peamine.

19
00:00:48,120 --> 00:00:53,320
Me ei saa kasutada int main void kui me tahame
koguda muid andmeid käsurea

20
00:00:53,320 --> 00:00:57,540
kui kasutaja käivitab programmi,
seega käsurea argumente.

21
00:00:57,540 --> 00:00:59,810
>> Koguda neid käsurea
argumendid kasutaja,

22
00:00:59,810 --> 00:01:03,140
muuta oma deklaratsiooni
Peamised nägema see-- int

23
00:01:03,140 --> 00:01:10,450
Peamine, avatud paren, int Argc, koma,
string argv, nurksulgudes,

24
00:01:10,450 --> 00:01:12,670
ja avage lokkis traksidega.

25
00:01:12,670 --> 00:01:14,415
Mida see tähendab juba?

26
00:01:14,415 --> 00:01:19,410
Noh, me möödub kaks parameetrit,
või argumendid või sisendite peamine.

27
00:01:19,410 --> 00:01:23,800
Üks, täisarv nimetatakse
Argc, ja teine ​​on mis?

28
00:01:23,800 --> 00:01:26,430

29
00:01:26,430 --> 00:01:29,640
See on massiivi stringe, eks?

30
00:01:29,640 --> 00:01:31,140
Me näeme, et nurksulg märke.

31
00:01:31,140 --> 00:01:32,181
See on massiivi stringe.

32
00:01:32,181 --> 00:01:35,110
See ei ole individuaalne string,
see on massiivi stringe.

33
00:01:35,110 --> 00:01:39,640
Ja need kaks argumenti, Argc ja argv,
võimaldab teil teada, milliseid andmeid kasutaja

34
00:01:39,640 --> 00:01:42,912
andis tööd käsurea
ja kui palju nad

35
00:01:42,912 --> 00:01:44,120
osutatakse käsurea.

36
00:01:44,120 --> 00:01:46,570
Päris kasulikud asjad töötada.

37
00:01:46,570 --> 00:01:50,310
>> Argc seisab argument loota,
ja sa peaksid teadma, muide,

38
00:01:50,310 --> 00:01:52,600
et sa võid helistada Argc
mida iganes sa tahad seda.

39
00:01:52,600 --> 00:01:54,710
Teil on võimalik helistada argv iganes sa tahtsid.

40
00:01:54,710 --> 00:01:58,740
Need on vaid tavalised nimed
et me kasutame them-- argument loota,

41
00:01:58,740 --> 00:02:00,907
ja nagu me näeme teise,
argument vektor, argv.

42
00:02:00,907 --> 00:02:03,698
Aga sa ei pea neid nimetada
Argc ja argv kui sa ei taha,

43
00:02:03,698 --> 00:02:05,570
aga tavapäraselt, see on, mida me teeme.

44
00:02:05,570 --> 00:02:07,500
>> Igatahes, Argc argument loota.

45
00:02:07,500 --> 00:02:11,569
See on täisarv-tüüpi muutuja ja nii, nagu
te võite arvata, kui meil on kaks asja

46
00:02:11,569 --> 00:02:13,860
et me ei kavatse olla leidmine
millised need on trükitud

47
00:02:13,860 --> 00:02:16,070
ja kui palju kraami
kasutaja sisestatud, Argc on

48
00:02:16,070 --> 00:02:18,559
läheb ütle meile, kui palju
kraami kasutaja sisestatud.

49
00:02:18,559 --> 00:02:20,850
Nii et see annab sulle mitmeid
käsurea argumente kasutaja

50
00:02:20,850 --> 00:02:22,470
trükitud kui programm hukati.

51
00:02:22,470 --> 00:02:25,780
Seega, kui teie programm on
joosta dot kaldkriips ahne,

52
00:02:25,780 --> 00:02:28,670
ja sees oma ahne
programmeerida oma põhifunktsiooni

53
00:02:28,670 --> 00:02:34,800
on deklaratsiooni int main int Argc,
string argv nurksulgudes, siis

54
00:02:34,800 --> 00:02:37,950
Argc sel juhul on üks.

55
00:02:37,950 --> 00:02:40,200
Nüüd märkate me ei
lugema, kui palju asju

56
00:02:40,200 --> 00:02:42,590
kasutaja sisestatud pärast programmi nimi.

57
00:02:42,590 --> 00:02:46,710
Programmi nimi ise loeb
kui käsurea argument.

58
00:02:46,710 --> 00:02:51,770
>> Nii dot kaldkriips ahne, in
Sellisel juhul Argc on üks.

59
00:02:51,770 --> 00:02:57,910
Kui kasutaja sisestatud kaldkriipsuga ahne 1024 CS50
kell käsurea, Argc sel juhul

60
00:02:57,910 --> 00:02:59,520
oleks kolm.

61
00:02:59,520 --> 00:03:03,720
Ja me teame seda, sest teed
et jagunemine stringid

62
00:03:03,720 --> 00:03:06,030
tuvastatakse, kas
seal on ruumi, või tab,

63
00:03:06,030 --> 00:03:08,230
või midagi sellist nende vahel.

64
00:03:08,230 --> 00:03:13,860
Seetõttu on igasugune summa tühja ruumi, nn,
väärtuste vahel kirjutatud käsurea

65
00:03:13,860 --> 00:03:15,720
näitab, kui palju on.

66
00:03:15,720 --> 00:03:24,040
Nii dot kaldkriips ahne ruumi 1024 ruumi
CS50, Argc, sel juhul on kolm.

67
00:03:24,040 --> 00:03:26,600
>> Argv on argument vektor.

68
00:03:26,600 --> 00:03:29,240
Vector, muide, on lihtsalt
teise sõna array,

69
00:03:29,240 --> 00:03:31,510
ja see on massiivi
mis talletab stringid.

70
00:03:31,510 --> 00:03:35,540
Üks string per element, mis on
stringid, et kasutaja tegelikult

71
00:03:35,540 --> 00:03:39,230
trükitud on käsurea
kui programm hukati.

72
00:03:39,230 --> 00:03:40,990
Nüüd, kui on tegemist
iga massiivi, kui te

73
00:03:40,990 --> 00:03:44,380
mäletate meie arutelu
massiivid, esimene osa argv

74
00:03:44,380 --> 00:03:49,150
alati saab leida
kell argv nurksulg null.

75
00:03:49,150 --> 00:03:51,800
See on esimene indeks
on argv massiivi.

76
00:03:51,800 --> 00:03:55,720
Nii et will-- ja tegelikult, mis
alati programmi nimi,

77
00:03:55,720 --> 00:03:59,730
alati asuma
argv nurksulg null.

78
00:03:59,730 --> 00:04:08,590
>> Viimane osa argv on alati leitud
kell argv nurksulgudes Argc miinus üks.

79
00:04:08,590 --> 00:04:10,300
Kas sa näed, miks?

80
00:04:10,300 --> 00:04:14,180
Pea meeles, kui palju elemente
eksisteerivad selle massiivi.

81
00:04:14,180 --> 00:04:16,660
Noh, me teame, selle-- see
Argc mitmeid elemente.

82
00:04:16,660 --> 00:04:21,279
Kui kasutaja sisestatud kolm asja juures
käsurea, Argc on kolm.

83
00:04:21,279 --> 00:04:27,070
Aga kuna c, kui me töötame
massiivid, iga element massiivi,

84
00:04:27,070 --> 00:04:30,190
või pigem indeksid
massiivi, alustada nullist.

85
00:04:30,190 --> 00:04:34,000
Kui meil on kolm elementi meie
massiiv, meil on element argv null,

86
00:04:34,000 --> 00:04:37,930
element on argv üks,
ja üht elementi argv kaks.

87
00:04:37,930 --> 00:04:41,700
Ei ole element argv
kolm ja hulgaliselt suurus kolm.

88
00:04:41,700 --> 00:04:43,990
Nii et miks viimane
element argv saab alati

89
00:04:43,990 --> 00:04:49,510
kättesaadavad argv ruut
Sulgudes Argc miinus üks.

90
00:04:49,510 --> 00:04:52,420
>> Nii Oletame kasutaja vormistab
ahne programmi follows--

91
00:04:52,420 --> 00:04:57,970
kui nad kirjuta käsurea dot
kaldkriips ahne ruumi 1024 ruumi CS50,

92
00:04:57,970 --> 00:05:00,720
ja mingil põhjusel me oleme
juba valmis meie ahne programmi

93
00:05:00,720 --> 00:05:04,050
teada ning teeb nimetatud
käsurea argumente.

94
00:05:04,050 --> 00:05:07,030
Me pole varem kui me teinud
seda, et ahne probleem,

95
00:05:07,030 --> 00:05:09,660
aga oletame, et me oleme nüüd muudetud
see, et me teeme protsessi

96
00:05:09,660 --> 00:05:11,480
käsurea argumente kuidagi.

97
00:05:11,480 --> 00:05:15,720
Sel juhul argv null
on dot kaldkriipsuga ahne.

98
00:05:15,720 --> 00:05:17,042
Mis argv üks?

99
00:05:17,042 --> 00:05:19,030
Noh, see on 1024 eks?

100
00:05:19,030 --> 00:05:22,620
See on 1024, kuid siin on
tõesti oluline distinction--

101
00:05:22,620 --> 00:05:26,410
Kas sa mäletad andmete tüüpi argv?

102
00:05:26,410 --> 00:05:31,020
>> See salvestab stringid, eks?

103
00:05:31,020 --> 00:05:34,140
Aga tundub, et 1024
on täisarv.

104
00:05:34,140 --> 00:05:36,530
See on tõesti oluline
vahet ega on tegelikult

105
00:05:36,530 --> 00:05:40,200
hakkab muutuma midagi, mida
võib tekkida ka hiljem probleeme.

106
00:05:40,200 --> 00:05:43,770
Kõigel argv on
salvestatud stringi.

107
00:05:43,770 --> 00:05:48,775
Nii argv üks sisu on
string ühe, nulli, kaks, neli,

108
00:05:48,775 --> 00:05:50,275
koosneb nendest neli märki.

109
00:05:50,275 --> 00:05:53,870
See on sama, kui kasutaja sisestatud
üks, null, kaks, neli

110
00:05:53,870 --> 00:05:56,680
kui üksikuid tähti või sümboleid.

111
00:05:56,680 --> 00:06:00,730
See ei ole täisarv 1024,
ja et sa ei saa otseselt

112
00:06:00,730 --> 00:06:11,580
töötada selle juurde int 1000, või
pigem int x võrdub argv üks miinus 24.

113
00:06:11,580 --> 00:06:15,550
>> Intuitiivselt, siis võiks mõelda, et
nagu OK, ka see on 1024 miinus 24,

114
00:06:15,550 --> 00:06:17,920
nii x on võrdne 1000.

115
00:06:17,920 --> 00:06:22,020
Aga tegelikult, et see ei ole nii,
sest argv üks on string.

116
00:06:22,020 --> 00:06:23,940
String 1024.

117
00:06:23,940 --> 00:06:28,739
Nüüd on funktsioon, mis võib olla
kasutatakse teisendada stringi täisarvud.

118
00:06:28,739 --> 00:06:30,780
Ma ei riku seda teile
nüüd, kuid ma olen kindel, et Zamyla

119
00:06:30,780 --> 00:06:34,380
on hea meel öelda teile seda
läbikäiguks tulevase probleemi.

120
00:06:34,380 --> 00:06:36,390
Aga sa võid leida ka
probleeme like-- vabandus

121
00:06:36,390 --> 00:06:39,921
Mulle funktsioone, mis
Selleks viites 50,

122
00:06:39,921 --> 00:06:42,462
kui te lähete viiteteatmik
leiad funktsioon, mis

123
00:06:42,462 --> 00:06:43,820
teeb selle muutmise eest.

124
00:06:43,820 --> 00:06:45,980
Aga jälle, et läbikäiguks
Tuleviku probleem,

125
00:06:45,980 --> 00:06:48,290
Zamyla hea meelega
öelda, mida funktsioon

126
00:06:48,290 --> 00:06:53,280
see on see, et konverteerib
string 1024 kuni täisarv 1024.

127
00:06:53,280 --> 00:06:54,560
>> Olgu, nii liigub.

128
00:06:54,560 --> 00:06:56,726
Oleme kaetud meie argv null,
oleme kaetud argv üks.

129
00:06:56,726 --> 00:06:58,000
Mis on argv kaks?

130
00:06:58,000 --> 00:06:58,620
CS50.

131
00:06:58,620 --> 00:07:01,350
See üks on ilmselt
üsna selgituseta.

132
00:07:01,350 --> 00:07:02,950
Mis on argv kolm?

133
00:07:02,950 --> 00:07:04,970
Noh jälle, me tõesti ei tea, eks?

134
00:07:04,970 --> 00:07:08,060
Meil on hulgaliselt suurus kolm,
see, kui palju elemente kasutaja

135
00:07:08,060 --> 00:07:11,610
trükitud on käsurea,
nii et kui me läheme argv kolm,

136
00:07:11,610 --> 00:07:14,660
me nüüd ületamisele
piire meie massiivi.

137
00:07:14,660 --> 00:07:18,570
Kompilaator tehkem seda,
pole intuitiivne probleem see,

138
00:07:18,570 --> 00:07:22,890
kuid nii tegelikult, mis toimub
juhtuda, et me ei tea.

139
00:07:22,890 --> 00:07:25,380
See sõltub sellest, mida on
asub mälu, kuhu

140
00:07:25,380 --> 00:07:28,060
argv kolm võiks eeldada, et olla.

141
00:07:28,060 --> 00:07:30,716
Ja nii me võiks lõpuks
saada eemale karistamata tasuta.

142
00:07:30,716 --> 00:07:33,840
Tõenäolisem kui mitte, eriti kui
te töötate argv erinevalt

143
00:07:33,840 --> 00:07:35,548
mis tahes muu massiivi
see on meie programmi,

144
00:07:35,548 --> 00:07:38,660
me ilmselt läheb kannatada
laevastikuosi süü. Nii jälle,

145
00:07:38,660 --> 00:07:42,756
kindlasti mitte väljuda piire
oma massiivid, eriti argv,

146
00:07:42,756 --> 00:07:47,170
arvestades tema suurt
tähtsust oma programmides.

147
00:07:47,170 --> 00:07:48,100
>> Ma olen Doug Lloyd.

148
00:07:48,100 --> 00:07:50,170
See on CS50.

149
00:07:50,170 --> 00:07:51,457