C-argumentit. Valinnaiset ja nimetyt argumentit. Tietojen siirtämisen käytännön merkitys ohjelmaan

Huomaa, että tällä main():n versiolla ei ole parametreja. Monet ohjelmat vaativat kuitenkin jonkin verran syöttöä. Oletetaan esimerkiksi, että kirjoitat Picture-nimistä ohjelmaa, joka ottaa kuvan syötteeksi ja tekee sitten pikkukuvan (pienen version kuvasta) siitä kuvasta. Miten Kuva-toiminto tietää, mikä kuva hyväksytään ja käsitellään? Käyttäjän on kerrottava ohjelmalle, mikä tiedosto avataan. Tämä voidaan tehdä seuraavasti:

// Ohjelma: Picture #include #sisältää int main() ( std::cout<< "Enter name of image-file to create a thumbnail for: "; std::string filename; std::cin >>tiedostonimi; // Avaa kuvatiedosto // Luo pikkukuva // Näytä pikkukuva)

Tässä on kuitenkin mahdollinen ongelma. Aina kun ohjelma käynnistetään, se odottaa käyttäjän syötteitä. Tämä ei ole ongelma, jos suoritat ohjelman manuaalisesti komentorivi kerran yhdelle kuvalle. Mutta tämä on jo ongelma, jos haluat työskennellä iso määrä tiedostot tai jotta toinen ohjelma voi suorittaa tämän ohjelman.

Katsotaanpa tätä tarkemmin.

Haluat esimerkiksi luoda pikkukuvat kaikille kuvatiedostoille, jotka sijaitsevat tietyssä hakemistossa. Kuinka tehdä se? Voit suorittaa tämän ohjelman niin monta kertaa kuin hakemistossa on kuvia syöttämällä kunkin tiedostonimen manuaalisesti. Jos kuvia on kuitenkin satoja, tämä lähestymistapa ei ole lievästi sanoen kovin tehokas! Ratkaisu tähän on kirjoittaa ohjelma, joka toistaa jokaisen hakemiston tiedostonimen läpi kutsuen jokaisen tiedoston Picture joka kerta.

Harkitse nyt tapausta, jossa sinulla on verkkosivusto ja haluat sen luovan pikkukuvan aina, kun käyttäjä lataa kuvan sivustolle. Tämä ohjelma ei voi hyväksyä syötettä Internetistä ja seuraava looginen kysymys: "Kuinka sitten syötetään tiedoston nimi?" Ratkaisu on olemassa: web-palvelin kutsuu Kuva-toiminnon automaattisesti aina, kun tiedosto ladataan.

Molemmissa tapauksissa meidän täytyy ulkoinen ohjelma välitti tiedostonimen syötteeksi ohjelmallemme sen käynnistyessä sen sijaan, että itse kuva olisi odottanut käyttäjän kirjoittavan tiedostonimen manuaalisesti.

Komentorivi-argumentit ovat valinnaisia ​​merkkijonoargumentteja, jotka käyttöjärjestelmä välittää ohjelmalle sen käynnistyessä. Ohjelma voi käyttää niitä syötteenä tai jättää ne huomiotta. Aivan kuten yhden funktion parametrit tarjoavat tietoja toisen funktion parametreille, komentoriviargumentit antavat ihmisille tai ohjelmille mahdollisuuden syöttää ohjelmaan.

Komentoriviargumenttien välittäminen

Suoritettavat ohjelmat voidaan käynnistää komentorivillä kutsun kautta. Esimerkiksi juosta suoritettava tiedosto MyProgram, joka sijaitsee C-aseman juurihakemistossa Windows-käyttöjärjestelmässä, sinun on syötettävä:

C:\>MyProgram

Jos haluat välittää komentoriviargumentteja MyProgramille, sinun on lueteltava ne suoritettavan tiedoston nimen jälkeen:

C:\>MyProgram SomeContent.txt

Nyt kun MyProgram on käynnissä, SomeContent.txt tarjotaan komentoriviargumenttina. Ohjelmalla voi olla useita välilyönnillä erotettuja komentoriviargumentteja:

C:\>MyProgram SomeContent.txt SomeOtherContent.txt

Tämä toimii myös muiden kanssa käyttöjärjestelmät esim. Linuxilla (vaikka hakemistorakenne on erilainen kuin Windowsin hakemistorakenne).

Jos käytät ohjelmaa IDE:stä, IDE:n on tarjottava tapa komentoriviargumenttien syöttämiseen.

Käyttäjille Visual Studio : Klikkaus oikealla painikkeella siirrä hiiren osoitin haluamasi projektin päälle Solution Explorerissa ja valitse sitten "Ominaisuudet":

