Borland C++ podporuje tri hlavné () argumenty. Prvé dva sú tradičné argc a argv. Toto sú jediné argumenty hlavné funkcie(), definované štandardom ANSI C. Umožňujú odovzdanie argumentov príkazového riadka programu. Argumenty príkazového riadku sú informácie nasledujúce za názvom programu príkazový riadok operačný systém. Napríklad, keď je program kompilovaný pomocou inline kompilátora Borland, bcc sa zvyčajne zadáva názov_programu

Kde názov_programu je program, ktorý sa má skompilovať. Názov programu sa odovzdá kompilátoru ako argument.

Parameter argc obsahuje počet argumentov príkazového riadku a je to celé číslo. Vždy je aspoň 1, pretože názov programu je kvalifikovaný ako prvý argument. Parameter argv je ukazovateľ na pole ukazovateľov znakov. Každý prvok tohto poľa ukazuje na argument príkazového riadka. Všetky argumenty príkazového riadku sú reťazce. Všetky čísla sú konvertované programom do interného formátu. Nasledujúci program vypíše „Ahoj“ a za ním používateľské meno, ak je napísané hneď za názvom programu:

#include

{
if(argc!=2)
{
printf("Zabudli ste zadať svoje meno\n");
návrat 1;
}
printf("Ahoj %s", argv);
návrat 0;
}

Ak sa volá tento program meno a používateľské meno je Sergey, potom na spustenie programu by ste mali zadať:
meno Sergej.
V dôsledku programu sa objaví:
Ahoj Sergei.

Argumenty príkazového riadka musia byť oddelené medzerami alebo tabulátormi. Čiarky, bodkočiarky a podobné znaky sa nepovažujú za oddeľovače. Napríklad:

Pozostáva z troch riadkov, pričom

Herb, Rick, Fred

Toto je jeden riadok – čiarky nie sú oddeľovače.

Ak chcete zadať reťazec obsahujúci medzery alebo tabulátory ako jeden argument, uzatvorte ho dvojité úvodzovky. Napríklad toto je jeden argument:

"toto je test"

Je dôležité správne deklarovať argv. Najtypickejšia metóda je:

Prázdne zátvorky označujú, že pole nemá pevnú dĺžku. K jednotlivým prvkom sa dostanete pomocou indexovania argv. Napríklad argv ukazuje na prvý riadok, ktorý vždy obsahuje názov programu. argv ukazuje na ďalší riadok atď.

Nižšie je uvedený malý príklad použitia argumentov príkazového riadku. Odpočítava od hodnoty zadanej na príkazovom riadku a pri dosiahnutí nuly vydá signál. Všimnite si, že prvý argument obsahuje číslo prevedené na celé číslo pomocou štandardnej funkcie atoi(). Ak je reťazec "zobrazenie" prítomný ako druhý argument, potom sa na obrazovke zobrazí samotné počítadlo.

/* program na počítanie */

#include
#include
#include
int main(int argc, char *argv)
{
int disp, počet;
if(argc<2)
{
printf("Musíte zadať dĺžku počítania\n");
printf("na príkazovom riadku. Skúste to znova.\n");
návrat 1;
}
if (argc==3 && !strcmp(argv,"zobrazit")) disp = 1;
inak disp = 0;
for(count=atoi(argv); count; -count)
if (disp) printf("%d", pocet);
printf("%c", "\a"); /* na väčšine počítačov ide o volanie */
návrat 0;
}

Všimnite si, že ak nie sú zadané žiadne argumenty, zobrazí sa chybové hlásenie. Toto je najtypickejšie pre programy, ktoré používajú argumenty príkazového riadka na zadávanie pokynov, ak bol vykonaný pokus o spustenie programu bez správnych informácií.

Ak chcete získať prístup k jednotlivým znakom príkazového riadka, pridajte do argv druhý index. Napríklad nasledujúci program vypíše všetky argumenty, pomocou ktorých bol volaný, jeden znak po druhom:

#include
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;
}

Je potrebné si uvedomiť, že prvý index slúži na prístup k reťazcu a druhý je na prístup k znaku reťazca.

