Borland C++ podporuje tři argumenty pro main(). První dva jsou tradiční argc a argv. Toto jsou jediné argumenty pro main() definované standardem ANSI C. Umožňují předání argumentů příkazového řádku programu. Argumenty příkazového řádku jsou informace následující za názvem programu příkazový řádek operační systém. Když je například program kompilován pomocí řádkového kompilátoru Borland, je obvykle zadán bcc název_programu
Kde název_programu je program, který je potřeba zkompilovat. Název programu je předán kompilátoru jako argument.
Parametr argc obsahuje počet argumentů příkazového řádku a je to celé číslo. Vždy se rovná alespoň 1, protože název programu se kvalifikuje jako první argument. Parametr argv je ukazatel na pole ukazatelů znaků. Každý prvek tohoto pole ukazuje na argument příkazového řádku. Všechny argumenty příkazového řádku jsou řetězce. Všechna čísla jsou převedena programem do interního formátu. Další program vypíše "Ahoj" následované uživatelským jménem, pokud je napsáno přímo za názvem programu:
#zahrnout
{
if(argc!=2)
{
printf("Zapomněli jste napsat své jméno\n");
návrat 1;
}
printf("Ahoj %s", argv);
návrat 0;
}
Pokud zavoláte tento program jméno a uživatelské jméno je Sergey, poté pro spuštění programu zadejte:
jméno Sergey.
V důsledku programu se objeví následující:
"Ahoj Sergey."
Argumenty příkazového řádku musí být odděleny mezerami nebo tabulátory. Čárky, středníky a podobné znaky se nepovažují za oddělovače. Například:
Skládá se ze tří řádků, zatímco
Herb, Rick, Fred
Toto je jeden řádek – čárky nejsou oddělovače.
Pokud potřebujete předat řetězec obsahující mezery nebo tabulátory jako jeden argument, musíte jej uzavřít do dvojitých uvozovek. Například toto je jeden argument:
"tohle je zkouška"
Je důležité správně deklarovat argv. Nejtypičtější metodou je:
Prázdné závorky označují, že pole nemá pevnou délku. K jednotlivým prvkům můžete přistupovat pomocí indexování argv. Například argv ukazuje na první řádek, který vždy obsahuje název programu. argv ukazuje na další řádek a tak dále.
Níže je malý příklad použití argumentů příkazového řádku. Odpočítává od hodnoty zadané na příkazovém řádku a vyšle signál, když dosáhne nuly. Všimněte si, že první argument obsahuje číslo převedené na celé číslo pomocí standardní funkce atoi(). Pokud je jako druhý argument přítomen řetězec "display", pak se na obrazovce zobrazí samotné počítadlo.
/* program na počítání */
#zahrnout
#zahrnout
#zahrnout
int main(int argc, char *argv)
{
int disp, počet;
if(argc<2)
{
printf("Musíte zadat délku počítání\n");
printf("na příkazovém řádku. Zkuste to znovu.\n");
návrat 1;
}
if (argc==3 && !strcmp(argv,"zobrazit")) disp = 1;
jinak disp = 0;
for(count=atoi(argv); count; -count)
if (disp) printf("%d ", pocet);
printf("%c", "\a"); /* na většině počítačů se jedná o volání */
návrat 0;
}
Upozorňujeme, že pokud nejsou zadány žádné argumenty, zobrazí se chybová zpráva. To je nejtypičtější pro programy, které používají argumenty příkazového řádku k vydávání pokynů, pokud byl proveden pokus o spuštění programu bez správných informací.
Chcete-li získat přístup k jednotlivým znakům příkazového řádku, přidejte do argv druhý index. Například následující program vytiskne všechny argumenty, se kterými byl volán, jeden znak po druhém:
#zahrnout
int main(int argc, char *argv)
{
int t, i;
for(t=0; t
i = 0;
while(argv[t][i])
{
printf("%c", argv[t][i]);
}
printf(" ");
}
návrat 0;
}
Musíme si pamatovat, že první index je pro přístup k řetězci a druhý je pro přístup ke znaku v řetězci.
K získání zdrojových příkazů se obvykle používají argc a argv. Teoreticky je možné mít až 32767 argumentů, ale většina operačních systémů vám ani nedovolí se k tomu přiblížit. Tyto argumenty se obvykle používají k určení názvu souboru nebo voleb. Použití argumentů příkazového řádku dodává programu profesionální vzhled a umožňuje použití programu v dávkových souborech.
Pokud zahrnete soubor WILDARGS.OBJ dodávaný s Borland C++, můžete použít šablony v argumentech typu *.EXE. (Borland C++ automaticky zpracovává zástupné znaky a příslušně zvyšuje argc.) Pokud například připojíte WILDARGS.OBJ k následujícímu programu, řekne vám, kolik souborů odpovídá názvu souboru zadanému na příkazovém řádku:
/* Propojit tento program s WILDARGS.OBJ */
#zahrnout
int main(int argc, char *argv)
{
zaregistrovat int i;
printf("%d souborů odpovídá zadanému názvu\n", argc-1);
printf("Jsou to: ");
for(i=1; i
návrat 0;
}
Pokud tento program nazveme WA, pak jej spustíme následovně, získáme počet souborů s příponou EXE a seznam názvů těchto souborů:
Kromě argc a argv nabízí Borland C++ také třetí argument příkazového řádku -env. Parametr env umožňuje programu přístup k informacím o prostředí operačního systému. Parametr env musí následovat po argc a argv a je deklarován následovně:
Jak vidíte, env je deklarováno stejným způsobem jako argv. Stejně jako argv je to ukazatel na pole řetězců. Každý řádek je řetězec prostředí definovaný operačním systémem. Parametr env nemá žádný ekvivalentní parametr argc, který říká, kolik řádků prostředí existuje. Místo toho je poslední řádek prostředí null. Následující program vytiskne všechny řetězce prostředí aktuálně definované v operačním systému:
/* tento program zobrazí všechny řádky prostředí */
#zahrnout
int main(int argc, char *argv, char *env)
{
int t;
for(t=0; env[t]/ t++)
printf("%s\n", env[t]);
návrat 0;
}
Vezměte prosím na vědomí, že ačkoli argc a argv program nepoužívá, musí být přítomny v seznamu parametrů. C nezná názvy parametrů. Místo toho je jejich použití určeno pořadím, ve kterém jsou parametry deklarovány. Ve skutečnosti můžete parametr nazvat, jak chcete. Vzhledem k tomu, že argc, argv a env jsou tradiční názvy, je nejlepší je nadále používat, aby každý, kdo čte program, okamžitě pochopil, že se jedná o argumenty funkce main().
Typickým úkolem programů je vyhledat hodnotu definovanou v řetězci prostředí. Například obsah řádku PATH umožňuje programům používat vyhledávací cesty. Následující program ukazuje, jak najít řetězce, které deklarují standardní vyhledávací cesty. Používá standardní knihovní funkci strstr(), která má následující prototyp:
Char *strstr(const char *str1, const char *str2);
Funkce strstr() hledá řetězec, na který ukazuje str1, v řetězci, na který ukazuje str2. Pokud je takový řetězec nalezen, vrátí se ukazatel na první pozici. Pokud nejsou nalezeny žádné shody, funkce vrátí hodnotu NULL.
/* program hledá mezi řetězci prostředí řádek obsahující PATH */
#zahrnout
#zahrnout
int main (int argc, char *argv, char *env)
{
int t;
for(t=0; env[t]; t++)
{
if(strstr(env[t], "PATH"))
printf("%s\n", env[t]);
}
návrat 0;
}
Nepovinné a pojmenované argumenty
Nepovinné argumenty
C# 4.0 zavádí novou funkci, která usnadňuje specifikaci argumentů při volání metody. Tento lék se nazývá volitelné argumenty a umožňuje definovat výchozí hodnotu pro parametr metody. Tato hodnota se použije ve výchozím nastavení, pokud není pro parametr při volání metody zadán odpovídající argument. Proto není nutné uvádět argument pro takový parametr. Volitelné argumenty usnadňují volání metod, kde jsou na některé parametry aplikovány výchozí argumenty. Mohou být také použity jako "zkratková" forma přetížení metody.
Hlavním impulsem pro přidání volitelných argumentů byla potřeba zjednodušit interakci s objekty COM. Několik objektových modelů společnosti Microsoft (například Microsoft Office) poskytuje funkce prostřednictvím objektů COM, z nichž mnohé byly napsány před dlouhou dobou a jsou navrženy tak, aby přebíraly volitelné parametry.
Příklad použití volitelných argumentů je uveden níže:
Použití systému; pomocí System.Collections.Generic; pomocí System.Linq; pomocí System.Text; jmenný prostor ConsoleApplication1 ( třída Program ( // Argumenty b a c jsou volitelné při volání static int mySum(int a, int b = 5, int c = 10) ( return a + b + c; ) static void Main() ( int sum1 = mySum(3); int sum2 = mySum(3,12); Console.WriteLine("Sum1 = "+sum1); Console.WriteLine("Sum2 = "+sum2); Console.ReadLine(); ) ) )
Je třeba mít na paměti, že všechny volitelné argumenty musí být uvedeny vpravo od požadovaných. Kromě metod lze v konstruktorech, indexerech a delegátech použít volitelné argumenty.
Jednou z výhod volitelných argumentů je, že usnadňují programátorovi zpracovávat komplexní volání metod a konstruktorů. Koneckonců, je často nutné zadat více parametrů v metodě, než je obvykle požadováno. A v takových případech mohou být některé z těchto parametrů volitelné díky pečlivému použití volitelných argumentů. To znamená, že musíte předat pouze ty argumenty, které jsou v daném případě důležité, a ne všechny argumenty, které by jinak byly vyžadovány. Tento přístup vám umožňuje racionalizovat metodu a zjednodušit programátorovi manipulaci s ní.
Pojmenované argumenty
Další funkcí, která byla do C# přidána s vydáním .NET 4.0, je podpora tzv pojmenované argumenty. Jak víte, při předávání argumentů metodě se jejich pořadí zpravidla musí shodovat s pořadím, ve kterém jsou parametry definovány v samotné metodě. Jinými slovy, hodnota argumentu je přiřazena parametru na základě jeho pozice v seznamu argumentů.
Pojmenované argumenty jsou navrženy tak, aby toto omezení překonaly. Pojmenovaný argument umožňuje zadat název parametru, kterému je přiřazena jeho hodnota. A v tomto případě už na pořadí argumentů nezáleží. Pojmenované argumenty jsou tedy poněkud podobné dříve zmíněným inicializátorům objektů, i když se od nich liší svou syntaxí. Chcete-li zadat argument podle názvu, použijte následující formu syntaxe:
název_parametru: hodnota
Tady název_parametru označuje název parametru, kterému je hodnota předána. Název_parametru musí být samozřejmě názvem skutečného parametru pro volanou metodu.
Některé argumenty můžete předat programům C. Když je main() volána na začátku výpočtu, jsou předány tři parametry. První z nich určuje počet argumentů příkazu při přístupu k programu. Druhým je pole ukazatelů na znakové řetězce obsahující tyto argumenty (jeden argument na řádek). Třetí je také pole ukazatelů na znakové řetězce, slouží k přístupu k parametrům operačního systému (proměnným prostředí).
Každý takový řádek je reprezentován jako:
proměnná = hodnota\0
Poslední řádek lze nalézt podle dvou koncových nul.
Pojmenujme argumenty funkce main() podle toho: argc, argv a env (jakákoli jiná jména jsou možná). Potom jsou přijatelné následující popisy:
main(int argc, char *argv)
main(int argc, char *argv, char *env)
Předpokládejme, že na jednotce A: je nějaký program prog.exe. Řešíme to následovně:
A:\>prog.exe soubor1 soubor2 soubor3
Potom argv je ukazatel na řádek A:\prog.exe, argv je ukazatel na řádek soubor1 atd. Na první aktuální argument ukazuje argv a na poslední argv. Pokud argc=1, pak za názvem programu na příkazovém řádku nejsou žádné parametry. V našem příkladu argc=4.
Rekurze
Rekurze je metoda volání, ve které funkce odkazuje sama na sebe.
Důležitým bodem při sestavování rekurzivního programu je organizace výstupu. Zde je snadná chyba, že se funkce bude postupně volat sama sebe donekonečna. Proto musí rekurzivní proces krok za krokem problém zjednodušit tak, aby se pro něj nakonec objevilo nerekurzivní řešení. Použití rekurze není vždy žádoucí, protože může vést k přetečení zásobníku.
Knihovní funkce
V programovacích systémech jsou rutiny pro řešení často se vyskytujících problémů kombinovány do knihoven. Mezi takové úkoly patří: výpočet matematických funkcí, vstup/výstup dat, zpracování řetězců, interakce s nástroji operačního systému atd. Použití knihovních rutin zbavuje uživatele potřeby vyvíjet vhodné nástroje a poskytuje mu další služby. Funkce obsažené v knihovnách jsou dodávány s programovacím systémem. Jejich deklarace jsou uvedeny v souborech *.h (jedná se o tzv. include nebo hlavičkové soubory). Proto, jak je uvedeno výše, na začátku programu s knihovními funkcemi by měly být řádky jako:
#zahrnout<включаемый_файл_типа_h>
Například:
#zahrnout
K dispozici jsou také zařízení pro rozšiřování a vytváření nových knihoven s uživatelskými programy.
Globálním proměnným je přiděleno pevné místo v paměti po celou dobu trvání programu. Lokální proměnné jsou uloženy v zásobníku. Mezi nimi je paměťová oblast pro dynamickou alokaci.
Funkce malloc() a free() se používají k dynamickému přidělování volné paměti. Funkce malloc() paměť alokuje, funkce free() ji uvolní. Prototypy těchto funkcí jsou uloženy v hlavičkovém souboru stdlib.h a vypadají takto:
void *malloc(velikost_t velikost);
void *free(void *p);
Funkce malloc() vrací ukazatel void; Pro správné použití musí být hodnota funkce převedena na ukazatel na příslušný typ. Pokud je úspěšná, funkce vrátí ukazatel na první bajt volné paměti o velikosti. Pokud není dostatek paměti, vrátí se hodnota 0. Chcete-li určit počet bajtů potřebných pro proměnnou, použijte operaci sizeof().
Příklad použití těchto funkcí:
#zahrnout
#zahrnout
p = (int *) malloc(100 * sizeof(int)); /* Přidělte paměť pro 100
celá čísla */
printf("Nedostatek paměti\n");
pro (i = 0; i< 100; ++i) *(p+i) = i; /* Использование памяти */
pro (i = 0; i< 100; ++i) printf("%d", *(p++));
zdarma(p); /* Volná paměť */
Před použitím ukazatele vráceného malloc() se musíte ujistit, že je dostatek paměti (ukazatel není null).
Preprocesor
C preprocesor je program, který zpracovává vstup do kompilátoru. Preprocesor se podívá na zdrojový program a provede následující akce: připojí k němu určené soubory, provede substituce a také řídí podmínky kompilace. Programové řádky začínající symbolem # jsou určeny pro preprocesor. Na jeden řádek je povoleno zapsat pouze jeden příkaz (direktivu preprocesoru).
Směrnice
#define náhrada identifikátoru
způsobí, že pojmenovaný identifikátor bude v následujícím textu programu nahrazen textem náhrady (všimněte si absence středníku na konci tohoto příkazu). Tato směrnice v podstatě zavádí definici makra, kde „identifikátor“ je název definice makra a „substituce“ je posloupnost znaků, kterými preprocesor nahradí zadaný název, když jej najde v textu programu. Je obvyklé psát název definice makra velkými písmeny.
Podívejme se na příklady:
První řádek způsobí, že program nahradí identifikátor MAX konstantou 25. Druhý řádek umožňuje použít v textu slovo BEGIN místo úvodní složené závorky (().
Všimněte si, že vzhledem k tomu, že preprocesor nekontroluje kompatibilitu mezi symbolickými názvy definic maker a kontextem, ve kterém jsou použity, doporučuje se definovat takové identifikátory nikoli direktivou #define, ale pomocí klíčového slova const s explicitním označením typ (to platí ve větší míře pro C++):
const int MAX = 25;
(typ int lze vynechat, protože je výchozí).
Pokud direktiva #define vypadá takto:
#define identifier(identifikátor, ..., identifikátor) substituce
a mezi prvním identifikátorem a úvodní závorkou není mezera, pak jde o definici substituce makra argumenty. Například po řádku jako:
#define READ(val) scanf("%d", &val)
příkaz READ(y); zacházeno stejně jako scanf("%d",&y);. Zde je argument argument a provede se substituce makra argumentem.
Pokud jsou v substituci dlouhé definice, které pokračují na dalším řádku, znak \ se umístí na konec dalšího pokračovacího řádku.
Objekty oddělené ## můžete vložit do definice makra, například:
#define PR(x, y) x##y
Poté PR(a, 3) zavolá substituci a3. Nebo například definice makra
#define z(a, b, c, d) a(b##c##d)
bude mít za následek nahrazení z(sin, x, +, y) sin(x+y).
Symbol # umístěný před argument makra označuje, že je převedeno na řetězec. Například po směrnici
#define PRIM(var) printf(#var"= %d", var)
následující část textu programu
se převádí takto:
printf("rok""= %d", rok);
Pojďme si popsat další direktivy preprocesoru. Direktivu #include jsme viděli již dříve. Může být použit ve dvou formách:
#include "název souboru"
#zahrnout<имя файла>
Úkolem obou příkazů je zahrnout do programu soubory se zadaným názvem. První z nich načte soubor z aktuálního adresáře nebo adresáře zadaného jako prefix. Druhý příkaz hledá soubor ve standardních umístěních definovaných v programovacím systému. Pokud soubor, jehož název je napsán v uvozovkách, není v zadaném adresáři nalezen, bude hledání pokračovat v podadresářích zadaných pro příkaz #include<...>. Direktivy #include mohou být vnořeny do sebe.
Další skupina direktiv umožňuje selektivně kompilovat části programu. Tento proces se nazývá podmíněná kompilace. Tato skupina zahrnuje direktivy #if, #else, #elif, #endif, #ifdef, #ifndef. Základní forma zápisu direktivy #if vypadá takto:
#if konstantní_výraz sekvence_operátorů
Zde se kontroluje hodnota konstantního výrazu. Pokud je pravdivá, provede se zadaná sekvence příkazů, a pokud je nepravdivá, pak se tato posloupnost příkazů vynechá.
Akce direktivy #else je podobná akci příkazu else v jazyce C, například:
#if konstantní_výraz
posloupnost_2
Pokud je konstantní výraz pravdivý, provede se operator_sequence_1 a pokud je nepravda, provede se operator_sequence_2.
Direktiva #elif znamená akci „else if“. Základní forma jeho použití je:
#if konstantní_výraz
sekvence_příkazů
#elif konstantní_výraz_1
posloupnost_1
#elif konstantní_výraz_n
sekvence_výroků_n
Tato forma je podobná konstrukci jazyka C: if...else if...else if...
Směrnice
#ifdef identifikátor
určuje, zda je zadaný identifikátor aktuálně definován, tzn. zda byl zahrnut v direktivách jako #define. Řetězec formuláře
#ifndef identifikátor
zkontroluje, zda zadaný identifikátor není aktuálně definován. Za kteroukoli z těchto direktiv může následovat libovolný počet řádků textu, případně obsahující příkaz #else (nelze použít #elif) a končící řádkem #endif. Pokud je kontrolovaná podmínka pravdivá, pak jsou ignorovány všechny řádky mezi #else a #endif, a pokud je nepravda, pak řádky mezi kontrolou a #else (pokud není slovo #else, pak #endif). Direktivy #if a #ifndef lze vnořit do sebe.
Zobrazit směrnici
#undef identifikátor
způsobí, že zadaný identifikátor bude považován za nedefinovaný, tzn. nepodléhá výměně.
Podívejme se na příklady. Následující tři směrnice:
zkontrolujte, zda je definován identifikátor WRITE (tj. zda tam byl příkaz typu #define WRITE...), a pokud ano, pak se název WRITE začne považovat za nedefinovaný, tzn. nepodléhá výměně.
směrnice
#define WRITE fprintf
zkontroluje, zda není identifikátor WRITE definován, a pokud ano, určí se identifikátor WRITE namísto jména fprintf.
Direktiva #error je napsána v následujícím tvaru:
#error error_message
Pokud se objeví v textu programu, kompilace se zastaví a na displeji se zobrazí chybová zpráva. Tento příkaz se používá hlavně během fáze ladění. Všimněte si, že chybová zpráva nemusí být uzavřena do dvojitých uvozovek.
Direktiva #line je určena ke změně hodnot proměnných _LINE_ a _FILE_ definovaných v programovacím systému C. Proměnná _LINE_ obsahuje číslo řádku právě prováděného programu. Identifikátor _FILE_ je ukazatel na řetězec s názvem kompilovaného programu. Direktiva #line je napsána takto:
#line number "file_name"
Číslo je zde jakékoli kladné celé číslo, které bude přiřazeno proměnné _LINE_, název_souboru je volitelný parametr, který přepíše hodnotu _FILE_.
Direktiva #pragma umožňuje předat některé instrukce kompilátoru. Například čára
označuje, že program C obsahuje řetězce assembleru. Například:
Podívejme se na některé globální identifikátory nebo názvy maker (názvy definic maker). Je definováno pět takových jmen: _LINE_, _FILE_, _DATE_, _TIME_, _STDC_. Dva z nich (_LINE_ a _FILE_) již byly popsány výše. Identifikátor _DATE_ určuje řetězec, který ukládá datum, kdy byl zdrojový soubor přeložen do objektového kódu. Identifikátor _TIME_ určuje řetězec, který ukládá čas, kdy byl zdrojový soubor přeložen do objektového kódu. Makro _STDC_ má hodnotu 1, pokud jsou použity standardní definované názvy maker. Jinak tato proměnná nebude definována.
Někdy při spouštění programu je užitečné předat mu nějaké informace. Obvykle jsou tyto informace předány do main() pomocí argumentů příkazového řádku. Argument příkazového řádku je informace, která se zadává do příkazového řádku operačního systému za názvem programu. Chcete-li například začít kompilovat program, musíte do příkazového řádku po výzvě napsat něco jako následující:
Kopie název_programu
název_programu je argument příkazového řádku; udává název programu, který se chystáte zkompilovat.
K přijetí argumentů příkazového řádku se používají dva speciální vestavěné argumenty: argc a argv. Parametr argc obsahuje počet argumentů na příkazovém řádku a je to celé číslo a vždy je alespoň 1, protože první argument je název programu. A parametr argv je ukazatel na pole ukazatelů na řetězce. V tomto poli každý prvek ukazuje na argument příkazového řádku. Všechny argumenty příkazového řádku jsou řetězce, takže převod jakýchkoli čísel do požadovaného binárního formátu musí být zajištěn v programu při jeho vývoji.
Zde je jednoduchý příklad použití argumentu příkazového řádku. Na obrazovce se zobrazí slovo Ahoj a vaše jméno, které je třeba zadat jako argument příkazového řádku.
#zahrnout
Pokud jste tento program nazvali jméno (jméno) a vaše jméno je Tom, pak pro spuštění programu byste měli do příkazového řádku zadat jméno Tom. V důsledku spuštění programu se na obrazovce objeví zpráva Ahoj, Tome.
V mnoha prostředích musí být všechny argumenty příkazového řádku odděleny mezerou nebo tabulátorem. Čárky, středníky a podobné znaky se nepovažují za oddělovače. Například,
Běžte, utíkejte
se skládá ze tří znakových řetězců, zatímco
Eric, Rick, Fred
představuje jeden znakový řetězec - čárky se zpravidla nepovažují za oddělovače.
Pokud řetězec obsahuje mezery, můžete jej v některých prostředích uzavřít do dvojitých uvozovek, abyste zabránili vytváření více argumentů. V důsledku toho bude celý řetězec považován za jeden argument. Chcete-li se dozvědět více o tom, jak váš operační systém nastavuje parametry příkazového řádku, přečtěte si dokumentaci k operačnímu systému.
Je velmi důležité správně deklarovat argv. Nejčastěji se to dělá takto:
Char *argv;
Prázdné hranaté závorky označují, že pole má neurčitou délku. K jednotlivým argumentům lze nyní přistupovat indexováním pole argv. Například argv ukazuje na první řetězec znaků, což je vždy název programu; argv ukazuje na první argument a tak dále.
Dalším malým příkladem použití argumentů příkazového řádku je následující program, odpočítávání. Tento program počítá zpětně, počínaje nějakou hodnotou (zadanou na příkazovém řádku), a pípne, když dosáhne 0. Všimněte si, že první argument obsahující počáteční hodnotu je převeden na celočíselnou hodnotu pomocí standardní funkce atoi (). Pokud je druhý argument příkazového řádku (a pokud za argument považujeme název programu, pak třetí) je řádek „zobrazení“ (zobrazení), pak se na obrazovce zobrazí výsledek počítání (v opačném pořadí).
/* Program pro počítání v obráceném pořadí. */ #zahrnout
Vezměte prosím na vědomí, že pokud nejsou zadány argumenty příkazového řádku, zobrazí se chybová zpráva. Programy, které přebírají argumenty příkazového řádku, často dělají následující: Když uživatel spustí tyto programy bez zadání požadovaných informací, zobrazí pokyny, jak správně zadat argumenty.
Chcete-li získat přístup k jednotlivému znaku jednoho z argumentů příkazového řádku, zadejte druhý index do argv. Například následující program vypíše znak po znaku všechny argumenty, se kterými byl volán:
#zahrnout Pamatujte, že první index argv poskytuje přístup k řetězci a druhý index poskytuje přístup k jeho jednotlivým znakům. Typicky se argc a argv používají k tomu, aby daly programu počáteční příkazy, které bude potřebovat při spuštění. Například argumenty příkazového řádku často určují informace, jako je název souboru, možnost nebo alternativní chování. Použití argumentů příkazového řádku dává vašemu programu "profesionální vzhled" a usnadňuje použití v dávkových souborech. Názvy argc a argv jsou tradiční, ale nejsou povinné. Tyto dva parametry ve funkci main() můžete volat, jak chcete. Některé kompilátory mohou navíc podporovat další argumenty pro main(), takže se ujistěte, že si prohlédnete dokumentaci vašeho kompilátoru. Když program nevyžaduje parametry příkazového řádku, je nejběžnější explicitně deklarovat funkci main() jako bez parametrů. V tomto případě je klíčové slovo void použito v seznamu parametrů této funkce. Při automatickém vytváření konzolové aplikace v programovacím jazyce C++ se automaticky vytvoří hlavní funkce velmi podobná této: int main(int argc, char * argv) Hlavička funkce obsahuje podpis hlavní funkce main() s argumenty argс a argv. Když spustíte program prostřednictvím příkazového řádku Windows, můžete mu předat některé informace. V tomto případě bude příkazový řádek vypadat takto: Argumenty příkazového řádku jsou odděleny jednou nebo více mezerami. Argument argv obsahuje úplný název aplikace: #zahrnout cout<< argv << endl; Návrat 0; Výsledek provedení Příklad: Výpočet součinu dvou celých čísel #zahrnout Int a = 0, b = 0; If (argc > 1) a = StrToInt(argv); Pokud (argc > 2) b = StrToInt(argv); cout<< a <<«*»
<< b << «= «
<< a*b << endl; Návrat 0; Program se spouští následovně: Výsledek provedení Chcete-li předat argumenty příkazového řádku při ladění programu, musíte vstoupit do nabídky Vlastnosti projekt. Při spuštění programu v režimu ladění budou zadané argumenty programem považovány za argumenty příkazového řádku.
{…}
Pokud spouštíte program přes příkazový řádek, pak je možné do tohoto programu přenést některé informace. K tomu existují argumenty příkazového řádku argc a argv.
Parametr argc je typu int a obsahuje počet parametrů předávaných hlavní funkci. Navíc argc je vždy alespoň 1, i když hlavní funkci nejsou předány žádné informace, protože prvním parametrem je název aplikace.
Parametr argv je pole ukazatelů na řetězce. Přes příkazový řádek lze předávat pouze data řetězce.
Jednotka:\cesta\název.exe argument1 argument2 ...
pomocí jmenného prostoru std;
}
Program pomocí této funkce převede řetězec na celé číslo StrToInt() odtud.
pomocí jmenného prostoru std;
int StrToInt(char *s) (…)
int main(int argc, char * argv) (
}Ladění programu pomocí argumentů příkazového řádku
Na kartě Vlastnosti konfigurace ->Ladění Vybrat Příkazové argumenty a nastavit jejich hodnoty. 