Sitten "Määritysominaisuudet > Virheenkorjaus". Oikeassa paneelissa on viiva "Joukun argumentit". Voit kirjoittaa komentoriviargumentteja tähän, ja ne välitetään automaattisesti ohjelmallesi sen käynnistyessä:

Koodi::Estää käyttäjät täytyy valita "Projekti > Aseta ohjelman argumentit":

Komentoriviargumenttien käyttäminen

Nyt kun tiedät kuinka komentoriviargumentit välitetään ohjelmalle, seuraava vaihe on käyttää niitä ohjelman sisältä. Tätä varten käytetään main()-funktion eri muotoa, joka ottaa kaksi argumenttia (argc ja argv) seuraavasti:

int main(int argc, char *argv)

Voit myös nähdä tämän vaihtoehdon:

int main(int argc, char** argv)

int main(int argc, char * * argv)

Vaikka molemmat vaihtoehdot ovat pohjimmiltaan identtisiä, on suositeltavaa käyttää ensimmäistä, koska se on intuitiivisempi.

argc (eng. " arg ument c ount" = "argumenttien lukumäärä") on kokonaislukuparametri, joka sisältää ohjelmalle välitettyjen argumenttien määrän. argc on aina vähintään 1, koska ensimmäinen argumentti on aina itse ohjelman nimi. Jokainen käyttäjän antama komentoriviargumentti saa argc-arvon kasvamaan yhdellä.

argv (englanti " arg ument v alues" = "argumenttiarvot") on paikka, johon todelliset argumenttiarvot tallennetaan. Vaikka argv-ilmoitus näyttää hieman pelottavalta, se on vain joukko. Tämän taulukon pituus on argc.

Kirjoita lyhyt ohjelma nimeltä MyArguments, joka tulostaa kaikkien komentoriviargumenttien arvot:

// Ohjelma: MyArguments #include int main(int argc, char *argv) ( std::cout<< "There are " << argc << " arguments:\n"; // Перебираем каждый аргумент и выводим его порядковый номер и значение for (int count=0; count < argc; ++count) std::cout << count << " " << argv << "\n"; return 0; }

// Ohjelma: MyArguments #sisältää int main (int argc, char * argv) // Selaa jokaisen argumentin läpi ja tulosta sen sarjanumero ja arvo for (int count = 0 ; count< argc ; ++ count ) std::cout<< count << " " << argv [ count ] << "\n" ; paluu 0;

Nyt kun kutsut MyArgumentsia komentoriviargumenteilla SomeContent.txt ja 200 , tulos on seuraava:

On 3 argumenttia:
0 C:\Omat argumentit
1SomeContent.txt
2 200

Parametri 0 on nykyisen ohjelman polku ja nimi. Parametrit 1 ja 2 tässä ovat komentoriviargumentit, jotka välitimme.

Numeeristen argumenttien käsittely

Komentoriviargumentit välitetään aina merkkijonoina, vaikka annettu arvo olisi numeerinen. Jos haluat käyttää komentoriviargumenttia numerona, sinun on muunnettava se merkkijonosta numeroksi. Valitettavasti C++ tekee tästä hieman monimutkaisemman kuin sen pitää olla:

#sisältää #sisältää #sisältää // std::stringstreamille #include // for exit() int main(int argc, char *argv) ( if (argc<= 1) { // В некоторых операционных системах, argv может быть просто пустой строкой, без имени программы // Обрабатываем случай, когда argv может быть пустым или не пустым if (argv) std::cout << "Usage: " << argv << " " << "\n"; else std::cout << "Usage: " << "\n"; exit(1); } std::stringstream convert(argv); // создаём переменную stringstream с именем convert, инициализируя её значением argv int myint; if (!(convert >> myint)) // suorita muunnos myint = 0; // jos muunnos epäonnistuu, aseta myint oletusarvoon std::cout<< "Got integer: " << myint << "\n"; return 0; }

#sisältää #sisältää #sisältää // std::stringstreamille #sisältää // poistumiselle() int main (int argc, char * argv) jos (argc<= 1 ) // Joissakin käyttöjärjestelmissä argv voi olla yksinkertaisesti tyhjä merkkijono ilman ohjelman nimeä // Käsittele tapausta, jossa argv voi olla tyhjä tai ei tyhjä jos (argv [ 0 ] ) std::cout<< "Usage: " << argv [ 0 ] << " " << "\n" ; muu std::cout<< "Käyttö: " << "\n" ; poistu(1);