Typicky sa argc a argv používajú na získanie zdrojových príkazov. Teoreticky môžete mať až 32 767 argumentov, no väčšina operačných systémov vám ani nedovolí sa k tomu priblížiť. Tieto argumenty sa zvyčajne používajú na určenie názvu súboru alebo možností. Použitie argumentov príkazového riadku dáva programu profesionálny vzhľad a umožňuje použitie programu v dávkových súboroch.

Ak zahrniete súbor WILDARGS.OBJ dodávaný s Borland C++, môžete použiť zástupné znaky v argumentoch typu *.EXE. (Borland C++ spracováva vzory automaticky a podľa toho zvyšuje argc.) Napríklad, ak pripojíte WILDARGS.OBJ k nasledujúcemu programu, vypíše, koľko súborov sa zhoduje s názvom súboru zadaného v príkazovom riadku:

/* Prepojte tento program s WILDARGS.OBJ */

#include
int main(int argc, char *argv)
{
register int i;
printf("%d súborov zodpovedá zadanému názvu\n", argc-1);
printf("Sú to: ");
pre (i=1; i printf("%s", argv[i]);
návrat 0;
}

Ak tento program nazveme WA, potom ho spustíme nasledovne, dostaneme počet súborov, ktoré majú príponu EXE, a zoznam názvov týchto súborov:

Okrem argc a argv poskytuje Borland C++ aj tretí argument príkazového riadka -env. Parameter env umožňuje programu prístup k informáciám o prostredí operačného systému. Parameter env musí nasledovať po argc a argv a je deklarovaný takto:

Ako vidíte, env sa deklaruje rovnakým spôsobom ako argv. Rovnako ako argv, toto je ukazovateľ na pole reťazcov. Každý riadok je reťazec prostredia, ako ho definuje operačný systém. Parameter env nemá žiadny náprotivok k parametru argc, ktorý hovorí, koľko je tam riadkov prostredia. Namiesto toho je posledný riadok prostredia nulový. Nasledujúci program vytlačí všetky reťazce prostredia aktuálne definované v operačnom systéme:

/* tento program vypíše všetky riadky prostredia */

#include
int main(int argc, char *argv, char *env)
{
int t;
for(t=0; env[t]/t++)
printf("%s\n", env[t]);
návrat 0;
}

Všimnite si, že hoci argc a argv program nepoužíva, musia byť prítomné v zozname parametrov. C nepozná názvy parametrov. Namiesto toho je ich použitie určené poradím, v ktorom sú parametre deklarované. V skutočnosti môžete parameter nazvať akokoľvek chcete. Pretože argc, argv a env sú tradičné názvy, je najlepšie ich naďalej používať, aby každý, kto číta program, okamžite rozpoznal, že ide o argumenty funkcie main().

Pre programy je typickou úlohou nájsť hodnotu definovanú v reťazci prostredia. Napríklad obsah reťazca PATH umožňuje programom používať vyhľadávacie cesty. Nasledujúci program ukazuje, ako nájsť reťazce, ktoré deklarujú štandardné vyhľadávacie cesty. Používa štandardnú knižničnú funkciu strstr(), ktorá má nasledujúci prototyp:

Char *strstr(const char *str1, const char *str2);

Funkcia strstr() hľadá reťazec, na ktorý ukazuje str1, v reťazci, na ktorý ukazuje str2. Ak sa takýto reťazec nájde, vráti sa ukazovateľ na prvú pozíciu. Ak sa nenájde žiadna zhoda, funkcia vráti hodnotu NULL.

/* program hľadá v reťazcoch prostredia reťazec obsahujúci PATH */

#include
#include
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;
}

Pri vytváraní konzolovej aplikácie v programovacom jazyku C++ sa automaticky vytvorí riadok veľmi podobný tomuto:

int main(int argc, char* argv) // parametre funkcie main().

Tento riadok je hlavičkou hlavnej funkcie main() , parametre argс a argv sú uvedené v zátvorkách. Takže, ak je program spustený cez príkazový riadok, potom je možné do tohto programu preniesť akékoľvek informácie, na to existujú parametre argc a argv. Parameter argc je dátového typu int a obsahuje počet parametrov odovzdaných hlavnej funkcii. Navyše argc je vždy aspoň 1, aj keď neodovzdáme žiadne informácie, pretože názov funkcie sa považuje za prvý parameter. Parameter argv je pole ukazovateľov na reťazce. Cez príkazový riadok možno preniesť iba údaje typu reťazec. Ukazovatele a reťazce sú dve veľké témy, pre ktoré boli vytvorené samostatné sekcie. Takže všetky informácie sa prenášajú cez parameter argv. Vyvinieme program, ktorý spustíme cez príkazový riadok Windowsu a odovzdáme mu nejaké informácie.

