>> [Muziek]
>> DOUG LLOYD: Oke, dus laten we praten over command-line argumenten.
Tot nu toe in de loop vrij veel van al uw programma's
waarschijnlijk begonnen zoals dit-- int main leegte.
We zijn het verzamelen input van de gebruiker als we het nodig hebben
in onze programma's, zoals het Mario programma, bijvoorbeeld,
door in-programma aanwijzingen.
We hebben niet noodzakelijk te wijzigen de verklaring van de belangrijkste,
want in plaats binnenin main we gewoon zeggen, je kan bellen om int te krijgen.
Hoe groot wil je de piramide zijn?
Of u kunt het bellen om te krijgen float-- hoeveel verandering
moet ik output naar de gebruiker?
>> Er is een andere manier wel, en als we willen dat onze gebruikers
te kunnen bieden gegevens naar ons programma
bij runtime in plaats van tijdens het het programma wordt uitgevoerd,
een subtiel onderscheid, maar soms zeer nuttig is,
we hebben een nieuwe vorm van verklaren belangrijkste.
We kunnen geen gebruik maken van int main vervalt als we willen andere gegevens te verzamelen op de opdrachtregel
wanneer de gebruiker het programma loopt, vandaar command-line argumenten.
>> Om deze command-line verzamelen argumenten van de gebruiker,
wijzigen van uw verklaring van belangrijkste om te kijken als dit-- int
belangrijkste open paren, int argc, komma, touwtje argv, haken,
en open accolade.
Dus wat betekent dat al?
Nou, we passeren in twee parameters, of argumenten, of ingangen naar de belangrijkste.
One, een integer genaamd argc, en de andere is wat?
Het is een array van strings, toch?
We zien dat plein haakjesnotering.
Het is een array van strings.
Het is niet een individuele string het is een array van strings.
En deze twee argumenten, argc en argv, stellen u in staat om te weten welke gegevens de gebruiker
heeft verstrekt op de opdrachtregel en hoeveel dingen die ze
mits bij de command-line.
Vrij nuttige dingen om mee te werken.
>> Argc staat voor argument tellen, en je moet weten, door de manier,
dat je zou kunnen noemen argc wat je wilt.
U kunt argv wat je wilde bellen.
Dit zijn slechts de conventionele namen die we gebruiken voor them-- argument tellen,
en zoals we zullen zien in een tweede, argument vector, argv.
Maar je hoeft niet te bellen argc en argv als je niet wilt,
maar conventioneel, dat is wat we doen.
>> Dus toch, argc, de telling argument.
Het is een integer type variabele enzovoort, zoals je zou verwachten, als we twee dingen
dat we gaan te vinden wat deze worden getypt
en hoeveel spullen de gebruiker getypt, argc is
gaat ons vertellen hoeveel vul de gebruiker getypt.
Dus het geeft je een aantal command-line argumenten gebruiker
getypt toen het programma werd uitgevoerd.
Dus als je programma is gerund dot slash hebzuchtig,
en de binnenkant van uw hebzuchtige programmeren belangrijkste functie
heeft de verklaring int main int argc, touwtje argv vierkante haken, dan
argc in dat geval een.
Nu merken we dat niet doen optellen hoeveel dingen
de gebruiker getypte na de naam van het programma.
De naam van het programma zelf telt als een command-line argument.
>> Dus dot slash hebzuchtig, in dat geval argc is één.
Als de gebruiker getypte slash hebzuchtige 1024 CS50 op de opdrachtregel, argc in dat geval
drie zou zijn.
En we weten dit omdat de weg dat de scheiding tussen de snaren
gedetecteerd is of er is een ruimte, of een tabblad,
of iets dergelijks tussen hen.
Dus elke hoeveelheid witruimte, zogenaamde, tussen de waarden getypte command-line
geeft aan hoeveel het er zijn.
Dus dot slash hebzuchtige 1024 ruimte CS50, argc, in dat geval, is drie.
>> Argv is het argument vector.
Vector, door de manier, is gewoon ander woord voor een serie,
en dit is een matrix dat slaat strings.
Één snaar per element, dat de snaren die de gebruiker daadwerkelijk
getypt op de opdrachtregel toen het programma werd uitgevoerd.
Nu, zoals het geval bij elke array, als je
herinneren van onze bespreking van arrays, het eerste element van argv
zal altijd worden gevonden bij argv vierkante beugel nul.
Dat is de eerste index van de argv array.
Zodat will-- en in feite, dat wil de naam van het programma altijd,
zal altijd zich op argv vierkante beugel nul.
>> Het laatste element van argv altijd gevonden bij argv vierkante haakjes argc min één.
Zie je waarom?
Vergeet niet hoeveel elementen bestaan ​​in deze matrix.
Nou, we weten dat het dat-- argc aantal elementen.
Als de gebruiker drie dingen getypt op de command-line, argc is drie.
Maar omdat in c, wanneer we werken met arrays, elk element van de array,
of liever de indices van de array beginnen bij nul.
Als we drie elementen in onze array, hebben wij een element in argv nul,
een element in argv één, en een element in argv twee.
Er is geen enkel element in argv drie en een array van drie afmetingen.
Dus dat is de reden waarom de laatste element van argv kan altijd
is te vinden op argv vierkante beugels argc min één.
>> Dus laten we aannemen dat de gebruiker uitvoert de gulzige programma follows--
als ze typen in de opdrachtregel dot slash hebzuchtige 1024 ruimte CS50,
en om wat voor reden we hebben al onze gulzige programma voorbereid
kennen en werken met deze command-line argumenten.
We hebben niet eerder toen we werkten op het voor de gulzige probleem,
maar laten we zeggen dat we nu aangepast het zo dat we proces te doen
de command-line argumenten op een bepaalde manier.
In dit geval, argv nul is dot slash hebberig.
Wat is argv één?
Nou, het is 1024, niet?
Het is 1024, maar hier is een echt belangrijk distinction--
herinner je je het datatype van argv?
>> Het slaat strijkers, toch?
Maar het lijkt erop dat 1024 is een geheel getal.
Dit is een heel belangrijk onderscheid en eigenlijk
gaat iets geworden dat je tegenkomen in latere problemen.
Alles in argv is opgeslagen als een string.
Dus argv iemands inhoud zijn de snaar een, nul, twee, vier,
bestaande uit deze vier karakters.
Het is alsof de gebruiker getypte een, nul, twee, vier
als individuele letters of tekens.
Het is niet de gehele 1024, en dus kun je niet direct
werken door te zeggen int 1000, of eerder int x gelijk argv een minus 24.
>> Intuïtief zou je denken van die als, OK, nou het is 1024 minus 24,
dus x is gelijk aan 1.000.
Maar in feite is dat niet het geval is, want argv een is een string.
De string 1024.
Nu is er een functie die kan worden gebruikt om strings te converteren naar integers.
Ik zal niet bederven het voor u nu, maar ik ben er zeker van Zamyla
zal blij zijn om u te vertellen over het in de walkthrough voor een toekomstig probleem.
Maar u kunt ook problemen like-- excuus
me, functies die zou Dit doen in referentie 50,
als je naar de handleiding U kunt een functie vinden dat
zal deze conversie voor u maken.
Maar nogmaals, in de walkthrough voor een toekomstige problemen,
Zamyla zal blij zijn om u vertellen welke functie
is die converteren snaar 1024 de integer 1024.
>> Oké, dus bewegen op.
We hebben onze argv nul gedekt, we hebben behandeld argv één.
Wat zit er in argv twee?
CS50.
Die ene is waarschijnlijk vrij vanzelfsprekend.
Wat zit er in argv drie?
Weer goed, we weten niet echt, toch?
We hebben een scala van grootte van drie, dat is hoe veel elementen van de gebruiker
getypt op de opdrachtregel, dus als we naar drie argv,
we nu overschrijden de grenzen van ons aanbod.
De compiler zal laten wij dit doen, is er geen probleem met het intuïtieve,
maar in termen van eigenlijk wat er aan de hand gebeuren, weten we niet echt weten.
Het hangt af van wat er is gevestigd in geheugen waarin
argv drie zouden worden verwacht.
En dus konden we uiteindelijk krijgen weg vrijuit.
Waarschijnlijk is, vooral wanneer je werkt met argv in tegenstelling
elke andere matrix dat is in ons programma,
we waarschijnlijk gaan om te lijden een segmentation fault. Dus nogmaals,
worden zeker niet de grenzen overschrijden van arrays, met name argv,
gezien de hoge mate van belang in uw programma's.
>> Ik ben Doug Lloyd.
Dit is CS50.