Borland C++ palaiko tris pagrindinius () argumentus. Pirmieji du yra tradiciniai argc ir argv. Tai vieninteliai argumentai pagrindines funkcijas(), apibrėžtas ANSI C standarto. Jie leidžia programai perduoti komandinės eilutės argumentus. Komandinės eilutės argumentai yra informacija po programos pavadinimo komandinė eilutė Operacinė sistema. Pavyzdžiui, kai programa kompiliuojama naudojant Borland eilutinį kompiliatorių, paprastai įvedamas bcc programos_pavadinimas

Kur programos_pavadinimas yra programa, kurią reikia sudaryti. Programos pavadinimas perduodamas kompiliatoriui kaip argumentas.

Argc parametre yra komandinės eilutės argumentų skaičius ir jis yra sveikasis skaičius. Jis visada yra bent 1, nes programos pavadinimas yra pirmasis argumentas. Argv parametras yra žymeklis į simbolių rodyklių masyvą. Kiekvienas šio masyvo elementas nurodo komandinės eilutės argumentą. Visi komandinės eilutės argumentai yra eilutės. Visus skaičius programa konvertuoja į vidinį formatą. Ši programa išspausdina „Hello“, po kurio nurodomas vartotojo vardas, jei įvedamas iškart po programos pavadinimo:

#įtraukti

{
if(argc!=2)
{
printf("Pamiršote įvesti savo vardą\n");
grąžinti 1;
}
printf ("Sveiki, %s", argv);
grąžinti 0;
}

Jei paskambins šią programą vardą, o vartotojo vardas yra Sergejus, tada norėdami paleisti programą turite įvesti:
vardas Sergejus.
Programos rezultatas bus:
Sveikas Sergejus.

Komandinės eilutės argumentai turi būti atskirti tarpais arba skirtukais. Kableliai, kabliataškiai ir panašūs simboliai nelaikomi skyrikliais. Pavyzdžiui:

Susideda iš trijų eilučių, o

Herbas, Rikas, Fredas

Tai viena eilutė – kableliai nėra skiriamieji ženklai.

Jei eilutę, kurioje yra tarpų arba tabuliavimo ženklų, norite perduoti kaip vieną argumentą, įtraukite ją dvigubos kabutės. Pavyzdžiui, tai yra vienas argumentas:

"čia testas"

Svarbu teisingai deklaruoti argv. Labiausiai paplitęs metodas yra:

Tušti skliaustai rodo, kad masyvo ilgis nėra fiksuotas. Atskirus elementus galite pasiekti naudodami argv indeksavimą. Pavyzdžiui, argv nurodo pirmąją eilutę, kurioje visada yra programos pavadinimas. argv nurodo kitą eilutę ir pan.

Žemiau pateikiamas nedidelis komandinės eilutės argumentų naudojimo pavyzdys. Jis skaičiuoja atgal nuo komandinėje eilutėje nurodytos vertės ir siunčia signalą, kai pasiekiamas nulis. Atkreipkite dėmesį, kad pirmame argumente yra skaičius, konvertuotas į sveikąjį skaičių naudojant standartinę atoi() funkciją. Jei eilutė "rodymas" yra kaip antrasis argumentas, tada ekrane bus rodomas pats skaitiklis.

/* skaičiavimo programa */

#įtraukti
#įtraukti
#įtraukti
int main(int argc, char *argv)
{
int disp, count;
if(argc<2)
{
printf("Turite įvesti skaičiavimo ilgį\n");
printf("komandinėje eilutėje. Bandykite dar kartą.\n");
grąžinti 1;
}
if (argc==3 && !strcmp(argv,"display")) disp = 1;
kitaip disp = 0;
for(count=atoi(argv); count; -count)
if (disp) printf ("%d", skaičius);
printf("%c", "\a"); /* daugelyje kompiuterių tai skambutis */
grąžinti 0;
}

Atminkite, kad jei argumentai nenurodyti, pasirodo klaidos pranešimas. Tai labiausiai būdinga programoms, kurios naudoja komandinės eilutės argumentus, kad pateiktų instrukcijas, jei buvo bandoma paleisti programą be teisingos informacijos.

Norėdami pasiekti atskirus komandinės eilutės simbolius, pridėkite antrą indeksą prie argv. Pavyzdžiui, ši programa spausdina visus argumentus, su kuriais ji buvo iškviesta, po vieną simbolį:

#įtraukti
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(");
}
grąžinti 0;
}

Reikia atsiminti, kad pirmasis indeksas skirtas prieigai prie eilutės, o antrasis – prieigai prie eilutės simbolio.