// argc_argv.cpp: Určuje vstupný bod pre aplikáciu konzoly. #include "stdafx.h" #include pomocou menného priestoru std; int main(int argc, char* argv) ( if (argc ><< argv<

// kód Kód::Blocks

// Kód Dev-C++

// argc_argv.cpp: Určuje vstupný bod pre aplikáciu konzoly. #include pomocou menného priestoru std; int main(int argc, char* argv) ( ak (argc > 1)// ak odovzdáme argumenty, potom argc bude väčšie ako 1 (v závislosti od počtu argumentov) ( cout<< argv<

Po odladení programu otvorte príkazový riadok Windows a pretiahnite spustiteľný súbor nášho programu do okna príkazového riadka, na príkazovom riadku sa zobrazí úplná cesta k programu (cestu k programu však môžete napísať ručne), po že môžete stlačiť ENTER a program sa spustí (pozri obrázok 1).

Obrázok 1 - Parametre hlavnej funkcie

Keďže sme program len spustili a neodovzdali sme mu žiadne argumenty, objavilo sa hlásenie Nie sú argumenty. Obrázok 2 ukazuje spustenie toho istého programu cez príkazový riadok, ale s argumentom Otvoriť.

Obrázok 2 - Parametre hlavnej funkcie

Argumentom je slovo Open , ako môžete vidieť na obrázku, toto slovo sa objavilo na obrazovke. Môžete odovzdať niekoľko parametrov naraz, pričom ich oddelíte čiarkou. Ak je potrebné zadať parameter pozostávajúci z niekoľkých slov, musia byť uvedené v úvodzovkách a tieto slová sa budú považovať za jeden parameter. Na obrázku je napríklad znázornené spustenie programu a odovzdanie argumentu pozostávajúceho z dvoch slov - Funguje to.

Obrázok 3 - Parametre hlavnej funkcie

A ak odstránite úvodzovky. Potom uvidíme iba slovo To. Ak neplánujete odovzdávať žiadne informácie pri spustení programu, potom môžete odstrániť argumenty vo funkcii main(), môžete tiež zmeniť názvy týchto argumentov. Niekedy dochádza k úpravám parametrov argc a argv, ale všetko závisí od typu vytváranej aplikácie alebo od vývojového prostredia.

Pri automatickom vytváraní konzolovej aplikácie v programovacom jazyku C++ sa automaticky vytvorí hlavná funkcia, ktorá je veľmi podobná tejto:

int main(int argc, char * argv)
{…}

Hlavička funkcie obsahuje podpis hlavnej funkcie main() s argumentmi argc a argv .
Ak sa program spúšťa cez príkazový riadok, potom je možné do tohto programu preniesť akékoľvek informácie. Na to existujú argumenty príkazového riadku argc a argv.
Parameter argc je typu int a obsahuje počet parametrov odovzdaných hlavnej funkcii. Okrem toho je argc vždy aspoň 1, aj keď sa do hlavnej funkcie neodovzdávajú žiadne informácie, pretože názov aplikácie sa považuje za prvý parameter.
Parameter argv je pole ukazovateľov na reťazce. Cez príkazový riadok možno preniesť iba údaje typu reťazec.

Keď spustíte program cez príkazový riadok systému Windows, môžete mu odovzdať niektoré informácie. V tomto prípade bude príkazový riadok vyzerať takto:
Jednotka:\cesta\názov.exe argument1 argument2 ...

Argumenty príkazového riadka sú oddelené jednou alebo viacerými medzerami.

Argument argv obsahuje úplný názov aplikácie:

#include
pomocou menného priestoru std;

cout<< argv << endl;

návrat 0;
}

Výsledok popravy

Príklad: výpočet súčinu dvoch celých čísel
Program používa funkciu konverzie reťazca na celé číslo StrToInt() odtiaľto .

#include
pomocou menného priestoru std;
int StrToInt(char*s) (…)
int main(int argc, char * argv) (

Int a = 0, b = 0;

Ak (argc > 1)

a = StrToInt(argv);

Ak (argc > 2)

b = StrToInt(argv);

cout<< a <<«*» << b << «= « << a*b << endl;

návrat 0;
}

