Hallo, en welkom terug.
In deze lezing wil ik praten over opdrachtregelargumenten.
De reden dat ik dit heb opgenomen informatie
in de sectie variabelen en gegevenstypen is omdat: opdrachtregelargumenten zijn een manier om gegevens door
te geven aan uw programma.
Dus het is een soort van voorbijgaan een variabele in uw programma.
En het is erg handig en je doet het vaak, dus ik wilde
dit heel snel behandelen.
Dus opdrachtregelargumenten.
Kortom, er zijn momenten waarop a programma is ontwikkeld waarvoor de gebruiker
een klein bedrag moet invoeren informatie op de terminal.
Dus net zoals dit impliceert, opdrachtregelargumenten zijn
in wezen programmaargumenten.
Zo kun je slagen gegevens naar een programma.
Dus wanneer u een gebruiker of een programma heeft gegevens nodig, die dynamisch zijn, die door de gebruiker worden
ingevoerd, er zijn een aantal verschillende manieren waarop u deze
gegevens kunt doorgeven.
Je kunt de gebruiker erom vragen of je kunt het doorgeven als een programma.
En de reden waarom je zou willen doen? dit komt
omdat u de gebruiker mogelijk opnieuw een nummer moet laten invoeren dat geeft het driehoeksgetal aan dat u
wilt laten berekenen of de gebruiker moet een woord invoeren dat u in een
woordenboek wilt opzoeken.
Niet alle gegevens zijn statisch of verandert niet.
Sommige gegevens moet u vraag de gebruiker om in te voeren.
En zoals ik al zei, je zou kunnen doe dit op twee manieren.
U kunt de gegevens opvragen bij: de gebruiker en daar gaan we
het in de komende colleges over hebben of jij kan leveren de informatie het programma op het
moment dat het programma wordt uitgevoerd.
En dit is wat wordt bedoeld als opdrachtregelargumenten.
Gegevens doorgeven aan uw programma via de opdrachtregel wanneer het programma wordt uitgevoerd.
En dus weten we al dat elke c programma heeft een hoofdfunctie.
Dit is een speciale functie het is eigenlijk het startpunt
van het programma.
Het is ook bijzonder omdat het kan gebruikt om opdrachtregelargumenten op te halen.
Dus wanneer de belangrijkste wordt aangeroepen door de
runtime-systemen, worden hier feitelijk twee argumenten aan doorgegeven functie, opdrachtregelargumenten.
De twee argumenten zijn de eerste een daarvan is het aantal argumenten.
Hoeveel gegevens worden er? doorgegeven aan het programma.
Het is een geheel getal.
Het specificeert het aantal argumenten getypt op de opdrachtregel.
Het tweede argument dat wordt weergegeven door arg v voor
argument vector is an reeks karakteraanwijzers.
Nu vraag je je misschien af wat is een array.
We weten nog niet wat een array is.
Maar nogmaals, het is belangrijk om begrijpen hoe u
opdrachtregelargumenten kunt doorgeven.
Je kunt een array gewoon zien als: veel verschillende variabelen voor nu.
Dus eerste argument arg c voor het argument, telling
tweede argument is een vector.
Onthoud, argumenten zijn hoe je kan gegevens doorgeven aan een functie.
Dat is alles. Het is echt niet eens dat dat ingewikkeld
is, dus de belangrijkste functie kun je geef de hoofdfunctie enkele gegevens door.
Wanneer u het programma uitvoert, dat gegevens kunnen worden opgegeven wanneer u het programma
vanaf de opdrachtregel uitvoert.
Dus onthoud, wanneer u een programma uitvoert ofwel dubbelklik erop als het een uitvoerbaar bestand is
of als je bezig bent met Linux of Windows u voert het uit door
een dot slash a dot out te doen.
Nou, als je dat doet je kunt echt dingen
doorgeven na het programma.
Dus je zou kunnen zeggen programma. exe en plaats
daarna parameters, daarna gegevens.
En ik ga het laten zien je hoe je dat moet doen.
Dus alweer de eerste vermelding in de array is een pointer
de naam van het programma dat wordt uitgevoerd en dan alles daarna zouden de argumenten zijn
en ik zal dit aantonen.
Dus hier is een voorbeeld dit is
de hoofdfunctie en het heeft eigenlijk twee argumenten of twee parameters.
We zullen het hebben over de verschil tussen
parameters en argumenten ook.
Maar zie je, er staat int argsie en dan char en
er is een sterretje arg v.
Nogmaals, maak je daar geen zorgen over eigenlijk zou
alles na de komma enkele gegevens zijn die je gaat naar het programma.
En de arg c zou zijn het nummer van de gegevens.
Dus laten we een voorbeeld doornemen dat is de beste manier om dit te leren.
Dus hier is ons voorbeeld.
Als we gegevens willen doorgeven aan onze programma via de opdrachtregel, we moeten
parameters in onze main hebben.
Tot nu toe heeft main net leeg geweest met twee lege haakjes.
Dus het eerste wat we moeten doen doen is gewoon arg c zeggen.
Het kan eigenlijk elke naam zijn, behalve arg c staat voor het aantal argumenten.
En dan char star arg v.
En nogmaals, maak je geen zorgen over deze syntaxis voor nu.
Maar die twee moeten we wel eerst toevoegen.
En dus ga ik er wat maken variabelen hier die aantonen dat
gegevens worden doorgegeven en.
Dus omdat de gegevens worden doorgegeven, Ik moet het ergens opbergen.
Dus ik ga een maken variabele van het type int
alleen dat is het aantal argumenten.
En dit gaat gelijk zijn aan arg c.
Arg c is gewoon de variabele dat is doorgegeven, en ik zal
u laten zien wat dit voorstelt.
Ik ga er nog een maken
variabele die alleen ons argument vertegenwoordigt en dit gaat gelijk zijn aan arg v nul.
Nogmaals, maak je geen zorgen over de arg v nul syntaxis.
Wat doet deze regel code? regel 13 is het is het
instellen van argument 1 variabele gelijk aan de programmanaam.
En als we er dan nog een doen, we zeggen karakter ster argument twee en
we gaan set die gelijk is aan arg v sub 1.
En dan gaan we gewoon om deze gegevens af te drukken.
Dus we gaan zeggen print out aantal argumenten en
we willen de waardevariabele afdrukken, dus we moet dit formaat specificeren.
We gaan procent d zeggen.
En dan na de komma, we gaan het aantal argumenten noemen,
want dit is een variabele die we willen weergeven.
En dan hebben we er nog een print statement
dat argument 1 gaat afdrukken.
En dit gaat de programmanaam vertegenwoordigen.
En nogmaals, we hebben een procentteken dus we gaan procent s zeggen
omdat dit weer een string is, niet belangrijk om op dit punt te begrijpen.
Vaak, als je demonstreert, codevoorbeelden, wilt u de waarde van
variabelen afdrukken.
En dus deze printf-statements op 16 en 17 drukken de waarde af van
de variabelen die worden doorgegeven aan main, dat zijn opdrachtregelargumenten, daarom
geef ik het weer.
En dan de laatste die ik wil
display is ons tweede argument, en dit is het commandoregelargument, naast de programmanaam.
Dit zou argument 2 zijn die we gaan vertonen.
En dan gaan we 0 teruggeven.
Het is dus een heel eenvoudig programma in termen van het
heeft niet veel functionaliteit.
Het krijgt eigenlijk gewoon gegevens van de functie die is doorgegeven en
geeft die gegevens weer.
Dus toen ik zei dat je het kunt gegevens doorgeven aan een programma.
Nogmaals, onthoud dat wanneer je om dit programma uit te voeren, dubbelklikken
we gewoon op een menu-optie.
Maar wat er echt aan de hand is, is dat je... een
opdracht uitvoeren, ofwel dubbelklikken of exe of in linux uitvoeren of unix je doet een punt uit.
En dus wanneer u het programma uitvoert, u kunt er daadwerkelijk gegevens aan doorgeven.
Dus aangezien we niet echt uitvoeren het commando, we doen het menu, we moeten
de gegevens doorgeven via de geïntegreerde ontwikkelomgeving.
En gelukkig heeft codeblokken een leuke manier om dat te doen.
Gegevens doorgeven als een opdrachtregel argument aan een programma, alles wat
je hoeft te doen is naar je project te gaan, markeer het, ga naar de
menu-optie die zegt project en dan ga naar programmaargumenten instellen.
En zie hier, een raam zal pop-up en hier kun je eigenlijk
gewoon je argumenten zeggen.
En je kunt invoeren als zoveel als je wilt hier.
Laten we beginnen.
Ik ga gewoon mijn naam Jason afdrukken.
Ik ga dat argument doorgeven die gegevens in mijn programma wanneer het
programma wordt uitgevoerd.
En ik ga zeggen oké.
Dus ik ga vooruit en stel deze samen.
En als ik het run, wat doe ik dan? je denkt dat de waarde van
het aantal argumenten zal zijn.
Nou, onthoud dat er een is argument dat is doorgegeven, dat
is de naam van het programma en dan ben ik Jason passeren, dus dit
moet gelijk zijn aan 2, het getal 2.
Argument 1 wordt de programmanaam, dus dit zou de programmanaam moeten zijn,
wat ik ook heb genoemd het en ik kan me niet herinneren of dit een
test zal genereren of niet.
Dan zou argument 2 Jason moeten zijn want dat is wat ik doorgeef.
Dus als ik het nu run, laten we eens kijken wat gebeurt, zeggen we uitvoeren, je zult zien dat
het aantal argumenten twee is.
Argument één is de programmanaam en het is erg moeilijk om het formaat te lezen omdat
er geen nieuwe regels zijn.
Dus laten we dit opnieuw beginnen en voeg eigenlijk wat nieuwe regels toe.
Hoe kunnen we nieuwe toevoegen? lijnen die moeten worden afgedrukt.
We kunnen wel een ontsnapping gebruiken reeks, die een backslash n is.
Dus laten we een backslash n . toevoegen na het
percentage d voor de eerste afdrukopdracht en a backslash n na de volgende.
Het is dus beter leesbaar als uitvoer.
En laten we dat nu opslaan, laten we bouw het opnieuw en laten we het uitvoeren en kijken wat
de output deze keer is.
Hopelijk is het dan makkelijker te lezen.
Als we het nu uitvoeren, zul je zie dat er
aparte regels zijn, veel gemakkelijker te lezen.
Aantal argumenten wordt weergegeven als twee omdat, zoals ik al zei, het eerste
argument de programmanaam is de tweede argument is wat ik heb doorgegeven.
En argument 1 wordt daadwerkelijk weergegeven als de naam van het programma, wat mijn hele
map is opbouwen en dan testen. exe.
En argument 2 is Jason omdat dat is wat ik in de ID heb ingesteld.
Nu kan ik gaan en ik kan
wijzigen de programmaargumenten door naar de projectmenu-optie te gaan en zeggen project ga naar programmaargumenten instellen en ik kan
dit veranderen.
Als ik dit nu verander, als ik verander het in iets anders of ik zeg
gewoon iets.
Als ik het nu uitvoer, worden de gegevens dat wordt doorgegeven aan
het programma gaat iets worden anders, het gaat worden en eigenlijk hoef je alleen maar te
rennen het hoeft u niet opnieuw te compileren.
Nu is het gewoon iets dat wordt weergegeven.
En dus is dit een manier waarop je kunt gegevens doorgeven aan een programma zonder er
specifiek om te vragen van de gebruiker.
Je typt het gewoon in de IDE en geef het door aan het programma.
En je kunt veel argumenten aandragen.
Die hoef je niet zomaar te passeren.
Als je meer zou willen doorgeven, zou je dat doen
ga gewoon opnieuw naar het instellen van programmaargumenten en gescheiden door nieuwe regels, natuurlijk, als je ze wilt gebruiken, moet je ze openen in
de array, maar je kunt er veel doorgeven.
Dit is dus handig om gegevens door te geven aan: een programma zonder de gebruiker te vragen iets op
het toetsenbord te typen.
Als je het niet op deze manier hebt gedaan, programma zou pauzeren en het zou
zeggen hey gebruiker, voer alstublieft iets in.
En dan zou de gebruiker invoeren iets en dan zou
je het in een variabele moeten opslaan en dan je moet doorgaan met uitvoeren.
Zo hoef je het niet te vragen de gebruiker voor alles wat je
gewoon doorgeeft als onderdeel van het programma.
Dus dit is het commando lijnargumenten zijn.
Maak je geen zorgen over deze andere concepten zoals arrays, zie je de asterisk voor pointers,
maak je daar geen zorgen over.
Nogmaals, dit wordt alleen weergegeven de opdrachtregelargumenten.
En de manier waarop u toegang krijgt ze zijn
via deze parameters in de functie.
Maar nogmaals, het belangrijkste punt is: dit is hoe je het kunt doen.
En het is handig dat het zal zijn nuttig voor andere programma's
en wordt geassocieerd met variabelen.
Dank u.