Main()-functieargumenten. Opdrachtregelopties Functie Argumenten main c visual studio
Optionele en benoemde argumenten
Optionele argumenten
C# 4.0 introduceert een nieuwe functie die het gemakkelijker maakt om argumenten op te geven bij het aanroepen van een methode. Dit middel heet optionele argumenten en stelt u in staat een standaardwaarde voor een methodeparameter te definiëren. Deze waarde wordt standaard gebruikt als er geen corresponderend argument is opgegeven voor de parameter bij het aanroepen van de methode. Daarom is het niet nodig om een argument voor een dergelijke parameter op te geven. Optionele argumenten maken het gemakkelijker om methoden aan te roepen waarbij standaardargumenten op sommige parameters worden toegepast. Ze kunnen ook worden gebruikt als een "snelkoppeling" voor overbelasting van methoden.
De belangrijkste drijfveer voor het toevoegen van optionele argumenten was de noodzaak om de interactie met COM-objecten te vereenvoudigen. Verschillende Microsoft-objectmodellen (zoals Microsoft Office) bieden functionaliteit via COM-objecten, waarvan er vele lang geleden zijn geschreven en zijn ontworpen om optionele parameters te gebruiken.
Hieronder ziet u een voorbeeld van het gebruik van optionele argumenten:
Systeem gebruiken; met behulp van System.Collections.Generic; met behulp van System.Linq; met behulp van System.Text; naamruimte ConsoleApplication1 ( class Program ( // Argumenten b en c zijn optioneel bij het aanroepen van static int mySum(int a, int b = 5, int c = 10) ( return a + b + c; ) static void Main() ( int sum1 = mijnSom(3); int som2 = mijnSom(3,12); Console.WriteLine("Som1 = "+som1);
Houd er rekening mee dat alle optionele argumenten rechts van de vereiste argumenten moeten worden opgegeven. Naast methoden kunnen optionele argumenten worden gebruikt in constructors, indexers en afgevaardigden.
Een voordeel van optionele argumenten is dat ze het voor de programmeur gemakkelijker maken om complexe methode- en constructoraanroepen af te handelen. Vaak is het immers nodig om in een methode meer parameters op te geven dan normaal gesproken nodig is. En in dergelijke gevallen kunnen sommige van deze parameters optioneel worden gemaakt door zorgvuldig gebruik te maken van optionele argumenten. Dit betekent dat u alleen die argumenten hoeft door te geven die in een bepaald geval van belang zijn, en niet alle argumenten die anders nodig zouden zijn. Met deze aanpak kunt u de methode rationaliseren en de manier waarop de programmeur ermee omgaat, vereenvoudigen.
Genoemde argumenten
Een andere functie die met de release van .NET 4.0 aan C# is toegevoegd, is ondersteuning voor de zogenaamde benoemde argumenten. Zoals u weet, moet hun volgorde bij het doorgeven van argumenten aan een methode in de regel samenvallen met de volgorde waarin de parameters in de methode zelf zijn gedefinieerd. Met andere woorden: de argumentwaarde wordt aan de parameter toegewezen op basis van zijn positie in de argumentenlijst.
Genoemde argumenten zijn bedoeld om deze beperking te ondervangen. Met een benoemd argument kunt u de naam opgeven van de parameter waaraan de waarde ervan is toegewezen. En in dit geval doet de volgorde van de argumenten er niet meer toe. Benoemde argumenten lijken dus enigszins op de eerder genoemde objectinitialisatoren, hoewel ze daarvan verschillen in hun syntaxis. Om een argument op naam op te geven, gebruikt u de volgende syntaxis:
parameternaam: waarde
Hier parameternaam geeft de naam aan van de parameter waaraan de waarde wordt doorgegeven. Uiteraard moet parameternaam de naam zijn van de daadwerkelijke parameter voor de methode die wordt aangeroepen.
Borland C++ ondersteunt drie argumenten voor main(). De eerste twee zijn de traditionele argc en argv. Dit zijn de enige argumenten voor main() die zijn gedefinieerd door de ANSI C-standaard. Ze maken het mogelijk dat opdrachtregelargumenten aan het programma worden doorgegeven. Opdrachtregelargumenten zijn de informatie die volgt op de programmanaam op de opdrachtregel van het besturingssysteem. Wanneer een programma bijvoorbeeld wordt gecompileerd met behulp van de Borland-lijncompiler, wordt dit doorgaans als bcc getypt programmanaam
Waar programmanaam is een programma dat gecompileerd moet worden. De programmanaam wordt als argument aan de compiler doorgegeven.
De parameter argc bevat het aantal opdrachtregelargumenten en is een geheel getal. Deze is altijd gelijk aan minimaal 1, omdat de programmanaam als eerste argument geldt. De parameter argv is een verwijzing naar een reeks tekenaanwijzers. Elk element van deze array verwijst naar een opdrachtregelargument. Alle opdrachtregelargumenten zijn tekenreeksen. Alle getallen worden door het programma omgezet naar een intern formaat. Het volgende programma drukt "Hallo" af, gevolgd door de gebruikersnaam wanneer het direct achter de programmanaam wordt getypt:
#erbij betrekken
{
als(argc!=2)
{
printf("Je bent vergeten je naam in te typen\n");
retour 1;
}
printf("Hallo %s", argv);
retour 0;
}
Als je deze programmanaam noemt en de gebruikersnaam is Sergey, typ dan om het programma te starten:
naam Sergej.
Als resultaat van het programma verschijnt het volgende:
"Hallo Sergej."
Opdrachtregelargumenten moeten worden gescheiden door spaties of tabs. Komma's, puntkomma's en soortgelijke tekens worden niet als scheidingstekens beschouwd. Bijvoorbeeld:
Bestaat uit drie regels, terwijl
Kruid, Rick, Fred
Dit is één regel; komma's zijn geen scheidingstekens.
Als u een tekenreeks met spaties of tabs als één enkel argument wilt doorgeven, moet u deze tussen dubbele aanhalingstekens plaatsen. Dit is bijvoorbeeld een argument:
"Dit is een proef"
Het is belangrijk om argv correct te declareren. De meest typische methode is:
Lege haakjes geven aan dat de array geen vaste lengte heeft. U kunt toegang krijgen tot individuele elementen met behulp van argv-indexering. Argv verwijst bijvoorbeeld naar de eerste regel, die altijd de programmanaam bevat. argv verwijst naar de volgende regel, enzovoort.
Hieronder ziet u een klein voorbeeld van het gebruik van opdrachtregelargumenten. Het telt af vanaf de waarde die is opgegeven op de opdrachtregel en zendt een signaal uit wanneer het nul bereikt. Merk op dat het eerste argument een getal bevat dat is geconverteerd naar een geheel getal met behulp van de standaardfunctie atoi(). Als de string "display" aanwezig is als tweede argument, wordt de teller zelf op het scherm weergegeven.
/* telprogramma */
#erbij betrekken
#erbij betrekken
#erbij betrekken
int hoofd(int argc, char *argv)
{
int disp, tellen;
als(arg<2)
{
printf("Je moet de lengte van de telling invoeren\n");
printf("op de opdrachtregel. Probeer het opnieuw.\n");
retour 1;
}
if (argc==3 && !strcmp(argv,"display")) disp = 1;
anders disp = 0;
for(count=atoi(argv); count; -count)
if (disp) printf("%d ", tellen);
printf("%c", "\a"); /* op de meeste computers is dit een oproep */
retour 0;
}
Houd er rekening mee dat als er geen argumenten zijn opgegeven, er een foutmelding verschijnt. Dit is het meest typerend voor programma's die opdrachtregelargumenten gebruiken om instructies te geven als er wordt geprobeerd het programma uit te voeren zonder de juiste informatie.
Om toegang te krijgen tot individuele opdrachtregeltekens, voegt u een tweede index toe aan argv. Het volgende programma drukt bijvoorbeeld alle argumenten waarmee het is aangeroepen af, één teken tegelijk:
#erbij betrekken
int hoofd(int argc, char *argv)
{
int t, ik;
voor(t=0; t
ik = 0;
terwijl(argv[t][i])
{
printf("%c", argv[t][i]);
}
printf(" ");
}
retour 0;
}
We moeten niet vergeten dat de eerste index bedoeld is voor toegang tot een string, en de tweede voor toegang tot een teken in een string.
Normaal gesproken worden argc en argv gebruikt om bronopdrachten te verkrijgen. Het is theoretisch mogelijk om maximaal 32767 argumenten te hebben, maar bij de meeste besturingssystemen kun je daar niet eens in de buurt komen. Meestal worden deze argumenten gebruikt om een bestandsnaam of opties op te geven. Het gebruik van opdrachtregelargumenten geeft het programma een professionele uitstraling en maakt het mogelijk het programma in batchbestanden te gebruiken.
Als u het WILDARGS.OBJ-bestand opneemt dat bij Borland C++ wordt geleverd, kunt u sjablonen gebruiken in *.EXE-typeargumenten. (Borland C++ verwerkt automatisch jokertekens en verhoogt argc dienovereenkomstig.) Als u bijvoorbeeld WILDARGS.OBJ met het volgende programma verbindt, zal het u vertellen hoeveel bestanden overeenkomen met de bestandsnaam die is opgegeven op de opdrachtregel:
/* Koppel dit programma met WILDARGS.OBJ */
#erbij betrekken
int hoofd(int argc, char *argv)
{
registreer int i;
printf("%d bestanden komen overeen met de opgegeven naam\n", argc-1);
printf("Het zijn: ");
voor(i=1; ik
retour 0;
}
Als we dit programma WA noemen en het vervolgens als volgt uitvoeren, krijgen we het aantal bestanden met de EXE-extensie en een lijst met de namen van deze bestanden:
Naast argc en argv biedt Borland C++ ook een derde opdrachtregelargument -env. Met de parameter env kan een programma toegang krijgen tot informatie over de besturingssysteemomgeving. De parameter env moet volgen op argc en argv en wordt als volgt gedeclareerd:
Zoals u kunt zien, wordt env op dezelfde manier gedeclareerd als argv. Net als argv is het een verwijzing naar een array van strings. Elke regel is een omgevingsreeks die door het besturingssysteem wordt gedefinieerd. De parameter env heeft geen equivalente parameter argc die aangeeft hoeveel omgevingsrijen er zijn. In plaats daarvan is de laatste regel van de omgeving nul. Het volgende programma drukt alle omgevingsreeksen af die momenteel in het besturingssysteem zijn gedefinieerd:
/* dit programma toont alle omgevingsregels */
#erbij betrekken
int main(int argc, char *argv, char *env)
{
int t;
voor(t=0; env[t]/ t++)
printf("%s\n", env[t]);
retour 0;
}
Houd er rekening mee dat hoewel argc en argv niet door het programma worden gebruikt, ze wel aanwezig moeten zijn in de parameterlijst. C kent de parameternamen niet. In plaats daarvan wordt het gebruik ervan bepaald door de volgorde waarin de parameters worden gedeclareerd. In feite kunt u de parameter noemen hoe u maar wilt. Omdat argc, argv en env traditionele namen zijn, kun je ze het beste blijven gebruiken, zodat iedereen die het programma leest meteen kan begrijpen dat dit argumenten zijn voor de functie main().
Een typische taak voor programma's is het opzoeken van een waarde die is gedefinieerd in een omgevingsreeks. Dankzij de inhoud van de PATH-regel kunnen programma's bijvoorbeeld zoekpaden gebruiken. Het volgende programma laat zien hoe u tekenreeksen kunt vinden die standaardzoekpaden declareren. Het gebruikt de standaard bibliotheekfunctie strstr(), die het volgende prototype heeft:
Char *strstr(const char *str1, const char *str2);
De functie strstr() zoekt naar de string waarnaar str1 verwijst in de string waarnaar str2 verwijst. Als een dergelijke string wordt gevonden, wordt een verwijzing naar de eerste positie geretourneerd. Als er geen overeenkomsten worden gevonden, retourneert de functie NULL.
/* het programma zoekt in de omgevingsstrings naar een regel met PATH */
#erbij betrekken
#erbij betrekken
int main (int argc, char *argv, char *env)
{
int t;
voor(t=0; env[t]; t++)
{
if(strstr(env[t], "PAD"))
printf("%s\n", env[t]);
}
retour 0;
}
Tags: Opdrachtregelopties
Opdrachtregelopties
C is een gecompileerde taal. Na de montage is het programma een uitvoerbaar bestand (we houden geen rekening met het maken van dynamische bibliotheken, stuurprogramma's, enz.). Onze programma's zijn heel eenvoudig en bevatten geen Runtime-bibliotheken, zodat ze naar een computer met hetzelfde besturingssysteem (en vergelijkbare architectuur) kunnen worden overgebracht en daar kunnen worden uitgevoerd.
Het programma kan tijdens het opstarten parameters accepteren. Het zijn argumenten voor de hoofdfunctie. Het algemene beeld van de hoofdfunctie is als volgt
Leeg hoofd(int argc, char **argv) ( ... )
Het eerste argument van argc is het aantal parameters dat aan de functie wordt doorgegeven. Het tweede argument is een array van strings: de parameters zelf. Omdat de parameters van een functie van alles kunnen zijn, worden ze doorgegeven als strings, en het programma zelf moet ze parseren en converteren naar het gewenste type.
Het eerste argument (argv) is altijd de programmanaam. In dit geval wordt de naam weergegeven, afhankelijk van waar het programma is gestart.
#erbij betrekken
Laten we nu eens leren hoe we een beetje met de opdrachtregel kunnen werken. Dit is nodig om argumenten aan ons programma door te geven. De Win+R-toetscombinatie brengt het venster Uitvoeren naar voren. Typ cmd erin en je opent de opdrachtregel. U kunt cmd.exe ook vinden door te zoeken in het Start-menu. In Unix-achtige besturingssystemen kunt u het terminalprogramma oproepen.
We zullen niet te veel commando's leren. Alleen degenen die nodig zijn voor het werk.
Het cd-commando, standaard voor alle besturingssystemen, navigeert naar de gewenste map. Er zijn twee gereserveerde namen - . (punt) en.. (twee punten). De punt is de naam van de huidige map.
Gaat nergens heen
Toegang tot de bovenliggende map
Ga naar de bovenliggende map
Om naar de gewenste te gaan, schrijft u het cd-adres. U moet bijvoorbeeld naar Windows gaan naar de map C:\Windows\System32
Cd C:\Windows\System32
Als je in Linux naar de map /var/mysql moet gaan
Cd /var/mysql
Als het pad spaties bevat, wordt dit tussen dubbele aanhalingstekens geschreven
Cd "D:\Docuents and Settings\Prolog"
De terminal heeft de volgende handige functies: als u op het pijltje omhoog drukt, verschijnt het eerder uitgevoerde commando. Als u op Tab drukt, zal de terminal proberen de regel te voltooien met een bekende opdracht, of het pad te voltooien, waarbij alle mappen en bestanden in de huidige map worden doorlopen.
Typ cd C:\
druk op tab en kijk wat er gebeurt.
Een ander belangrijk commando, dir op Windows en ls op Linux, geeft de inhoud van de huidige map (de map waarin je je momenteel bevindt) weer op de console.
Uw programma heeft de volledige naam teruggegeven. Ga naar de map waarin uw programma zich bevindt en bekijk de inhoud ervan
Nu we naar onze map zijn genavigeerd, kunnen we ons programma uitvoeren. Om dit te doen, typt u haar naam.
Let op: de naam is veranderd. Omdat het programma vanuit zijn eigen map wordt aangeroepen, wordt de relatieve naam weergegeven. Laten we nu het programma wijzigen en alle argumenten laten afdrukken. die haar werden gegeven.
#erbij betrekken
Monteer het project. Zorg ervoor dat het programma is afgesloten voordat u met de montage begint. Roep nu het programma aan en geef het verschillende argumenten door. Om dit te doen, schrijft u de naam van het programma en de argumenten gescheiden door een spatie
Laten we nu een programma schrijven dat twee getalargumenten nodig heeft en hun som afdrukt
#erbij betrekken
Laten we verzamelen en bellen
Dit is hoe de meeste programma's werken. Door op een snelkoppeling te klikken, roept u het programma op waarnaar deze verwijst. De meeste programma's accepteren ook verschillende argumenten. U kunt bijvoorbeeld de Firefox-browser vanaf de opdrachtregel oproepen en de argumenten doorgeven
firefox.exe "www.mozilla.org" "site" en de sites op de opgegeven adressen worden onmiddellijk geopend in twee tabbladen.
Veel standaardopdrachten hebben ook parameters. In Windows is het gebruikelijk dat ze beginnen met een schuine streep, in Unix met een min of twee minnen. Bijvoorbeeld
Toont alleen mappen, maar in de Linux-terminal
Ls -l toont alle bestanden en mappen met attributen
Als u aanvullende Windows-opdrachten wilt bekijken, typt u help op de opdrachtregel of raadpleegt u de handleiding (deze is gemakkelijk te vinden op internet). Voor Linux zijn er veel meer opdrachten en hun opties, en sommige daarvan zijn onafhankelijke programmeertalen, dus het is de moeite waard om op zijn minst de minimale set en hun opties te leren.
Wanneer u automatisch een consoletoepassing in de programmeertaal C++ maakt, wordt automatisch een hoofdfunctie gemaakt die hier sterk op lijkt:
int hoofd(int argc, char * argv)
{…}
De functieheader bevat de handtekening van de hoofdfunctie main() met de argumenten argс en argv.
Als u een programma via de opdrachtregel uitvoert, is het mogelijk om bepaalde informatie naar dit programma over te brengen. Hiervoor zijn opdrachtregelargumenten argc en argv.
De parameter argc is van het type int en bevat het aantal parameters dat aan de hoofdfunctie wordt doorgegeven. Bovendien is argc altijd minimaal 1, zelfs als er geen informatie wordt doorgegeven aan de hoofdfunctie, aangezien de eerste parameter de applicatienaam is.
De parameter argv is een array van verwijzingen naar tekenreeksen. Alleen stringgegevens kunnen via de opdrachtregel worden doorgegeven.
Wanneer u een programma via de Windows-opdrachtregel uitvoert, kunt u er bepaalde informatie aan doorgeven. In dit geval ziet de opdrachtregel er als volgt uit:
Station:\pad\naam.exe argument1 argument2 ...
Opdrachtregelargumenten worden gescheiden door een of meer spaties.
Het argv-argument bevat de volledige applicatienaam:
#erbij betrekken
naamruimte std gebruiken;
uit<< argv << endl;
Retour 0;
}
Uitvoering resultaat
Voorbeeld: Berekening van het product van twee gehele getallen
Het programma gebruikt de functie om vanaf hier een string naar een geheel getal StrToInt() te converteren.
#erbij betrekken
naamruimte std gebruiken;
int StrToInt(char *s) (…)
int main(int argc, char * argv) (
Inta = 0, b=0;
Als (argc > 1)
a = StrToInt(argv);
Als (argc > 2)
b = StrToInt(argv);
uit<< a <<«*» << b << «= « << a*b << endl;
Retour 0;
}
Het programma wordt als volgt gelanceerd:
Uitvoering resultaat
Debuggen van een programma met opdrachtregelargumenten
Om opdrachtregelargumenten door te geven bij het debuggen van een programma, moet u het menu openen Eigenschappen project. 
Op het tabblad Configuratie-eigenschappen -> Foutopsporing kiezen Commando-argumenten en hun waarden instellen. 
Wanneer het programma in de debug-modus wordt uitgevoerd, worden de ingevoerde argumenten door het programma behandeld als opdrachtregelargumenten.
Soms is het handig om bij het starten van een programma wat informatie door te geven. Normaal gesproken wordt deze informatie doorgegeven aan main() via opdrachtregelargumenten. Opdrachtregelargument- Dit is de informatie die wordt ingevoerd op de opdrachtregel van het besturingssysteem na de programmanaam. Om bijvoorbeeld te beginnen met het compileren van een programma, typt u op de opdrachtregel na de prompt zoiets als het volgende:
CC programmanaam
programmanaam is een opdrachtregelargument; het specificeert de naam van het programma dat u gaat compileren.
Om opdrachtregelargumenten te accepteren, worden twee speciale ingebouwde argumenten gebruikt: argc en argv. De parameter argc bevat het aantal argumenten op de opdrachtregel en is een geheel getal, en is altijd minimaal 1 omdat het eerste argument de naam van het programma is. En de parameter argv is een verwijzing naar een array van verwijzingen naar tekenreeksen. In deze array verwijst elk element naar een opdrachtregelargument. Alle opdrachtregelargumenten zijn tekenreeksen, dus de conversie van getallen naar het gewenste binaire formaat moet in het programma worden voorzien wanneer het wordt ontwikkeld.
Hier is een eenvoudig voorbeeld van het gebruik van een opdrachtregelargument. Het woord Hallo en uw naam worden op het scherm weergegeven, wat moet worden opgegeven als opdrachtregelargument.
#erbij betrekken
Als je deze programmanaam (naam) hebt genoemd en je naam is Tom, dan moet je om het programma uit te voeren de naam Tom invoeren op de opdrachtregel. Als gevolg van het uitvoeren van het programma verschijnt de melding Hallo, Tom op het scherm.
In veel omgevingen moeten alle opdrachtregelargumenten worden gescheiden door een spatie of tab. Komma's, puntkomma's en soortgelijke tekens worden niet als scheidingstekens beschouwd. Bijvoorbeeld,
Ren Spot, ren
bestaat uit drie tekenreeksen, while
Erik, Rik, Fred
vertegenwoordigt een enkele tekenreeks - komma's worden in de regel niet als scheidingstekens beschouwd.
Als een tekenreeks spaties bevat, kunt u in sommige omgevingen de tekenreeks tussen dubbele aanhalingstekens plaatsen om te voorkomen dat deze meerdere argumenten produceert. Als gevolg hiervan wordt de hele tekenreeks als één argument beschouwd. Raadpleeg de documentatie van uw besturingssysteem voor meer informatie over hoe uw besturingssysteem opdrachtregelparameters specificeert.
Het is erg belangrijk om argv correct te declareren. Zo wordt het het vaakst gedaan:
Char *argv;
Lege vierkante haken geven aan dat de array een onbepaalde lengte heeft. Individuele argumenten zijn nu toegankelijk door de argv-array te indexeren. argv verwijst bijvoorbeeld naar de eerste tekenreeks, wat altijd de programmanaam is; argv verwijst naar het eerste argument, enzovoort.
Een ander klein voorbeeld van het gebruik van opdrachtregelargumenten is het volgende programma, countdown. Dit programma telt achteruit, beginnend vanaf een bepaalde waarde (opgegeven op de opdrachtregel), en piept wanneer het 0 bereikt. Merk op dat het eerste argument, dat de startwaarde bevat, wordt geconverteerd naar een geheel getal met behulp van de standaard atoi-functie (). Als het tweede opdrachtregelargument (en als we de programmanaam als een argument beschouwen, dan het derde) de regel "display" (display) is, wordt het resultaat van de telling (in omgekeerde volgorde) op het scherm weergegeven.
/* Programma voor tellen in omgekeerde volgorde. */ #erbij betrekken
Houd er rekening mee dat als er geen opdrachtregelargumenten zijn opgegeven, er een foutmelding wordt weergegeven. Programma's die opdrachtregelargumenten gebruiken, doen vaak het volgende: Wanneer de gebruiker deze programma's uitvoert zonder de vereiste informatie in te voeren, geven ze instructies weer over hoe u de argumenten correct kunt opgeven.
Om toegang te krijgen tot een individueel teken van een van de opdrachtregelargumenten, voert u een tweede index in argv in. Het volgende programma drukt bijvoorbeeld teken voor teken alle argumenten af waarmee het werd aangeroepen:
#erbij betrekken Onthoud dat de eerste index van argv toegang geeft tot de string, en de tweede index toegang geeft tot de individuele karakters ervan. Meestal worden argc en argv gebruikt om het programma de initiële opdrachten te geven die het nodig heeft bij het opstarten. Opdrachtregelargumenten specificeren bijvoorbeeld vaak informatie zoals een bestandsnaam, een optie of een alternatief gedrag. Het gebruik van opdrachtregelargumenten geeft uw programma een "professionele uitstraling" en maakt het gemakkelijker te gebruiken in batchbestanden. De namen argc en argv zijn traditioneel, maar niet verplicht. Je kunt deze twee parameters in de functie main() aanroepen wat je maar wilt. Bovendien ondersteunen sommige compilers mogelijk aanvullende argumenten voor main(), dus zorg ervoor dat u de documentatie van uw compiler raadpleegt. Wanneer een programma geen opdrachtregelparameters vereist, is het gebruikelijk om expliciet aan te geven dat de functie main() geen parameters heeft. In dit geval wordt het trefwoord void gebruikt in de parameterlijst van deze functie.