Voit välittää joitain argumentteja C-ohjelmille. Kun main():ta kutsutaan laskutoimituksen alussa, sille välitetään kolme parametria. Ensimmäinen niistä määrittää komentoargumenttien määrän ohjelmaa käytettäessä. Toinen on joukko osoittimia merkkijonoihin, jotka sisältävät nämä argumentit (yksi argumentti riviä kohden). Kolmas on myös joukko osoittimia merkkijonoihin; sitä käytetään käyttöjärjestelmän parametrien (ympäristömuuttujien) käyttämiseen.

Mikä tahansa tällainen rivi esitetään seuraavasti:

muuttuja = arvo\0

Viimeinen rivi löytyy kahdesta nollasta.

Nimetään main()-funktion argumentit vastaavasti: argc, argv ja env (muut nimet ovat mahdollisia). Sitten seuraavat kuvaukset ovat hyväksyttäviä:

main(int argc, char *argv)

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

Oletetaan, että asemassa A: on jokin ohjelma prog.exe. Käsitellään asiaa seuraavasti:

A:\>prog.exe tiedosto1 tiedosto2 tiedosto3

Sitten argv on osoitin riville A:\prog.exe, argv on osoitin riville file1 jne. Ensimmäiseen varsinaiseen argumenttiin argv viittaa ja viimeiseen argv. Jos argc=1, komentorivillä ei ole parametreja ohjelman nimen jälkeen. Esimerkissämme argc=4.

Rekursio

Rekursio on kutsumenetelmä, jossa funktio viittaa itseensä.

Tärkeä seikka rekursiivista ohjelmaa laadittaessa on tulosteen organisointi. Tässä on helppo tehdä virhe, että funktio kutsuu itseään peräkkäin loputtomiin. Siksi rekursiivisen prosessin tulee askel askeleelta yksinkertaistaa ongelmaa niin, että lopulta sille ilmestyy ei-rekursiivinen ratkaisu. Rekursion käyttö ei ole aina toivottavaa, koska se voi johtaa pinon ylivuotoon.

Kirjaston toiminnot

Ohjelmointijärjestelmissä usein esiintyvien ongelmien ratkaisurutiinit yhdistetään kirjastoiksi. Tällaisia ​​tehtäviä ovat: matemaattisten funktioiden laskenta, tiedon syöttö/tulostus, merkkijonojen käsittely, vuorovaikutus käyttöjärjestelmän työkalujen kanssa jne. Kirjaston rutiinien käyttö vapauttaa käyttäjän tarpeesta kehittää sopivia työkaluja ja tarjoaa hänelle lisäpalveluita. Kirjastoihin sisältyvät toiminnot toimitetaan ohjelmointijärjestelmän mukana. Niiden ilmoitukset annetaan *.h-tiedostoina (nämä ovat ns. include- tai header-tiedostoja). Siksi, kuten edellä mainittiin, kirjastotoimintoja sisältävän ohjelman alussa tulisi olla rivejä, kuten:

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

Esimerkiksi:

#sisältää

Siellä on myös mahdollisuudet laajentaa ja luoda uusia kirjastoja käyttäjäohjelmilla.

Globaalimuuttujille on varattu kiinteä paikka muistissa koko ohjelman ajaksi. Paikalliset muuttujat tallennetaan pinoon. Niiden välissä on muistialue dynaamista allokointia varten.

Malloc()- ja free()-funktioita käytetään vapaan muistin dynaamiseen varaamiseen. Malloc()-funktio varaa muistia, free()-funktio vapauttaa sen. Näiden funktioiden prototyypit on tallennettu stdlib.h-otsikkotiedostoon ja ne näyttävät tältä:

void *malloc(koko_t koko);

void *free(void *p);

Malloc()-funktio palauttaa void-osoittimen; Oikeaa käyttöä varten funktion arvo on muutettava sopivan tyypin osoittimeksi. Jos onnistuu, funktio palauttaa osoittimen koon kokoisen vapaan muistin ensimmäiseen tavuun. Jos muistia ei ole tarpeeksi, palautetaan arvo 0. Määritä muuttujan tarvittavien tavujen määrä käyttämällä sizeof()-operaatiota.

Esimerkki näiden toimintojen käytöstä:

#sisältää

#sisältää

p = (int *) malloc(100 * sizeof(int)); /* Varaa muistia 100:lle

kokonaislukuja */

printf("Muisti ei riitä\n");

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

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

vapaa(p); /* Vapaa muisti */

Ennen kuin käytät malloc(:n) palauttamaa osoitinta, sinun on varmistettava, että muistia on tarpeeksi (osoitin ei ole tyhjä).

Esiprosessori