Paprastai argc ir argv naudojami šaltinio komandoms gauti. Teoriškai galite turėti iki 32767 argumentų, tačiau dauguma operacinių sistemų net neleidžia prie to priartėti. Paprastai šie argumentai naudojami nurodyti failo pavadinimą arba parinktis. Komandinės eilutės argumentų naudojimas suteikia programai profesionalų išvaizdą ir leidžia programą naudoti paketiniuose failuose.

Jei įtraukiate WILDARGS.OBJ failą, pateiktą su Borland C++, *.EXE tipo argumentuose galite naudoti pakaitos simbolius. (Borland C++ automatiškai apdoroja šablonus ir atitinkamai padidina argc.) Pavyzdžiui, jei prijungiate WILDARGS.OBJ prie šios programos, ji išspausdins, kiek failų atitinka komandinėje eilutėje nurodytą failo pavadinimą:

/* Susiekite šią programą su WILDARGS.OBJ */

#įtraukti
int main(int argc, char *argv)
{
registruotis int i;
printf ("%d failai atitinka nurodytą pavadinimą\n", argc-1);
printf("Jie yra: ");
for(i=1; i printf("%s", argv[i]);
grąžinti 0;
}

Jei šią programą pavadinsime WA, paleiskite ją taip, gausime failų, turinčių EXE plėtinį, skaičių ir šių failų pavadinimų sąrašą:

Be argc ir argv, Borland C++ taip pat pateikia trečiąjį komandinės eilutės argumentą -env. Parametras env leidžia programai pasiekti informaciją apie operacinės sistemos aplinką. Parametras env turi sekti argc ir argv ir deklaruojamas taip:

Kaip matote, env deklaruojamas taip pat kaip argv. Kaip ir argv, tai yra žymeklis į eilučių masyvą. Kiekviena eilutė yra aplinkos eilutė, kurią apibrėžia operacinė sistema. Parametras env neturi atitikmens argc parametrui, kuris nurodo, kiek aplinkos eilučių yra. Vietoj to, paskutinė aplinkos eilutė yra nulinė. Ši programa spausdina visas aplinkos eilutes, kurios šiuo metu yra apibrėžtos operacinėje sistemoje:

/* ši programa spausdina visas aplinkos eilutes */

#įtraukti
int main (int argc, char * argv, char * env)
{
int t;
for(t=0; env[t]/t++)
printf("%s\n", env[t]);
grąžinti 0;
}

Atminkite, kad nors argc ir argv programa nenaudoja, jie turi būti parametrų sąraše. C nežino parametrų pavadinimų. Vietoj to, jų naudojimas nustatomas pagal parametrų deklaravimo tvarką. Tiesą sakant, parametrą galite vadinti kaip tik norite. Kadangi argc, argv ir env yra tradiciniai pavadinimai, geriausia juos naudoti toliau, kad kiekvienas, skaitantis programą, akimirksniu atpažintų, jog tai yra pagrindinės () funkcijos argumentai.

Programoms įprasta užduotis yra rasti reikšmę, apibrėžtą aplinkos eilutėje. Pavyzdžiui, PATH eilutės turinys leidžia programoms naudoti paieškos kelius. Šioje programoje parodyta, kaip rasti eilutes, deklaruojančias standartinius paieškos kelius. Jis naudoja standartinę bibliotekos funkciją strstr(), kuri turi tokį prototipą:

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

Funkcija strstr() ieško eilutės, į kurią nurodo str1, eilutėje, į kurią nukreipia str2. Jei tokia eilutė randama, grąžinama rodyklė į pirmąją poziciją. Jei atitikmens nerasta, funkcija grąžina NULL.

/* programa aplinkos eilutėse ieško eilutės, kurioje yra PATH */

#įtraukti
#įtraukti
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]);
}
grąžinti 0;
}

Kuriant konsolės programą C++ programavimo kalba, automatiškai sukuriama labai panaši eilutė:

int main(int argc, char* argv) // main() funkcijos parametrai

Ši eilutė yra pagrindinės funkcijos main() antraštė, parametrai argс ir argv deklaruojami skliausteliuose. Taigi, jei programa vykdoma per komandinę eilutę, tada į šią programą galima perkelti bet kokią informaciją, tam yra argc ir argv parametrai. Argc parametras yra int duomenų tipo ir apima pagrindinei funkcijai perduotų parametrų skaičių. Be to, argc visada yra bent 1, net kai neperduodame jokios informacijos, nes funkcijos pavadinimas laikomas pirmuoju parametru. Argv parametras yra masyvas rodyklių į eilutes. Per komandinę eilutę galima perduoti tik eilutės tipo duomenis. Rodyklės ir eilutės yra dvi didelės temos, kurioms sukurti atskiri skyriai. Taigi bet kokia informacija perduodama per parametrą argv. Sukurkime programą, kurią paleisime per Windows komandinę eilutę ir perduosime jai tam tikrą informaciją.