Program sa spúšťa ako

Výsledok popravy

Ladenie programu pomocou argumentov príkazového riadku

Ak chcete odovzdať argumenty príkazového riadka pri ladení programu, musíte vstúpiť do ponuky Vlastnosti projektu.


Na karte Vlastnosti konfigurácie -> Ladenie vyberte si Argumenty príkazov a nastaviť ich hodnoty.

Keď spustíte program v režime ladenia, so zadanými argumentmi bude program zaobchádzať ako s argumentmi príkazového riadku.

Programom C môžete odovzdať určité argumenty. Keď sa na začiatku výpočtu zavolá main(), odovzdajú sa mu tri parametre. Prvý z nich určuje počet argumentov príkazu pri prístupe k programu. Druhým je pole ukazovateľov na reťazce znakov, ktoré obsahujú tieto argumenty (jeden argument na reťazec). Tretím je tiež pole ukazovateľov na znakové reťazce, slúži na prístup k parametrom operačného systému (premenné prostredia).

Každý takýto riadok je reprezentovaný ako:

premenná = hodnota\0

Posledný riadok nájdete podľa dvoch koncových núl.

Pomenujme argumenty funkcie main(): argc, argv a env (možné sú aj iné názvy). Potom sú povolené nasledujúce popisy:

main(int argc, char *argv)

main(int argc, char *argv, char *env)

Predpokladajme, že na jednotke A: je nejaký program prog.exe. Riešime to takto:

A:\>prog.exe súbor1 súbor2 súbor3

Potom argv je ukazovateľ na reťazec A:\prog.exe, argv je ukazovateľ na reťazec file1 atď. Na prvý aktuálny argument poukazuje argv a na posledný argv. Ak argc=1, potom za názvom programu na príkazovom riadku nie sú žiadne parametre. V našom príklade argc=4.

rekurzia

Rekurzia je metóda volania, pri ktorej funkcia volá samu seba.

Dôležitým bodom pri zostavovaní rekurzívneho programu je organizácia výstupu. Tu je ľahké urobiť chybu, že funkcia sa bude dôsledne volať donekonečna. Preto rekurzívny proces musí krok za krokom problém zjednodušiť tak, aby sa preň nakoniec objavilo nerekurzívne riešenie. Použitie rekurzie nie je vždy žiaduce, pretože môže viesť k pretečeniu zásobníka.

Funkcie knižnice

V programovacích systémoch sa podprogramy na riešenie bežných problémov spájajú do knižníc. Tieto úlohy zahŕňajú: výpočet matematických funkcií, vstup/výstup dát, spracovanie reťazcov, interakciu s nástrojmi operačného systému atď. Používanie knižničných podprogramov zbavuje používateľa potreby vývoja vhodných nástrojov a poskytuje mu doplnkovú službu. Funkcie obsiahnuté v knižniciach sú dodávané s programovacím systémom. Ich deklarácie sú uvedené v súboroch *.h (ide o tzv. include alebo hlavičkové súbory). Preto, ako je uvedené vyššie, na začiatku programu s funkciami knižnice by mali byť riadky ako:

#include<включаемый_файл_типа_h>

Napríklad:

#include

K dispozícii sú tiež zariadenia na rozširovanie a vytváranie nových knižníc s používateľskými programami.

Globálnym premenným je počas trvania programu priradené pevné miesto v pamäti. Lokálne premenné sú uložené v zásobníku. Medzi nimi je pamäťová oblasť pre dynamickú alokáciu.

Funkcie malloc() a free() sa používajú na dynamické prideľovanie voľnej pamäte. Funkcia malloc() alokuje pamäť, funkcia free() ju uvoľní. Prototypy týchto funkcií sú uložené v hlavičkovom súbore stdlib.h a vyzerajú takto:

void *malloc(veľkosť_t veľkosť);

void *free(void *p);

Funkcia malloc() vracia ukazovateľ typu void; pre správne použitie musí byť hodnota funkcie prevedená na ukazovateľ na príslušný typ. Po úspechu funkcia vráti ukazovateľ na prvý bajt voľnej pamäte veľkosti. Ak nie je dostatok pamäte, vráti sa hodnota 0. Operácia sizeof() sa používa na určenie počtu bajtov potrebných pre premennú.