C-esiprosessori on ohjelma, joka käsittelee kääntäjän syötteen. Esiprosessori tarkastelee lähdeohjelmaa ja suorittaa seuraavat toiminnot: yhdistää määritetyt tiedostot siihen, suorittaa korvauksia ja myös ohjaa käännösehtoja. Symbolilla # alkavat ohjelmarivit on tarkoitettu esiprosessorille. Yhdelle riville voidaan kirjoittaa vain yksi komento (esikäsittelyohje).

Direktiivi

#määrittää tunnisteen korvaaminen

aiheuttaa sen, että nimetty tunniste korvataan seuraavassa ohjelman tekstissä korvaustekstillä (huomaa puolipisteen puuttuminen tämän komennon lopussa). Pohjimmiltaan tämä direktiivi ottaa käyttöön makromääritelmän, jossa "tunniste" on makromääritelmän nimi ja "korvaus" on merkkijono, jolla esiprosessori korvaa määritellyn nimen, kun se löytää sen ohjelman tekstistä. Makromääritelmän nimi on tapana kirjoittaa isoilla kirjaimilla.

Katsotaanpa esimerkkejä:

Ensimmäinen rivi saa ohjelman korvaamaan tunnisteen MAX vakiolla 25. Toisella rivillä voit käyttää tekstissä sanaa BEGIN avaavan aaltosulkeen (() sijaan.

Huomaa, että koska esiprosessori ei tarkista makromääritelmien symbolisten nimien ja niiden käyttökontekstin välistä yhteensopivuutta, on suositeltavaa määrittää tällaisia ​​tunnisteita ei #define-direktiivin avulla, vaan käyttämällä const-avainsanaa, jossa on selkeä ilmaisu tyyppi (tämä pätee enemmän C++:aan):

const int MAX = 25;

(int-tyyppi voidaan jättää pois, koska se on oletusarvo).

Jos #define-direktiivi näyttää tältä:

#määritä tunniste(tunniste, ..., tunniste) -korvaus

ja ensimmäisen tunnisteen ja avaussulkujen välillä ei ole välilyöntiä, tämä on makrokorvauksen määritelmä argumenteilla. Esimerkiksi seuraavan rivin jälkeen:

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

lause READ(y); käsitellään samalla tavalla kuin scanf("%d",&y);. Tässä val on argumentti ja makrokorvaus argumentilla suoritetaan.

Jos korvauksessa on pitkiä määritelmiä, jotka jatkuvat seuraavalla rivillä, merkki \ sijoitetaan seuraavan jatkorivin loppuun.

Voit lisätä ##-merkillä erotettuja objekteja makromääritykseen, esimerkiksi:

#määritä PR(x, y) x##y

Tämän jälkeen PR(a, 3) kutsuu substituutiota a3. Tai esimerkiksi makromäärittely

#määritä z(a, b, c, d) a(b##c##d)

tuloksena on z(sin, x, +, y) korvaaminen sin(x+y).

Makroargumentin eteen asetettu #-symboli osoittaa, että se muunnetaan merkkijonoksi. Esimerkiksi direktiivin jälkeen

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

seuraava fragmentti ohjelman tekstistä

muunnetaan näin:

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

Kuvataan muita esikäsittelyohjeita. #include-direktiivi on nähty ennenkin. Sitä voidaan käyttää kahdessa muodossa:

#include "tiedostonimi"

#sisältää<имя файла>

Molempien komentojen tehtävänä on sisällyttää ohjelmaan tiedostot määritetyllä nimellä. Ensimmäinen niistä lataa tiedoston nykyisestä hakemistosta tai etuliitteeksi määritetystä hakemistosta. Toinen komento etsii tiedostoa ohjelmointijärjestelmässä määritellyistä vakiopaikoista. Jos tiedostoa, jonka nimi on kirjoitettu lainausmerkeillä, ei löydy määritetystä hakemistosta, haku jatkuu #include komennolla määritetyissä alihakemistoissa<...>. #include-ohjeet voidaan upottaa toistensa sisään.

Seuraavan ryhmän ohjeiden avulla voit valikoivasti kääntää ohjelman osia. Tätä prosessia kutsutaan ehdolliseksi kokoamiseksi. Tämä ryhmä sisältää käskyt #if, #else, #elif, #endif, #ifdef, #ifndef. #if-direktiivin kirjoittamisen perusmuoto näyttää tältä:

#if vakio_lausekesekvenssi lauseiden_sekvenssi

Tässä tarkistetaan vakiolausekkeen arvo. Jos se on tosi, määritetty lausesarja suoritetaan, ja jos se on epätosi, tämä lausesarja ohitetaan.

#else-direktiivin toiminta on samanlainen kuin C-kielen else-komennon toiminta, esimerkiksi:

#jos vakio_lauseke

lauseke_sekvenssi_2

Tässä, jos vakiolauseke on tosi, suoritetaan operaattorijono_1, ja jos epätosi, operaattorisekvenssi_2 suoritetaan.

#elif-direktiivi tarkoittaa "else if" -toimintoa. Sen käytön perusmuoto on:

#jos vakio_lauseke

lauseke_sekvenssi

#elif vakio_lauseke_1

lauseke_sekvenssi_1

#elif vakio_lauseke_n

lausekkeiden_jono_n

Tämä muoto on samanlainen kuin C-kielen konstruktio: if...else if...else if...

Direktiivi

#ifdef-tunniste

määrittää, onko määritetty tunniste sillä hetkellä määritelty, ts. sisällytettiinkö se direktiiveihin, kuten #define. Lomakkeen merkkijono

#ifndef-tunniste

tarkistaa, onko määritetty tunniste tällä hetkellä määrittelemätön. Mitä tahansa näistä käskyistä voi seurata mielivaltainen määrä tekstirivejä, jotka voivat sisältää #else-käskyn (#elifiä ei voida käyttää) ja joka päättyy riviin #endif. Jos tarkistettava ehto on tosi, kaikki rivit #else ja #endif ohitetaan, ja jos epätosi, niin tarkastuksen ja #else väliset rivit (jos sanaa #else ei ole, niin #endif). #if- ja #ifndef-direktiivit voidaan upottaa toistensa sisään.

Katso ohje

#undef tunniste

saa määritettyä tunnistetta määrittelemättömäksi, ts. ei vaihdeta.

Katsotaanpa esimerkkejä. Seuraavat kolme direktiiviä:

tarkista onko WRITE-tunniste määritelty (eli onko olemassa komento kuten #define WRITE...), ja jos on, niin WRITE-nimeä aletaan pitää määrittelemättömänä, ts. ei vaihdeta.

direktiivit

#define KIRJOITA fprintf

tarkistaa, onko WRITE-tunniste määrittelemätön, ja jos on, määritetään WRITE-tunniste fprintf-nimen sijaan.

#error-ohje on kirjoitettu seuraavassa muodossa:

#error error_message

Jos se esiintyy ohjelman tekstissä, kääntäminen pysähtyy ja näyttöön tulee virheilmoitus. Tätä komentoa käytetään pääasiassa virheenkorjausvaiheessa. Huomaa, että virheilmoitusta ei tarvitse laittaa lainausmerkkeihin.

#line-käsky on tarkoitettu muuttamaan C-ohjelmointijärjestelmässä määritettyjen muuttujien _LINE_ ja _FILE_ arvoja. _LINE_-muuttuja sisältää parhaillaan suoritettavan ohjelman rivinumeron. _FILE_-tunniste on osoitin merkkijonoon, jossa on käännettävän ohjelman nimi. #line-käsky on kirjoitettu seuraavasti:

#rivinumero "tiedoston_nimi"

Tässä numero on mikä tahansa positiivinen kokonaisluku, joka liitetään muuttujaan _LINE_, tiedoston_nimi on valinnainen parametri, joka ohittaa arvon _FILE_.

#pragma-direktiivin avulla voit välittää joitain ohjeita kääntäjälle. Esimerkiksi linja

osoittaa, että C-ohjelma sisältää kokoonpanokielen merkkijonoja. Esimerkiksi:

Katsotaanpa joitain yleisiä tunnisteita tai makronimiä (makromääritelmien nimiä). Viisi tällaista nimeä on määritelty: _LINE_, _FILE_, _DATE_, _TIME_, _STDC_. Kaksi niistä (_LINE_ ja _FILE_) on jo kuvattu yllä. Tunniste _DATE_ määrittää merkkijonon, joka tallentaa päivämäärän, jolloin lähdetiedosto käännettiin objektikoodiksi. Tunniste _TIME_ määrittää merkkijonon, joka tallentaa ajan, jolloin lähdetiedosto käännettiin objektikoodiksi. _STDC_-makron arvo on 1, jos käytetään vakiomääritettyjä makronimiä. Muuten tätä muuttujaa ei määritellä.

Kun luot konsolisovellusta C++-ohjelmointikielellä, luodaan automaattisesti tämän kaltainen rivi:

Int main(int argc, char* argv) // main()-funktion parametrit

Tämä rivi on pääfunktion main() otsikko, parametrit argс ja argv ilmoitetaan suluissa. Joten jos ajat ohjelmaa komentorivin kautta, on mahdollista siirtää jotain tietoa tähän ohjelmaan, tätä varten on parametrit argc ja argv. Argc-parametrilla on int-tietotyyppi, ja se sisältää pääfunktiolle välitettyjen parametrien määrän. Lisäksi argc on aina vähintään 1, vaikka emme välitä mitään tietoa, koska ensimmäinen parametri on funktion nimi. Argv-parametri on joukko osoittimia merkkijonoihin. Vain merkkijonotiedot voidaan siirtää komentorivin kautta. Osoittimet ja merkkijonot ovat kaksi suurta aihetta, joille on luotu erilliset osiot. Joten kaikki tiedot lähetetään argv-parametrin kautta. Kehitetään ohjelma, jonka suoritamme Windowsin komentorivin kautta ja välitämme sille tietoja.

// argc_argv.cpp: Määrittää konsolisovelluksen aloituspisteen. #include "stdafx.h" #include käyttäen nimiavaruutta std; int main(int argc, char* argv) ( if (argc ><< argv<

// koodi Code::Blocks

// Dev-C++-koodi

// argc_argv.cpp: Määrittää konsolisovelluksen aloituspisteen. #sisältää käyttäen nimiavaruutta std; int main(int argc, char* argv) ( jos (argc > 1) // jos välitämme argumentteja, niin argc on suurempi kuin 1 (riippuen argumenttien määrästä) ( cout<< argv<

Kun olemme tehneet ohjelman virheenkorjauksen, avaa Windowsin komentorivi ja vedä ohjelmamme suoritettava tiedosto komentoriviikkunaan. Ohjelman koko polku näkyy komentorivillä (mutta voit syöttää ohjelman polun manuaalisesti ), jonka jälkeen voit napsauttaa TULLA SISÄÄN ja ohjelma käynnistyy (katso kuva 1).

Kuva 1 - Päätoimintoparametrit

Koska me yksinkertaisesti suoritimme ohjelman emmekä välittäneet sille argumentteja, näkyviin tuli Not arguments -viesti. Kuvassa 2 näkyy saman ohjelman käynnistäminen komentorivin kautta, mutta välitetään Open-argumentti.

Kuva 2 - Päätoimintoparametrit

Argumentti on sana Open, kuten kuvasta voidaan nähdä, tämä sana ilmestyi näytölle. Voit välittää useita parametreja kerralla erottamalla ne pilkulla. Jos sinun on välitettävä useista sanoista koostuva parametri, ne on suljettava lainausmerkeillä, jolloin näitä sanoja pidetään yhtenä parametrina. Esimerkiksi kuvassa näkyy ohjelman käynnistäminen ja välitetään sille kahdesta sanasta koostuva argumentti - Se toimii.

Kuva 3 - Päätoimintoparametrit

Ja jos lainausmerkit poistetaan. Sitten näemme vain sanan Se. Jos et aio välittää tietoja ohjelmaa suoritettaessa, voit poistaa argumentit main()-funktiosta ja voit myös muuttaa näiden argumenttien nimiä. Joskus argc- ja argv-parametreihin tulee muutoksia, mutta tämä kaikki riippuu luotavan sovelluksen tyypistä tai kehitysympäristöstä.

Joskus ohjelmaa käynnistettäessä on hyödyllistä välittää sille tietoja. Tyypillisesti nämä tiedot välitetään main():lle komentoriviargumenttien kautta. Komentorivi-argumentti on tieto, joka syötetään käyttöjärjestelmän komentoriville ohjelman nimen jälkeen. Esimerkiksi aloittaaksesi ohjelman kääntämisen, sinun on kirjoitettava komentoriville kehotteen jälkeen jotain seuraavan kaltaista:

Kopio ohjelman_nimi

ohjelman_nimi on komentoriviargumentti; se määrittää käännettävän ohjelman nimen.

Komentoriviargumenttien hyväksymiseen käytetään kahta erityistä sisäänrakennettua argumenttia: argc ja argv. Argc-parametri sisältää komentorivillä olevien argumenttien määrän ja on kokonaisluku, ja se on aina vähintään 1, koska ensimmäinen argumentti on ohjelman nimi. Ja argv-parametri on osoitin merkkijonoihin osoittavien osoittimien joukkoon. Tässä taulukossa jokainen elementti osoittaa komentorivin argumenttiin. Kaikki komentorivin argumentit ovat merkkijonoja, joten minkä tahansa numeron muuntaminen haluttuun binäärimuotoon on annettava ohjelmassa sitä kehitettäessä.

Tässä on yksinkertainen esimerkki komentoriviargumentin käyttämisestä. Sana Hello ja nimesi näkyvät näytöllä, joka on määritettävä komentoriviargumenttina.

#sisältää #sisältää int main(int argc, char *argv) ( if(argc!=2) ( printf("Unohdit kirjoittaa nimesi.\n"); exit(1); ) printf("Hei %s", argv) ; palauta 0;)

Jos kutsuit tätä ohjelmaa nimellä (nimi) ja nimesi on Tom, ohjelman suorittamiseksi sinun tulee kirjoittaa nimi Tom komentoriville. Ohjelman suorittamisen seurauksena näytölle tulee viesti Hei, Tom.

Monissa ympäristöissä kaikki komentorivin argumentit on erotettava välilyönnillä tai sarkaimella. Pilkuja, puolipisteitä ja vastaavia merkkejä ei pidetä erottimina. Esimerkiksi,

Juokse Spot, juokse

koostuu kolmesta merkkijonosta, while

Eric, Rick, Fred

edustaa yhtä merkkijonoa - pilkkuja ei yleensä pidetä erottimina.

Jos merkkijono sisältää välilyöntejä, voit sulkea merkkijonon lainausmerkkeihin joissakin ympäristöissä, jotta se ei tuota useita argumentteja. Tämän seurauksena koko merkkijonoa pidetään yhtenä argumenttina. Saat lisätietoja siitä, kuinka käyttöjärjestelmäsi määrittää komentoriviparametrit, tutustumalla käyttöjärjestelmäsi asiakirjoihin.

On erittäin tärkeää ilmoittaa argv oikein. Näin se tehdään useimmiten:

Char *argv;

Tyhjät hakasulkeet osoittavat, että taulukon pituus on rajoittamaton. Yksittäisiin argumentteihin pääsee nyt indeksoimalla argv-taulukko. Esimerkiksi argv osoittaa ensimmäiseen merkkijonoon, joka on aina ohjelman nimi; argv viittaa ensimmäiseen argumenttiin ja niin edelleen.

Toinen pieni esimerkki komentoriviargumenttien käytöstä on seuraava ohjelma, lähtölaskenta. Tämä ohjelma laskee taaksepäin, alkaen jostakin arvosta (määritetty komentorivillä) ja piippaa kun se saavuttaa 0:n. Huomaa, että ensimmäinen argumentti, joka sisältää aloitusarvon, muunnetaan kokonaislukuarvoksi käyttämällä standardia atoi-funktiota (). Jos toinen komentorivin argumentti (ja jos pidämme ohjelman nimeä argumenttina, niin kolmas) on rivi "näyttö" (näyttö), laskennan tulos (käänteisessä järjestyksessä) näytetään näytöllä.

/* Ohjelma laskemiseen käänteisessä järjestyksessä. */ #sisältää #sisältää #sisältää #sisältää int main(int argc, char *argv) ( int disp, count; if(argc<2) { printf("В командной строке необходимо ввести число, с которого\n"); printf("начинается отсчет. Попробуйте снова.\n"); exit(1); } if(argc==3 && !strcmp(argv, "display")) disp = 1; else disp = 0; for(count=atoi(argv); count; --count) if(disp) printf("%d\n", count); putchar("\a"); /* здесь подается звуковой сигнал */ printf("Счет закончен"); return 0; }

Huomaa, että jos komentorivin argumentteja ei ole määritetty, näyttöön tulee virhesanoma. Ohjelmat, jotka käyttävät komentoriviargumentteja, tekevät usein seuraavaa: Kun käyttäjä suorittaa nämä ohjelmat syöttämättä vaadittuja tietoja, ne näyttävät ohjeet argumenttien oikeasta määrittämisestä.

Jos haluat käyttää jonkin komentoriviargumentin yksittäistä merkkiä, kirjoita toinen indeksi kohtaan argv. Esimerkiksi seuraava ohjelma tulostaa merkki merkiltä kaikki argumentit, joilla sitä kutsuttiin:

#sisältää int main(int argc, char *argv) ( int t, i; for(t=0; t

Muista, että argv:n ensimmäinen indeksi tarjoaa pääsyn merkkijonoon ja toinen indeksi antaa pääsyn sen yksittäisiin merkkeihin.

Tyypillisesti argc:tä ja argv:tä käytetään antamaan ohjelmalle alkukomennot, joita se tarvitsee käynnistyessään. Esimerkiksi komentoriviargumentit määrittävät usein tietoja, kuten tiedostonimen, vaihtoehdon tai vaihtoehtoisen toiminnan. Komentoriviargumenttien käyttäminen antaa ohjelmallesi "ammattimaisen ulkonäön" ja helpottaa sen käyttöä erätiedostoissa.

Nimet argc ja argv ovat perinteisiä, mutta eivät pakollisia. Voit kutsua näitä kahta parametria main()-funktiossa miten haluat. Lisäksi jotkin kääntäjät voivat tukea main(:lle) lisäargumentteja, joten muista tarkistaa kääntäjän dokumentaatio.

Kun ohjelma ei vaadi komentoriviparametreja, on yleisintä ilmoittaa main()-funktiolla eksplisiittisesti ilman parametreja. Tässä tapauksessa avainsanaa void käytetään tämän funktion parametriluettelossa.

Valinnaiset ja nimetyt argumentit

Valinnaiset argumentit

C# 4.0 esittelee uuden ominaisuuden, joka helpottaa argumenttien määrittämistä metodia kutsuttaessa. Tätä lääkettä kutsutaan valinnaisia ​​argumentteja ja voit määrittää oletusarvon menetelmäparametrille. Tätä arvoa käytetään oletuksena, jos vastaavaa argumenttia ei ole määritetty parametrille menetelmää kutsuttaessa. Siksi ei ole tarpeen esittää argumenttia tällaiselle parametrille. Valinnaiset argumentit helpottavat sellaisten menetelmien kutsumista, joissa oletusargumentteja käytetään joihinkin parametreihin. Niitä voidaan käyttää myös menetelmän ylikuormituksen "oikotie"-muotona.

Valinnaisten argumenttien lisäämisen tärkein sysäys oli tarve yksinkertaistaa vuorovaikutusta COM-objektien kanssa. Useat Microsoftin objektimallit (kuten Microsoft Office) tarjoavat toimintoja COM-objektien kautta, joista monet on kirjoitettu kauan sitten ja ne on suunniteltu ottamaan valinnaisia ​​parametreja.

Alla on esimerkki valinnaisten argumenttien käytöstä:

Järjestelmän käyttö; käyttäen System.Collections.Generic; käyttäen System.Linq; käyttäen System.Text; nimitila ConsoleApplication1 ( luokka Ohjelma ( // Argumentit b ja c ovat valinnaisia ​​kutsuttaessa static int mySum(int a, int b = 5, int c = 10) ( return a + b + c; ) static void Main() ( int sum1 = mySum(3); int summa2 = omaSumma(3,12); Console.WriteLine("Sum1 = "+sum1); Console.WriteLine("Sum2 = "+sum2); Console.ReadLine(); ) ) )

On syytä muistaa, että kaikki valinnaiset argumentit on määritettävä pakollisten oikealle puolelle. Metodeiden lisäksi valinnaisia ​​argumentteja voidaan käyttää rakentajissa, indeksoijissa ja delegaateissa.

Yksi valinnaisten argumenttien etu on, että ne helpottavat ohjelmoijan monimutkaisten menetelmä- ja konstruktorikutsujen käsittelyä. Menetelmässä on usein tarpeen määrittää enemmän parametreja kuin yleensä vaaditaan. Ja tällaisissa tapauksissa joistakin näistä parametreista voidaan tehdä valinnaisia ​​käyttämällä valinnaisia ​​argumentteja huolellisesti. Tämä tarkoittaa, että sinun on välitettävä vain ne argumentit, jotka ovat tärkeitä tietyssä tapauksessa, etkä kaikkia argumentteja, joita muuten vaadittaisiin. Tämän lähestymistavan avulla voit järkeistää menetelmää ja yksinkertaistaa ohjelmoijan käsittelyä.

Nimetty Argumentit

Toinen ominaisuus, joka lisättiin C#:aan .NET 4.0:n julkaisun myötä, on tuki ns nimetyt argumentit. Kuten tiedät, kun argumentteja välitetään menetelmälle, niiden järjestyksen on pääsääntöisesti oltava sama kuin järjestys, jossa parametrit määritellään itse menetelmässä. Toisin sanoen argumentin arvo määritetään parametrille sen perusteella, missä se on argumenttiluettelossa.

Nimetyt argumentit on suunniteltu tämän rajoituksen voittamiseksi. Nimetty argumentti antaa sinun määrittää sen parametrin nimen, jolle sen arvo on määritetty. Ja tässä tapauksessa argumenttien järjestyksellä ei ole enää merkitystä. Nimetyt argumentit ovat siis jossain määrin samanlaisia ​​kuin aiemmin mainitut objektialustajat, vaikka ne eroavatkin niistä syntaksiltaan. Jos haluat määrittää argumentin nimellä, käytä seuraavaa syntaksia:

parametrin_nimi: arvo

Tässä parametrin_nimi tarkoittaa sen parametrin nimeä, jolle arvo välitetään. Parametrin_nimi on tietysti oltava kutsuttavan menetelmän todellisen parametrin nimi.