// argc_argv.cpp: nurodo konsolės programos įėjimo tašką. #include "stdafx.h" #include naudojant vardų sritį std; int main(int argc, char* argv) ( if (argc ><< argv<

// kodas Code::Blocks

// Dev-C++ kodas

// argc_argv.cpp: nurodo konsolės programos įėjimo tašką. #įtraukti naudojant vardų sritį std; int main(int argc, char* argv) (jei (argc > 1)// jei perduodame argumentus, tai argc bus didesnis nei 1 (priklausomai nuo argumentų skaičiaus) ( cout<< argv<

Suderinę programą, atidarykite Windows komandų eilutę ir vilkite mūsų programos vykdomąjį failą į komandų eilutės langą, komandų eilutėje bus rodomas visas programos kelias (bet kelią į programą galite įrašyti ir rankiniu būdu), po to kad galite paspausti ENTER ir programa prasidės (žr. 1 pav.).

1 pav. Pagrindinės funkcijos parametrai

Kadangi mes ką tik paleidome programą ir neperdavėme jai jokių argumentų, pasirodė pranešimas Not arguments. 2 paveiksle parodytas tos pačios programos paleidimas per komandinę eilutę, tačiau jai perduodamas argumentas Open.

2 pav. Pagrindinės funkcijos parametrai

Argumentas yra žodis Open , kaip matote iš paveikslo, šis žodis pasirodė ekrane. Galite vienu metu perduoti kelis parametrus, atskirdami juos kableliu. Jei reikia perduoti parametrą, susidedantį iš kelių žodžių, tada jie turi būti įterpti į dvigubas kabutes, o tada šie žodžiai bus laikomi vienu parametru. Pavyzdžiui, paveikslėlyje parodytas programos paleidimas, perduodamas argumentas, susidedantis iš dviejų žodžių - Tai veikia .

3 pav. Pagrindinės funkcijos parametrai

Ir jei pašalinsite kabutes. Tada matysime tik žodį Tai. Jei paleisdami programą neplanuojate perduoti jokios informacijos, tuomet galite pašalinti argumentus funkcijoje main(), taip pat galite pakeisti šių argumentų pavadinimus. Kartais yra argc ir argv parametrų modifikacijos, tačiau viskas priklauso nuo kuriamos programos tipo arba nuo kūrimo aplinkos.

Automatiškai kuriant konsolės programą C++ programavimo kalba, automatiškai sukuriama pagrindinė funkcija, labai panaši į šią:

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

Funkcijos antraštėje yra pagrindinės funkcijos main() parašas su argumentais argc ir argv .
Jei programa vykdoma per komandinę eilutę, į šią programą galima perkelti bet kokią informaciją. Tam yra komandinės eilutės argumentai argc ir argv.
Argc parametras yra int tipo ir apima pagrindinei funkcijai perduotų parametrų skaičių. Be to, argc visada yra bent 1, net kai į pagrindinę funkciją neperduodama jokia informacija, nes programos pavadinimas laikomas pirmuoju parametru.
Argv parametras yra masyvas rodyklių į eilutes. Per komandinę eilutę galima perduoti tik eilutės tipo duomenis.

Kai paleidžiate programą naudodami „Windows“ komandinę eilutę, galite jai perduoti tam tikrą informaciją. Tokiu atveju komandų eilutė atrodys taip:
Diskas:\path\name.exe argument1 argument2 ...

Komandų eilutės argumentai atskiriami vienu ar daugiau tarpų.

Argumente argv yra pilnas programos pavadinimas:

#įtraukti
naudojant vardų erdvę std;

cout<< argv << endl;

grąžinti 0;
}

Vykdymo rezultatas

Pavyzdys: dviejų sveikųjų skaičių sandaugos apskaičiavimas
Programa naudoja eilutę į sveikąjį skaičių konvertavimo funkciją StrToInt() iš čia .

#įtraukti
naudojant vardų erdvę std;
int StrToInt(char*s) (…)
int main(int argc, char * argv) (

Int a = 0, b = 0;

Jei (argc > 1)

a = StrToInt(argv);

Jei (argc > 2)

b = StrToInt(argv);

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

grąžinti 0;
}