Príklad použitia týchto funkcií:

#include

#include

p = (int *) malloc (100 * sizeof (int)); /* Pridelenie pamäte pre 100

celé čísla */

printf("Nedostatok pamäte\n");

pre (i = 0; i< 100; ++i) *(p+i) = i; /* Использование памяти */

pre (i = 0; i< 100; ++i) printf("%d", *(p++));

zadarmo(p); /* Voľná ​​pamäť */

Pred použitím ukazovateľa vráteného pomocou malloc() sa musíte uistiť, že máte dostatok pamäte (ukazovateľ nie je null).

Predprocesor

C preprocesor je program, ktorý spracováva vstup do kompilátora. Preprocesor sa pozrie na zdrojový program a vykoná tieto akcie: pripojí k nemu dané súbory, vykoná substitúcie a spravuje aj podmienky kompilácie. Preprocesor je určený pre programové riadky, ktoré začínajú symbolom #. Na jeden riadok je povolený iba jeden príkaz (direktíva preprocesora).

smernice

#define nahradenie identifikátora

spôsobí, že nasledujúci text programu nahradí pomenovaný identifikátor náhradným textom (všimnite si, že na konci tohto príkazu chýba bodkočiarka). Táto smernica v podstate zavádza definíciu makra (makro), kde „identifikátor“ je názov definície makra a „náhrada“ je postupnosť znakov, ktorými preprocesor nahradí zadaný názov, keď ho nájde v texte programu. Názov makra sa zvyčajne píše veľkými písmenami.

Zvážte príklady:

Prvý riadok spôsobí, že program nahradí identifikátor MAX konštantou 25. Druhý umožňuje použiť v texte namiesto otváracej zloženej zátvorky (() slovo BEGIN.

Upozorňujeme, že keďže preprocesor nekontroluje kompatibilitu medzi symbolickými názvami definícií makier a kontextom, v ktorom sa používajú, odporúča sa definovať takéto identifikátory nie direktívou #define, ale kľúčovým slovom const s explicitným označením typu. (to platí skôr pre C + +):

const int MAX = 25;

(typ int možno vynechať, pretože je štandardne nastavený).

Ak direktíva #define vyzerá takto:

#define identifier(identifikátor, ..., identifikátor) ​​substitúcia

a medzi prvým identifikátorom a úvodnou zátvorkou nie je medzera, potom ide o definíciu makro substitúcie s argumentmi. Napríklad, keď sa objaví riadok ako:

#define READ(val) scanf("%d", &val)

príkaz READ(y); sa spracuje rovnako ako scanf("%d",&y);. Tu je argument val a substitúcia makra sa vykonáva s argumentom.

Ak sú v nahradení dlhé definície, ktoré pokračujú na ďalšom riadku, na koniec nasledujúceho riadku sa umiestni znak \.

Do definície makra môžete umiestniť objekty oddelené znakmi ##, napríklad:

#define PR(x, y) x##y

Potom PR(a, 3) zavolá substitúciu a3. Alebo napríklad definícia makra

#define z(a, b, c, d) a(b##c##d)

zmení z(sin, x, +, y) na sin(x+y).

Znak # umiestnený pred argument makra znamená, že sa skonvertuje na reťazec. Napríklad po smernici

#define PRIM(var) printf(#var"= %d", var)

nasledujúci fragment textu programu

sa prevádza takto:

printf("rok""= %d", rok);

Poďme si popísať ďalšie direktívy preprocesora. Smernicu #include sme už videli. Môže byť použitý v dvoch formách:

#include "názov súboru"

#include<имя файла>

Účinok oboch príkazov je zahrnutie súborov so zadaným názvom do programu. Prvý načíta súbor z aktuálneho adresára alebo adresára zadaného ako prefix. Druhý príkaz vyhľadá súbor na štandardných miestach definovaných v programovacom systéme. Ak sa súbor, ktorého názov je napísaný v úvodzovkách, nenájde v zadanom adresári, vyhľadávanie bude pokračovať v podadresároch zadaných pre príkaz #include<...>. Direktívy #include môžu byť vnorené do seba.

Ďalšia skupina direktív umožňuje selektívne zostavovať časti programu. Tento proces sa nazýva podmienená kompilácia. Táto skupina zahŕňa direktívy #if, #else, #elif, #endif, #ifdef, #ifndef. Základná forma smernice #if je:

#if konštantný_výraz príkazová_sekvencia

Tu sa kontroluje hodnota konštantného výrazu. Ak je pravdivá, vykoná sa daná postupnosť príkazov a ak je nepravdivá, táto postupnosť príkazov sa preskočí.

Činnosť direktívy #else je podobná činnosti príkazu else v jazyku C, napríklad:

#if konštantný_výraz

príkaz_sekvencia_2

Ak je konštantný výraz pravdivý, potom sa vykoná sekvencia_operátorov_1 a ak je nepravdivá, vykoná sa sekvencia_operátorov_2.

Direktíva #elif znamená akciu typu „else if“. Hlavná forma jeho použitia je nasledovná:

#if konštantný_výraz

príkaz_sekvencia

#elif konštantný_výraz_1

príkaz_sekvencia_1

#elif konštantný_výraz_n

postupnosť_výrokov_n

Tento formulár je podobný konštruktu jazyka C formulára: if...else if...else if...

smernice

#ifdef identifikátor

nastavuje, či je zadaný identifikátor aktuálne definovaný, t.j. či to bolo zahrnuté v smerniciach vo forme #define. Zobraziť riadok

#ifndef identifikátor

skontroluje, či zadaný identifikátor momentálne nie je definovaný. Po ktorejkoľvek z týchto direktív môže nasledovať ľubovoľný počet riadkov textu, prípadne obsahujúcich príkaz #else (nie je možné použiť #elif) a končiacich riadkom #endif. Ak je kontrolovaná podmienka pravdivá, potom sa ignorujú všetky riadky medzi #else a #endif, a ak je nepravda, potom riadky medzi kontrolou a #else (ak nie je žiadne slovo #else, potom #endif). Direktívy #if a #ifndef môžu byť vnorené jedna do druhej.

Pozri smernicu

#undef identifikátor

spôsobí, že uvedený identifikátor bude považovaný za nedefinovaný, t.j. nevymeniteľné.

Zvážte príklady. Ide o tieto tri smernice:

skontrolujte, či je definovaný identifikátor ZÁPIS (t.j. bol to príkaz v tvare #define ZÁPIS...), a ak áno, potom sa názov ZÁPIS považuje za nedefinovaný, t.j. nevymeniteľné.

smernice

#define WRITE fprintf

skontrolujte, či je identifikátor WRITE nedefinovaný, a ak áno, potom sa namiesto názvu fprintf určí identifikátor WRITE.

Smernica #error je napísaná v nasledujúcom tvare:

#error error_message

Ak sa vyskytne v texte programu, kompilácia sa zastaví a na obrazovke sa zobrazí chybové hlásenie. Tento príkaz sa používa hlavne počas fázy ladenia. Upozorňujeme, že chybové hlásenie nemusí byť uzavreté do dvojitých úvodzoviek.

Direktíva #line je určená na zmenu hodnôt premenných _LINE_ a _FILE_ definovaných v programovacom systéme C. Premenná _LINE_ obsahuje číslo riadku práve vykonávaného programu. Identifikátor _FILE_ je ukazovateľ na reťazec s názvom kompilovaného programu. Smernica #line je napísaná takto:

#line number "názov súboru"

Číslo je tu akékoľvek kladné celé číslo, ktoré bude priradené premennej _LINE_, názov súboru je voliteľný parameter, ktorý prepíše hodnotu _FILE_.

Direktíva #pragma vám umožňuje odovzdať niektoré inštrukcie kompilátoru. Napríklad linka

označuje, že v programe C sú reťazce v jazyku symbolických inštancií. Napríklad:

Zvážte niektoré globálne identifikátory alebo názvy makier (názvy definícií makier). Je definovaných päť takýchto názvov: _LINE_, _FILE_, _DATE_, _TIME_, _STDC_. Dva z nich (_LINE_ a _FILE_) už boli opísané vyššie. Identifikátor _DATE_ určuje reťazec, ktorý ukladá dátum, kedy bol zdrojový súbor preložený do objektového kódu. Identifikátor _TIME_ určuje reťazec, v ktorom je uložený čas, kedy bol zdrojový súbor preložený do objektového kódu. Makro _STDC_ má hodnotu 1, ak sa používajú štandardne definované názvy makier. V opačnom prípade táto premenná nebude definovaná.

Stáva sa, že údaje sa do programu prenesú z príkazového riadku pri jeho volaní. Takéto údaje sa nazývajú argumenty príkazového riadku. Vyzerá to napríklad takto:

./a.out test.txt ls -lt /home/peter/

Toto volá programy a.out (z aktuálneho adresára) a ls (z rovnakého adresára špecifikovaného v premennej prostredia PATH). Prvý program z príkazového riadku dostane jedno slovo - test.txt, druhý - dve: -lt a /home/peter/.

Ak je program napísaný v C, potom sa pri spustení okamžite prenesie riadenie na funkciu main(), preto je to ona, kto dostane argumenty príkazového riadku, ktoré sú priradené k jej parametrom premennej.

Zatiaľ sme definovali funkciu main() tak, že neberie žiadne parametre a nič nevracia. V skutočnosti v C akákoľvek funkcia štandardne (ak nie je definované nič iné) vracia celé číslo. Dá sa to overiť. Ak napíšete kód takto:

main() ( printf("Ahoj \n"); návrat 0; )

Potom sa počas kompilácie nevyskytne žiadne varovanie ani chyba. To isté sa stane, ak napíšeme int main() . To dokazuje, že predvolená funkcia vracia celé číslo a nie nič (void). Hoci to, čo funkcia vracia, môže byť vždy „prepísané“, napríklad voidmain() alebo float main() .

Pri volaní programu z príkazového riadku sa mu vždy odovzdá pár údajov:

1. celé číslo, označujúce počet slov (prvkov oddelených medzerami) na príkazovom riadku pri volaní,
2. ukazovateľ na pole reťazcov, kde každý riadok je jedno slovo z príkazového riadku.

Upozorňujeme, že sa berie do úvahy aj samotný názov programu. Ak hovor vyzerá napríklad takto:

./a.out 12 téma 2

Potom je prvý argument programu 4 a pole reťazcov je definované ako (./a.out“, „12“, „téma“, „2“).

Venujte pozornosť terminológii, existujú len dva argumenty programu (číslo a pole), ale toľko argumentov príkazového riadku, koľko chcete. Argumenty príkazového riadku sa "prekladajú" na argumenty programu (do argumentov funkcie main()).
Tieto údaje (číslo a ukazovateľ) sú odovzdané programu, aj keď je jednoducho volaný menom bez toho, aby sa mu čokoľvek odovzdalo: ./a.out. V tomto prípade je prvý argument 1 a druhý argument ukazuje na pole iba jedného reťazca ("./a.out").

To, že sú dáta odovzdané programu, neznamená, že by ich mala prijať funkcia main(). Ak je funkcia main() definovaná bez parametrov, nie je možné získať prístup k argumentom príkazového riadka. Hoci vám nič nebráni v ich odoslaní. Nevyskytne sa žiadna chyba.

Ak chcete získať prístup k údajom odovzdaným do programu, musia byť priradené k premenným. Keďže argumenty sú okamžite odovzdané do main(), jej hlavička by mala vyzerať takto:
hlavné (int n, znak *arr)

Prvá premenná (n) obsahuje počet slov a druhá premenná obsahuje ukazovateľ na pole reťazcov. Druhý parameter sa často zapisuje ako **arr . Je to však rovnaké. Pripomeňme si, že samotné pole reťazcov obsahuje ako svoje prvky ukazovatele na reťazce. A vo funkcii odovzdávame ukazovateľ na prvý prvok poľa. Ukazuje sa, že odovzdávame ukazovateľ k ukazovateľu, t.j. **arr.

Cvičenie
Napíšte takýto program:

#include int main(int argc, char ** argv) ( int i; printf ("%d \n", argc); pre (i= 0; i< argc; i++ ) puts (argv[ i] ) ; }

Pri volaní vypíše počet slov na príkazovom riadku a každé slovo na nový riadok. Zavolajte to bez argumentov príkazového riadku a s argumentmi.

V programe sme použili premenné parametre argc a argv. Je zvykom používať práve takéto mená, no v skutočnosti to môže byť čokoľvek. Je lepšie tento štandard dodržiavať, aby boli vaše programy zrozumiteľnejšie nielen vám, ale aj ostatným programátorom.

Praktický význam odovzdávania údajov do programu

Ak máte skúsenosti s príkazovým riadkom GNU/Linux, viete, že väčšina príkazov má prepínače a argumenty. Napríklad pri prezeraní obsahu adresárov, kopírovaní, presúvaní sú ako argumenty špecifikované objekty súborového systému, na ktorých je príkaz vykonaný. Vlastnosti jeho implementácie sa určujú pomocou kľúčov. Napríklad v príkaze

Cp -r ../les_1 ../les_101

cp je názov príkazu, -r je prepínač a ../les_1 a ../les_101 sú argumenty príkazu.

Vo všeobecnosti sa najčastejšie pri spúšťaní programov prenášajú adresy súborov a „modifikátory“ (to sú kľúče) procesu vykonávania programu.

Napíšme program, ktorý otvorí súbory určené používateľom na príkazovom riadku na zápis alebo pripojenie a zapíše (pridá) tam rovnaké informácie, ktoré používateľ zadá z klávesnice počas vykonávania programu:

#include #include main (int argc, char ** argv) ( int i, ch; FILE * f[ 5 ] ; if (argc< 3 || argc >7 ) ( kladie ( "Neplatný počet parametrov"); návrat 1; ) if (strcmp (argv[ 1 ] , "-w" ) != 0 && strcmp (argv[ 1 ], "-a" ) != 0 ) ( vloží ( "Prvý parameter môže byť -w alebo -a"); návrat 2; ) pre (i= 0; i< argc- 2 ; i++ ) { f[ i] = fopen (argv[ i+ 2 ] , argv[ 1 ] + 1 ) ; if (f[ i] == NULL) { printf ("Súbor %s sa nedá otvoriť\n " argv[i+2]); návrat 3; ) ) while ((ch = getchar () ) != EOF) pre (i= 0; i< argc- 2 ; i++ ) putc (ch, f[ i] ) ; for (i= 0 ; i < argc- 2 ; i++ ) fclose (f[ i] ) ; return 0 ; }

Vysvetlenia pre kód:

1. Vytvorí sa pole piatich ukazovateľov súborov. Preto nie je možné súčasne otvoriť viac ako päť súborov. Ukazovateľ súboru prvého súboru bude uložený v prvku poľa f, druhý - v f atď.
2. Kontroluje sa počet argumentov príkazového riadku. Musia byť aspoň tri, pretože. prvý je názov programu, druhý je režim otvorenia súboru, tretí je prvý alebo jediný súbor, do ktorého sa má zapisovať. Keďže program umožňuje otvoriť iba päť súborov, celkový počet argumentov príkazového riadku nemôže presiahnuť sedem. Ak je teda počet argumentov menší ako 3 alebo väčší ako 7, program končí, pretože Príkaz return spôsobí ukončenie funkcie, aj keď je za ním ďalší kód. Návratovú hodnotu funkcie, ktorá sa nerovná 0, môže nadradený proces interpretovať ako správu, že program skončil s chybou.
3. Kontroluje sa správnosť druhého argumentu príkazového riadka. Ak to nie je ani "-w" ani "-a", potom podmienený výraz v druhom if vráti 1 (pravda). Funkcia strcmp() vám umožňuje porovnávať reťazce a vracia 0, ak sú rovnaké.
4. Cyklus for otvára súbory na zadaných adresách, ktoré začínajú na treťom prvku poľa argv. To je dôvod, prečo sa k i pridá 2, aby sa získali prvky poľa argv, začínajúc od tretieho. Výraz argc-2 označuje počet odovzdaných názvov súborov; pretože argc ukladá celkový počet argumentov príkazového riadku, z ktorých prvé dva nie sú názvy súborov.
5. Výraz argv+1 vám umožňuje „vystrihnúť“ podreťazec „w“ (alebo „a“) ​​z reťazca „-w“ (alebo „-a“), pretože argv je v podstate ukazovateľ na prvý prvok reťazca. Pridaním jedného do ukazovateľa ho posunieme na ďalší prvok v poli.
6. Ak sa súbor nedá otvoriť, funkcia fopen() vráti hodnotu NULL. V tomto prípade program končí.
7. Každý znak zadaný používateľom z klávesnice sa zapíše do všetkých otvorených súborov.
8. Na konci sa súbory zatvoria.