>> [Muusika mängib]
>> DOUG LLOYD: Okei, nii et olgem rääkida käsurea argumente.
Nii, siiani käigus päris palju kõik oma programmid
tõenäoliselt alguse saanud nagu see-- int main void.
Oleme kogunud kasutaja sisend, kui me seda vajame
meie programmides nagu Mario programmi, näiteks
in-programmi juhiseid.
Me ei ole vaja muuta deklaratsiooni peamine,
sest selle asemel sees peamine me lihtsalt öelda, siis võib seda nimetada saada int.
Kui suur sa tahad püramiidi olla?
Või siis võib seda nimetada saada float-- kui palju muutusi
ma peaksin väljund kasutaja?
>> On veel üks viis küll, ja kui me tahame, et meie kasutajad
olema võimelised andma andmed meie programmi
käivitamisel asemel samas programm töötab,
peen vahet, kuid mõnikord väga kasulik oon,
Vajame uut vormi kuulutatakse peamine.
Me ei saa kasutada int main void kui me tahame koguda muid andmeid käsurea
kui kasutaja käivitab programmi, seega käsurea argumente.
>> Koguda neid käsurea argumendid kasutaja,
muuta oma deklaratsiooni Peamised nägema see-- int
Peamine, avatud paren, int Argc, koma, string argv, nurksulgudes,
ja avage lokkis traksidega.
Mida see tähendab juba?
Noh, me möödub kaks parameetrit, või argumendid või sisendite peamine.
Üks, täisarv nimetatakse Argc, ja teine ​​on mis?
See on massiivi stringe, eks?
Me näeme, et nurksulg märke.
See on massiivi stringe.
See ei ole individuaalne string, see on massiivi stringe.
Ja need kaks argumenti, Argc ja argv, võimaldab teil teada, milliseid andmeid kasutaja
andis tööd käsurea ja kui palju nad
osutatakse käsurea.
Päris kasulikud asjad töötada.
>> Argc seisab argument loota, ja sa peaksid teadma, muide,
et sa võid helistada Argc mida iganes sa tahad seda.
Teil on võimalik helistada argv iganes sa tahtsid.
Need on vaid tavalised nimed et me kasutame them-- argument loota,
ja nagu me näeme teise, argument vektor, argv.
Aga sa ei pea neid nimetada Argc ja argv kui sa ei taha,
aga tavapäraselt, see on, mida me teeme.
>> Igatahes, Argc argument loota.
See on täisarv-tüüpi muutuja ja nii, nagu te võite arvata, kui meil on kaks asja
et me ei kavatse olla leidmine millised need on trükitud
ja kui palju kraami kasutaja sisestatud, Argc on
läheb ütle meile, kui palju kraami kasutaja sisestatud.
Nii et see annab sulle mitmeid käsurea argumente kasutaja
trükitud kui programm hukati.
Seega, kui teie programm on joosta dot kaldkriips ahne,
ja sees oma ahne programmeerida oma põhifunktsiooni
on deklaratsiooni int main int Argc, string argv nurksulgudes, siis
Argc sel juhul on üks.
Nüüd märkate me ei lugema, kui palju asju
kasutaja sisestatud pärast programmi nimi.
Programmi nimi ise loeb kui käsurea argument.
>> Nii dot kaldkriips ahne, in Sellisel juhul Argc on üks.
Kui kasutaja sisestatud kaldkriipsuga ahne 1024 CS50 kell käsurea, Argc sel juhul
oleks kolm.
Ja me teame seda, sest teed et jagunemine stringid
tuvastatakse, kas seal on ruumi, või tab,
või midagi sellist nende vahel.
Seetõttu on igasugune summa tühja ruumi, nn, väärtuste vahel kirjutatud käsurea
näitab, kui palju on.
Nii dot kaldkriips ahne ruumi 1024 ruumi CS50, Argc, sel juhul on kolm.
>> Argv on argument vektor.
Vector, muide, on lihtsalt teise sõna array,
ja see on massiivi mis talletab stringid.
Üks string per element, mis on stringid, et kasutaja tegelikult
trükitud on käsurea kui programm hukati.
Nüüd, kui on tegemist iga massiivi, kui te
mäletate meie arutelu massiivid, esimene osa argv
alati saab leida kell argv nurksulg null.
See on esimene indeks on argv massiivi.
Nii et will-- ja tegelikult, mis alati programmi nimi,
alati asuma argv nurksulg null.
>> Viimane osa argv on alati leitud kell argv nurksulgudes Argc miinus üks.
Kas sa näed, miks?
Pea meeles, kui palju elemente eksisteerivad selle massiivi.
Noh, me teame, selle-- see Argc mitmeid elemente.
Kui kasutaja sisestatud kolm asja juures käsurea, Argc on kolm.
Aga kuna c, kui me töötame massiivid, iga element massiivi,
või pigem indeksid massiivi, alustada nullist.
Kui meil on kolm elementi meie massiiv, meil on element argv null,
element on argv üks, ja üht elementi argv kaks.
Ei ole element argv kolm ja hulgaliselt suurus kolm.
Nii et miks viimane element argv saab alati
kättesaadavad argv ruut Sulgudes Argc miinus üks.
>> Nii Oletame kasutaja vormistab ahne programmi follows--
kui nad kirjuta käsurea dot kaldkriips ahne ruumi 1024 ruumi CS50,
ja mingil põhjusel me oleme juba valmis meie ahne programmi
teada ning teeb nimetatud käsurea argumente.
Me pole varem kui me teinud seda, et ahne probleem,
aga oletame, et me oleme nüüd muudetud see, et me teeme protsessi
käsurea argumente kuidagi.
Sel juhul argv null on dot kaldkriipsuga ahne.
Mis argv üks?
Noh, see on 1024 eks?
See on 1024, kuid siin on tõesti oluline distinction--
Kas sa mäletad andmete tüüpi argv?
>> See salvestab stringid, eks?
Aga tundub, et 1024 on täisarv.
See on tõesti oluline vahet ega on tegelikult
hakkab muutuma midagi, mida võib tekkida ka hiljem probleeme.
Kõigel argv on salvestatud stringi.
Nii argv üks sisu on string ühe, nulli, kaks, neli,
koosneb nendest neli märki.
See on sama, kui kasutaja sisestatud üks, null, kaks, neli
kui üksikuid tähti või sümboleid.
See ei ole täisarv 1024, ja et sa ei saa otseselt
töötada selle juurde int 1000, või pigem int x võrdub argv üks miinus 24.
>> Intuitiivselt, siis võiks mõelda, et nagu OK, ka see on 1024 miinus 24,
nii x on võrdne 1000.
Aga tegelikult, et see ei ole nii, sest argv üks on string.
String 1024.
Nüüd on funktsioon, mis võib olla kasutatakse teisendada stringi täisarvud.
Ma ei riku seda teile nüüd, kuid ma olen kindel, et Zamyla
on hea meel öelda teile seda läbikäiguks tulevase probleemi.
Aga sa võid leida ka probleeme like-- vabandus
Mulle funktsioone, mis Selleks viites 50,
kui te lähete viiteteatmik leiad funktsioon, mis
teeb selle muutmise eest.
Aga jälle, et läbikäiguks Tuleviku probleem,
Zamyla hea meelega öelda, mida funktsioon
see on see, et konverteerib string 1024 kuni täisarv 1024.
>> Olgu, nii liigub.
Oleme kaetud meie argv null, oleme kaetud argv üks.
Mis on argv kaks?
CS50.
See üks on ilmselt üsna selgituseta.
Mis on argv kolm?
Noh jälle, me tõesti ei tea, eks?
Meil on hulgaliselt suurus kolm, see, kui palju elemente kasutaja
trükitud on käsurea, nii et kui me läheme argv kolm,
me nüüd ületamisele piire meie massiivi.
Kompilaator tehkem seda, pole intuitiivne probleem see,
kuid nii tegelikult, mis toimub juhtuda, et me ei tea.
See sõltub sellest, mida on asub mälu, kuhu
argv kolm võiks eeldada, et olla.
Ja nii me võiks lõpuks saada eemale karistamata tasuta.
Tõenäolisem kui mitte, eriti kui te töötate argv erinevalt
mis tahes muu massiivi see on meie programmi,
me ilmselt läheb kannatada laevastikuosi süü. Nii jälle,
kindlasti mitte väljuda piire oma massiivid, eriti argv,
arvestades tema suurt tähtsust oma programmides.
>> Ma olen Doug Lloyd.
See on CS50.