Programa paleidžiama kaip

Vykdymo rezultatas

Programos derinimas naudojant komandinės eilutės argumentus

Norėdami perduoti komandinės eilutės argumentus derindami programą, turite pasiekti meniu Savybės projektą.


Skirtuke Konfigūracijos ypatybės -> Derinimas pasirinkti Komandų argumentai ir nustatyti savo vertybes.

Kai paleisite programą derinimo režimu, įvesti argumentai bus traktuojami kaip komandinės eilutės argumentai.

Galite perduoti tam tikrus argumentus C programoms. Kai skaičiavimo pradžioje iškviečiamas main(), jam perduodami trys parametrai. Pirmasis iš jų nustato komandų argumentų skaičių pasiekiant programą. Antrasis yra ženklų masyvas, rodantis simbolių eilutes, kuriose yra šie argumentai (vienoje eilutėje yra vienas argumentas). Trečiasis taip pat yra rodyklių į simbolių eilutes masyvas, naudojamas operacinės sistemos parametrams (aplinkos kintamiesiems) pasiekti.

Bet kuri tokia eilutė vaizduojama taip:

kintamasis = reikšmė\0

Paskutinę eilutę galima rasti dviem nuliais.

Pavadinkime pagrindinius () funkcijos argumentus atitinkamai: argc, argv ir env (galimi ir kiti pavadinimai). Tada leidžiami šie aprašymai:

pagrindinis (int argc, char * argv)

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

Tarkime, kad diske A: yra kokia nors programa prog.exe. Aptarkime tai taip:

A:\>prog.exe failas1 failas2 failas3

Tada argv yra žymeklis į eilutę A:\prog.exe, argv yra žymeklis į eilutę file1 ir pan. Pirmąjį faktinį argumentą nurodo argv, o paskutinį – argv. Jei argc=1, tada komandinėje eilutėje po programos pavadinimo parametrų nėra. Mūsų pavyzdyje argc=4.

rekursija

Rekursija yra iškvietimo metodas, kai funkcija iškviečia save.

Svarbus momentas rengiant rekursinę programą yra išėjimo organizavimas. Čia lengva padaryti klaidą, kad funkcija nuolatos vadinsis neribotą laiką. Todėl rekursinis procesas turi žingsnis po žingsnio supaprastinti problemą, kad galiausiai atsirastų nerekursyvus sprendimas. Rekursijos naudojimas ne visada yra pageidautinas, nes tai gali sukelti krūvos perpildymą.

Bibliotekos funkcijos

Programavimo sistemose bendrų problemų sprendimo paprogramės jungiamos į bibliotekas. Šios užduotys apima: matematinių funkcijų skaičiavimą, duomenų įvedimą/išvedimą, eilučių apdorojimą, sąveiką su operacinės sistemos įrankiais ir kt. Bibliotekos rutinų naudojimas išsaugo vartotoją nuo būtinybės kurti atitinkamus įrankius ir suteikia jam papildomą paslaugą. Į bibliotekas įtrauktos funkcijos pateikiamos kartu su programavimo sistema. Jų deklaracijos pateikiamos *.h failais (tai vadinamieji įtraukti arba antraštės failai). Todėl, kaip minėta aukščiau, programos su bibliotekos funkcijomis pradžioje turėtų būti tokios eilutės:

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

Pavyzdžiui:

#įtraukti

Taip pat yra galimybių išplėsti ir kurti naujas bibliotekas su vartotojo programomis.

Visuotiniams kintamiesiems priskiriama fiksuota vieta atmintyje programos veikimo laikui. Vietiniai kintamieji saugomi krūvoje. Tarp jų yra atminties sritis dinaminiam paskirstymui.

Funkcijos malloc () ir free () naudojamos dinamiškai paskirstyti laisvą atmintį. Funkcija malloc () paskirsto atmintį, funkcija free () ją atlaisvina. Šių funkcijų prototipai saugomi stdlib.h antraštės faile ir atrodo taip:

void *malloc(dydis_t dydis);

void *free(void *p);

Funkcija malloc() grąžina void tipo rodyklę; norint tinkamai naudoti, funkcijos reikšmė turi būti konvertuota į atitinkamo tipo rodyklę. Sėkmės atveju funkcija grąžina žymeklį į pirmąjį laisvos atminties baitą. Jei neužtenka atminties, grąžinama reikšmė 0. Operacija sizeof() naudojama norint nustatyti kintamajam reikalingų baitų skaičių.

Šių funkcijų naudojimo pavyzdys:

#įtraukti

#įtraukti

p = (int *) malloc(100 * sizeof(int)); /* Paskirstykite atmintį 100

sveikieji skaičiai */

printf("Pritrūko atminties\n");

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

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

laisvas(p); /* Laisva atmintis */

Prieš naudodami malloc() grąžintą žymeklį, turite įsitikinti, kad yra pakankamai atminties (rodyklė nėra nulinė).

Pirminis procesorius

C išankstinis procesorius yra programa, kuri apdoroja kompiliatoriaus įvestį. Pirminis procesorius žiūri į šaltinio programą ir atlieka šiuos veiksmus: sujungia su ja duotus failus, atlieka pakaitalus, taip pat tvarko kompiliavimo sąlygas. Pirminis procesorius skirtas programos eilutėms, kurios prasideda simboliu #. Vienoje eilutėje leidžiama tik viena komanda (išankstinio procesoriaus direktyva).

direktyvą

#define identifikatoriaus pakeitimas

dėl to toliau pateiktame programos tekste pavadintas identifikatorius pakeičiamas pakeitimo tekstu (atkreipkite dėmesį, kad šios komandos pabaigoje nėra kabliataškio). Iš esmės ši direktyva įveda makrokomandos apibrėžimą (makrokomandą), kur "identifikatorius" yra makrokomandos apibrėžimo pavadinimas, o "pakeitimas" yra simbolių seka, kuria pirminis procesorius pakeičia nurodytą pavadinimą, kai jį randa programos tekste. Makrokomandos pavadinimas dažniausiai rašomas didžiosiomis raidėmis.

Apsvarstykite pavyzdžius:

Pirmoje eilutėje programa pakeičia identifikatorių MAX konstanta 25. Antroji leidžia tekste naudoti vietoj įžanginio riestinio skliausto (() žodį BEGIN.

Atkreipkite dėmesį, kad kadangi išankstinis procesorius netikrina simbolinių makrokomandų apibrėžimų pavadinimų ir konteksto, kuriame jie naudojami, suderinamumo, rekomenduojama tokius identifikatorius apibrėžti ne su #define direktyva, o su const raktiniu žodžiu su aiškiu tipu. nuoroda (tai labiau tinka C ++):

const int MAX = 25;

(tipo int galima praleisti, nes jis nustatytas pagal numatytuosius nustatymus).

Jei #define direktyva atrodo taip:

#define identifikatorius (identifikatorius, ..., identifikatorius) pakeitimas

ir tarp pirmojo identifikatoriaus ir pradinio skliausto nėra tarpo, tai yra makrokomandos pakeitimo apibrėžimas su argumentais. Pavyzdžiui, pasirodžius tokiai linijai kaip:

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

teiginys READ(y); yra traktuojamas taip pat kaip scanf("%d",&y);. Čia val yra argumentas, o makrokomandos pakeitimas atliekamas argumentu.

Jei pakeitime yra ilgi apibrėžimai, kurie tęsiasi kitoje eilutėje, kitos tęstinės eilutės pabaigoje dedamas simbolis \.

Makrokomandos apibrėžime galite įdėti objektus, atskirtus ## simboliais, pavyzdžiui:

#apibūdinti PR(x, y) x##y

Po to PR(a, 3) pakvies a3. Arba, pavyzdžiui, makrokomandos apibrėžimas

#apibūdinkite z(a, b, c, d) a(b##c##d)

pakeis z(sin, x, +, y) į sin(x+y).

# simbolis, esantis prieš makrokomandos argumentą, rodo, kad jis konvertuojamas į eilutę. Pavyzdžiui, po direktyvos

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

sekantį programos teksto fragmentą

konvertuojamas taip:

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

Apibūdinkime kitas pirminio procesoriaus direktyvas. #include direktyva buvo matyta anksčiau. Jis gali būti naudojamas dviem formomis:

#include "failo pavadinimas"

#įtraukti<имя файла>

Abiejų komandų poveikis yra į programą įtraukti failus nurodytu pavadinimu. Pirmasis įkelia failą iš dabartinio katalogo arba katalogo, nurodyto kaip priešdėlis. Antroji komanda ieško failo standartinėse programavimo sistemoje apibrėžtose vietose. Jei failas, kurio pavadinimas parašytas dvigubomis kabutėmis, nurodytame kataloge nerastas, paieška bus tęsiama pakatalogiuose, nurodytuose komandai #include<...>. #include direktyvos gali būti įdėtos viena į kitą.

Kita direktyvų grupė leidžia pasirinktinai kompiliuoti programos dalis. Šis procesas vadinamas sąlyginiu kompiliavimu. Į šią grupę įeina direktyvos #if, #else, #elif, #endif, #ifdef, #ifndef. Pagrindinė #if direktyvos forma yra:

#if pastovus_išraiškos teiginys_seka

Čia patikrinama pastovios išraiškos reikšmė. Jei teisinga, tada duota sakinių seka vykdoma, o jei klaidinga, tada ši teiginių seka praleidžiama.

#else direktyvos veiksmas yra panašus į komandos else veiksmą C kalba, pavyzdžiui:

#jei pastovi_išraiška

teiginio_seka_2

Čia, jei pastovi išraiška yra teisinga, tada vykdoma seka_operatorių_1, o jei klaidinga, vykdoma seka_operatorių_2.

#elif direktyva reiškia „else if“ tipo veiksmą. Pagrindinė jo naudojimo forma yra tokia:

#jei pastovi_išraiška

teiginio_seka

#elif pastovi_išraiška_1

teiginio_seka_1

#elif konstanta_išraiška_n

pareiškimų_n seka

Ši forma yra panaši į formos C kalbos konstrukciją: if...else if...else if...

direktyvą

#ifdef identifikatorius

nustato, ar nurodytas identifikatorius šiuo metu yra apibrėžtas, t.y. ar jis buvo įtrauktas į #define formos direktyvas. Žiūrėti eilutę

#ifndef identifikatorius

patikrina, ar nurodytas identifikatorius šiuo metu neapibrėžtas. Po bet kurios iš šių direktyvų gali būti nurodytas savavališkas skaičius teksto eilučių, galinčių turėti teiginį #else (negalima naudoti #elif) ir baigiant eilute #endif. Jei tikrinama sąlyga yra teisinga, visos eilutės tarp #else ir #endif yra ignoruojamos, o jei false, tada eilutės tarp check ir #else (jei nėra žodžio #else, tada #endif). #if ir #ifndef direktyvos gali būti įdėtos viena į kitą.

Žiūrėti direktyvą

#undef identifikatorius

lemia tai, kad nurodytas identifikatorius laikomas neapibrėžtu, t.y. nepakeičiamas.

Apsvarstykite pavyzdžius. Trys direktyvos yra šios:

patikrinkite, ar identifikatorius WRITE yra apibrėžtas (t.y. buvo #define WRITE... formos komanda), o jei taip, tai WRITE pavadinimas laikomas neapibrėžtu, t.y. nepakeičiamas.

direktyvas

#define RAŠYTI fprintf

patikrinkite, ar WRITE identifikatorius neapibrėžtas, o jei taip, tada vietoj fprintf pavadinimo nustatomas WRITE identifikatorius.

#error direktyva parašyta tokia forma:

#error error_message

Jei tai yra programos tekste, kompiliavimas sustoja ir ekrane rodomas klaidos pranešimas. Ši komanda dažniausiai naudojama derinimo etape. Atminkite, kad klaidos pranešimo nereikia rašyti dvigubose kabutėse.

#line direktyva skirta pakeisti _LINE_ ir _FILE_ kintamųjų reikšmes, apibrėžtas C programavimo sistemoje. Kintamajame _LINE_ yra šiuo metu vykdomos programos eilutės numeris. _FILE_ identifikatorius yra rodyklė į eilutę su kompiliuojamos programos pavadinimu. #line direktyva parašyta taip:

#eilutės numeris "failo pavadinimas"

Čia skaičius yra bet koks teigiamas sveikasis skaičius, kuris bus priskirtas kintamajam _LINE_, failo pavadinimas yra pasirenkamas parametras, kuris nepaiso _FILE_ reikšmės.

#pragma direktyva leidžia perduoti kai kurias instrukcijas kompiliatoriui. Pavyzdžiui, linija

rodo, kad C programoje yra surinkimo kalbos eilučių. Pavyzdžiui:

Apsvarstykite kai kuriuos visuotinius identifikatorius arba makrokomandų pavadinimus (makrokomandų apibrėžimų pavadinimus). Apibrėžiami penki tokie pavadinimai: _LINE_, _FILE_, _DATE_, _TIME_, _STDC_. Du iš jų (_LINE_ ir _FILE_) jau aprašyti aukščiau. Identifikatorius _DATE_ nurodo eilutę, kurioje saugoma data, kai šaltinio failas buvo išverstas į objekto kodą. Identifikatorius _TIME_ nurodo eilutę, kurioje saugomas laikas, kai šaltinio failas buvo išverstas į objekto kodą. _STDC_ makrokomandos reikšmė yra 1, jei naudojami standartiniai makrokomandų pavadinimai. Priešingu atveju šis kintamasis nebus apibrėžtas.

Pasitaiko, kad duomenys į programą perduodami iš komandinės eilutės ją iškvietus. Tokie duomenys vadinami komandinės eilutės argumentais. Tai atrodo taip, pavyzdžiui:

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

Tai iškviečia programas a.out (iš dabartinio katalogo) ir ls (iš to paties katalogo, nurodyto PATH aplinkos kintamajame). Pirmoji programa iš komandinės eilutės gauna vieną žodį - test.txt, antroji - du: -lt ir /home/peter/.

Jei programa parašyta C, tada jai paleidus valdymas iš karto perkeliamas į main() funkciją, todėl būtent ji gauna komandinės eilutės argumentus, priskirtus jos kintamiesiems parametrams.

Iki šiol apibrėžėme main() funkciją taip, tarsi ji neimtų jokių parametrų ir nieko negrąžintų. Tiesą sakant, C programoje bet kuri funkcija pagal numatytuosius nustatymus (jei niekas daugiau neapibrėžta) grąžina sveikąjį skaičių. Tai galima patikrinti. Jei kodą rašote taip:

main() ( printf("Sveiki \n") ; grąžinti 0; )

Tada kompiliavimo metu nebus įspėjimų ar klaidų. Tas pats nutiks, jei parašysime int main() . Tai įrodo, kad numatytoji funkcija grąžina sveikąjį skaičių, o ne nieko (tuščią). Nors tai, ką funkcija grąžina, visada gali būti „nepaisoma“, pavyzdžiui, voidmain() arba float main() .

Kai programa iškviečiama iš komandinės eilutės, jai visada perduodama duomenų pora:

1. sveikasis skaičius, žyminčių žodžių (tarpais atskirtų elementų) skaičių komandinėje eilutėje, kai iškviečiama,
2. žymeklis į eilučių masyvą, kur kiekviena eilutė yra vienas žodis iš komandinės eilutės.

Atkreipkite dėmesį, kad atsižvelgiama į patį programos pavadinimą. Pavyzdžiui, jei skambutis atrodo taip:

./a.out 12 2 tema

Tada pirmasis programos argumentas yra 4, o eilučių masyvas apibrėžiamas kaip ("./a.out", "12", "theme", "2").

Atkreipkite dėmesį į terminologiją, yra tik du programos argumentai (skaičius ir masyvas), bet tiek komandų eilutės argumentų, kiek norite. Komandinės eilutės argumentai yra "verčiami" į programos argumentus (į argumentus į main() funkciją).
Šie duomenys (skaičius ir rodyklė) perduodami programai net tada, kai ji tiesiog iškviečiama vardu, nieko jai neperduodant: ./a.out. Šiuo atveju pirmasis argumentas yra 1, o antrasis argumentas nurodo tik vienos eilutės masyvą (""./a.out").

Tai, kad duomenys perduodami programai, nereiškia, kad funkcija main() turėtų juos gauti. Jei funkcija main() apibrėžta be parametrų, tada komandinės eilutės argumentų pasiekti negalima. Nors niekas netrukdo jų siųsti. Jokia klaida neatsiras.

Norint gauti prieigą prie programai perduotų duomenų, jie turi būti priskirti kintamiesiems. Kadangi argumentai iš karto perduodami į main(), jo antraštė turėtų atrodyti taip:
pagrindinis (int n, char *arr)

Pirmajame kintamajame (n) yra žodžių skaičius, o antrajame kintamajame yra rodyklė į eilučių masyvą. Dažnai antrasis parametras rašomas kaip **arr . Tačiau tai tas pats. Prisiminkite, kad pačiame eilučių masyve kaip elementai yra rodyklės į eilutes. O funkcijoje perduodame žymeklį į pirmąjį masyvo elementą. Išeina taip, kad mes perduodame rodyklę rodyklei, t.y. **arr.

Pratimas
Parašykite tokią programą:

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

Jis spausdina žodžių skaičių komandinėje eilutėje, kai ji iškviečiama, ir kiekvieną žodį naujoje eilutėje. Iškvieskite jį be komandinės eilutės argumentų ir su argumentais.

Programoje naudojome kintamųjų parametrus argc ir argv. Įprasta naudoti tik tokius pavadinimus, tačiau iš tikrųjų jie gali būti bet kokie. Geriau laikytis šio standarto, kad jūsų programos būtų suprantamesnės ne tik jums, bet ir kitiems programuotojams.

Praktinė duomenų perdavimo programai svarba

Jei turite patirties su GNU/Linux komandų eilute, žinote, kad dauguma komandų turi jungiklius ir argumentus. Pavyzdžiui, peržiūrint katalogų turinį, kopijuojant, perkeliant, kaip argumentai nurodomi failų sistemos objektai, kuriuose vykdoma komanda. Jo įgyvendinimo ypatybės nustatomos naudojant raktus. Pavyzdžiui, komandoje

Cp -r ../les_1 ../les_101

cp yra komandos pavadinimas, -r yra jungiklis, o ../les_1 ir ../les_101 yra komandos argumentai.

Apskritai dažniausiai paleidžiant programas yra perduodami failų adresai ir programos vykdymo proceso „modifikatoriai“ (tai yra raktai).

Parašykime programą, kuri atidaro vartotojo komandinėje eilutėje nurodytus failus rašymui ar papildymui ir ten įrašo (prideda) tą pačią informaciją, kurią vartotojas įveda iš klaviatūros vykdydamas programą:

#įtraukti #įtraukti pagrindinis (int argc, char ** argv) ( int i, ch; FILE * f[5] ; if (argc< 3 || argc >7 ) ( deda ( "Neteisingas parametrų skaičius") ; grąžinti 1; ) if (strcmp (argv[ 1 ] , "-w" ) != 0 && strcmp (argv[ 1 ] , "-a" ) != 0 ) ( įdeda ( "Pirmasis parametras gali būti -w arba -a") ; grąžinimas 2; ) (i= 0 ; i< argc- 2 ; i++ ) { f[ i] = fopen (argv[ i+ 2 ] , argv[ 1 ] + 1 ) ; if (f[ i] == NULL) { printf ("Failo %s negalima atidaryti\n", argv[ i+ 2 ] ) ; grąžinti 3; ) ) while ((ch = getchar () ) != EOF), kai (i= 0 ; i< argc- 2 ; i++ ) putc (ch, f[ i] ) ; for (i= 0 ; i < argc- 2 ; i++ ) fclose (f[ i] ) ; return 0 ; }

Kodo paaiškinimai:

1. Sukuriamas penkių failų rodyklių masyvas. Todėl vienu metu galima atidaryti ne daugiau kaip penkis failus. Pirmojo failo failo rodyklė bus saugoma masyvo elemente f, antrojo – f ir pan.
2. Patikrintas komandinės eilutės argumentų skaičius. Jų turi būti bent trys, nes. pirmasis yra programos pavadinimas, antrasis yra failo atidarymo režimas, trečiasis yra pirmasis arba vienintelis failas, į kurį reikia įrašyti. Kadangi programa leidžia atidaryti tik penkis failus, bendras komandinės eilutės argumentų skaičius negali viršyti septynių. Todėl, jei argumentų skaičius yra mažesnis nei 3 arba daugiau nei 7, programa baigiasi, nes Teiginys „Return“ priverčia funkciją išjungti, net jei po jo yra daugiau kodo. Funkcijos grąžinimo reikšmę, kuri nėra lygi 0, pirminis procesas gali interpretuoti kaip pranešimą, kad programa nutraukė klaidą.
3. Patikrintas antrojo komandinės eilutės argumento teisingumas. Jei tai nėra nei „-w“, nei „-a“, tada sąlyginė išraiška antroje if grąžina 1 (tiesa). Funkcija strcmp() leidžia palyginti eilutes ir grąžina 0, jei jos yra lygios.
4. Ciklas for atidaro failus nurodytais adresais, kurie prasideda nuo trečiojo argv masyvo elemento. Štai kodėl prie i pridedamas 2, kad būtų gauti argv masyvo elementai, pradedant nuo trečiojo. Išraiška argc-2 nurodo perduotų failų pavadinimų skaičių; nes argc saugo bendrą komandinės eilutės argumentų skaičių, iš kurių pirmieji du nėra failų pavadinimai.
5. Išraiška argv+1 leidžia „iškirpti“ eilutę „w“ (arba „a“) ​​iš eilutės „-w“ (arba „-a“), nes argv iš esmės yra rodyklė į pirmąjį eilutės elementą. Pridėję vieną prie žymeklio, perkeliame jį į kitą masyvo elementą.
6. Jei failo atidaryti nepavyksta, funkcija fopen() grąžina NULL. Tokiu atveju programa baigiasi.
7. Kiekvienas iš klaviatūros vartotojo įvestas simbolis įrašomas į visus atidarytus failus.
8. Pabaigoje failai uždaromi.