Функционални аргументи main c визуално студио. Аргументи на функцията Main().

Незадължителни и именувани аргументи

Незадължителни аргументи

C# 4.0 въвежда нова функция, която подобрява удобството при посочване на аргументи при извикване на метод. Този инструмент се нарича незадължителни аргументии ви позволява да дефинирате стойност по подразбиране за параметър на метод. Тази стойност ще се използва по подразбиране, ако не е зададен съответен аргумент за параметъра, когато методът се извиква. Следователно не е необходимо да се указва аргумент за такъв параметър. Незадължителните аргументи улесняват извикването на методи, където аргументите по подразбиране се прилагат към някои параметри. Те могат да се използват и като "кратка" форма на претоварване на метода.

Основният импулс за добавяне на незадължителни аргументи беше необходимостта да се опрости взаимодействието с COM обекти. В няколко обектни модела на Microsoft (напр. Microsoft офис) функционалността се предоставя чрез COM обекти, много от които са написани отдавна и са проектирани да използват незадължителни параметри.

Пример за използване на незадължителни аргументи е показан по-долу:

Използване на системата; използване на System.Collections.Generic; използване на System.Linq; използване на System.Text; namespace ConsoleApplication1 ( class Program ( // Аргументите b и c са незадължителни при извикване на 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(); ) ) )

Трябва да се има предвид, че всички незадължителни аргументи трябва задължително да бъдат посочени вдясно от задължителните. В допълнение към методите незадължителните аргументи могат да се използват в конструктори, индексатори и делегати.

Едно предимство на незадължителните аргументи е, че те улесняват програмиста да се справя със сложни извиквания на методи и конструктори. В края на краищата често е необходимо да се зададат повече параметри в метода, отколкото обикновено се изисква. И в случаи като този, някои от тези параметри могат да бъдат направени незадължителни чрез внимателно използване на незадължителните аргументи. Това означава, че трябва да подадете само аргументите, които са важни в дадения конкретен случай, не всички аргументи, които иначе би трябвало да се изискват. Този подход ни позволява да рационализираме метода и да опростим работата на програмиста с него.

Наименувани аргументи

Още едно функционалност, който беше добавен към C# с излизането на .NET 4.0, е поддръжка на т.нар именувани аргументи. Както знаете, когато подавате аргументи към метод, редът, в който се появяват, по правило трябва да съвпада с реда, в който параметрите са дефинирани в самия метод. С други думи, стойността на аргумента се присвоява на параметъра чрез неговата позиция в списъка с аргументи.

Именуваните аргументи са предназначени да преодолеят това ограничение. Наименуван аргумент ви позволява да посочите името на параметъра, на който е присвоена неговата стойност. И в този случай редът на аргументите вече няма значение. По този начин именуваните аргументи са донякъде подобни на инициализаторите на обекти, споменати по-рано, въпреки че се различават от тях по своя синтаксис. За да посочите аргумент по име, използвайте следната форма на синтаксис:

име_на_параметър: стойност

Тук име_на_параметъробозначава името на параметъра, към който се предава стойността. Разбира се, parameter_name трябва да е името на валиден параметър за метода, който се извиква.

Случва се данните да се прехвърлят към програмата от командния ред, когато се извика. Такива данни се наричат аргументи на командния ред. Изглежда така например:

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

Това извиква програмите a.out (от текущата директория) и ls (от същата директория, посочена в променливата на средата PATH). Първата програма от командния ред получава една дума - test.txt, втората - две: -lt и /home/peter/.

Ако програмата е написана на C, тогава, когато стартира, контролът незабавно се прехвърля към функцията main(), следователно тя получава аргументите на командния ред, които са присвоени на нейните променливи параметри.

Досега сме дефинирали функцията main() така, сякаш не приема никакви параметри и не връща нищо. Всъщност в C всяка функция по подразбиране (ако нищо друго не е дефинирано) връща цяло число. Това може да се провери. Ако напишете кода така:

main() ( printf("Здравей \н") ; връщане 0; )

Тогава няма да се появи предупреждение или грешка по време на компилирането. Същото ще се случи, ако напишем int main(). Това доказва, че функцията по подразбиране връща цяло число, а не нищо (void). Въпреки че това, което функцията връща, винаги може да бъде "заменено", например voidmain() или float main().

Когато програма бъде извикана от командния ред, към нея винаги се предава двойка данни:

цяло число, обозначаващ броя на думите (елементи, разделени с интервали) в командния ред при извикване,
указател към масив от низове, където всеки ред е една дума от командния ред.

Имайте предвид, че самото име на програмата също се взема предвид. Например, ако обаждането изглежда така:

./a.out 12 тема 2

Тогава първият аргумент на програмата е 4, а масивът от низове се дефинира като ("./a.out", "12", "theme", "2").

Обърнете внимание на терминологията, има само два аргумента на програмата (число и масив), но колкото искате аргументи на командния ред. Аргументите на командния ред се „превеждат“ в програмни аргументи (в аргументи на функцията main().
Тези данни (число и указател) се предават на програмата, дори когато тя просто се извиква по име, без да й се предава нищо: ./a.out. В този случай първият аргумент е 1, а вторият аргумент сочи към масив от само един низ (""./a.out").

Фактът, че данните се предават на програмата, не означава, че функцията main() трябва да ги получи. Ако функцията main() е дефинирана без параметри, тогава аргументите на командния ред не могат да бъдат достъпни. Въпреки че нищо не пречи да ги изпратите. Няма да възникне грешка.

За да получите достъп до данните, предадени на програмата, те трябва да бъдат присвоени на променливи. Тъй като аргументите се предават незабавно на main(), заглавката му трябва да изглежда така:
основен (int n, char *arr)

Първата променлива (n) съдържа броя на думите, а втората променлива съдържа указател към масив от низове. Често вторият параметър се записва като **arr . Въпреки това е същото. Спомнете си, че самият масив от низове съдържа указатели към низове като свои елементи. И във функцията подаваме указател към първия елемент от масива. Оказва се, че предаваме указател към указател, т.е. **обр.

Упражнение
Напишете програма като тази:

#включи int main(int argc, char ** argv) ( int i; printf ("%d \н", argc) ; за (i= 0; i< argc; i++ ) puts (argv[ i] ) ; }

Той отпечатва броя на думите в командния ред, когато бъде извикан, и всяка дума с нова линия. Извикайте го без аргументи на командния ред и с аргументи.

В програмата използвахме променливите параметри argc и argv. Прието е да се използват точно такива имена, но всъщност те могат да бъдат всякакви. По-добре е да се придържате към този стандарт, така че вашите програми да са по-разбираеми не само за вас, но и за други програмисти.

Практическото значение на предаването на данни към програма

Ако имате опит с командния ред на GNU/Linux, знаете, че повечето команди имат ключове и аргументи. Например, когато разглеждате съдържанието на директории, копирате, премествате, обектите се задават като аргументи файлова системана който се изпълнява командата. Характеристиките на неговото изпълнение се определят с помощта на ключове. Например в командата

Cp -r ../les_1 ../les_101

cp е името на командата, -r е превключвателят и ../les_1 и ../les_101 са аргументите на командата.

По принцип най-често при стартиране на програми се прехвърлят адреси на файлове и "модификатори" (това са ключове) на процеса на изпълнение на програмата.

Нека напишем програма, която отваря зададените от потребителя файлове в командния ред за писане или добавяне и записва (добавя) там същата информация, която потребителят въвежда от клавиатурата по време на изпълнение на програмата:

#включи #включи main (int argc, char ** argv) ( int i, ch; FILE * f[ 5 ] ; if (argc< 3 || argc >7 ) ( поставя ( „Невалиден брой параметри“) ; връщане 1; ) if (strcmp (argv[ 1 ] , "-w" ) != 0 && strcmp (argv[ 1 ] , "-a") != 0 ) ( поставя ( "Първият параметър може да бъде -w или -a") ; връщане 2; ) за (i= 0; i< argc- 2 ; i++ ) { f[ i] = fopen (argv[ i+ 2 ] , argv[ 1 ] + 1 ) ; if (f[ i] == NULL) { printf („Файлът %s не може да бъде отворен\n“, argv[ i+ 2 ] ); връщане 3; ) ) докато ((ch = getchar () ) != EOF) за (i= 0 ; i< argc- 2 ; i++ ) putc (ch, f[ i] ) ; for (i= 0 ; i < argc- 2 ; i++ ) fclose (f[ i] ) ; return 0 ; }

Обяснения към кода:

Създава се масив от пет файлови указателя. Следователно не могат да се отварят повече от пет файла едновременно. Файловият указател на първия файл ще се съхранява в елемента на масива f, на втория - във f и т.н.
Броят на аргументите на командния ред се проверява. Трябва да са поне три, т.к. първото е името на програмата, второто е режимът на отваряне на файла, третото е първият или единственият файл, в който ще се записва. Тъй като програмата ви позволява да отворите само пет файла, общият брой аргументи на командния ред не може да надвишава седем. Следователно, ако броят на аргументите е по-малък от 3 или повече от 7, тогава програмата приключва, защото Инструкцията return кара функцията да излезе, дори ако има още код след нея. Стойност, върната от функцията, която не е равна на 0, може да се интерпретира от родителския процес като съобщение, че програмата е приключила с грешка.
Проверява се коректността на втория аргумент на командния ред. Ако не е нито "-w", нито "-a", тогава условният израз във второто if връща 1 (true). Функцията strcmp() ви позволява да сравнявате низове и връща 0, ако са равни.
IN за цикълфайловете се отварят на посочените адреси, които започват с третия елемент от масива argv. Ето защо към i се добавя 2, за да се получат елементите на масива argv, започвайки от третия. Изразът argc-2 показва броя на предадените имена на файлове; защото argc съхранява общия брой аргументи на командния ред, първите два от които не са имена на файлове.
Изразът argv+1 ви позволява да "изрежете" подниза "w" (или "a") от низа "-w" (или "-a"), т.к. argv е по същество указател към първия елемент на низа. Добавяйки единица към показалеца, ние го преместваме към следващия елемент в масива.
Ако файлът не може да бъде отворен, функцията fopen() връща NULL. В този случай програмата приключва.
Всеки знак, въведен от потребителя от клавиатурата, се записва във всички отворени файлове.
Накрая файловете се затварят.

При автоматично създаване на конзолно приложение на езика за програмиране C++ автоматично се създава основна функция, която е много подобна на тази:

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

Заглавката на функцията съдържа подписа Главна функция main() с аргументи argc и argv.
Ако програмата се изпълнява през командния ред, тогава е възможно да прехвърлите всяка информация към тази програма. Има аргументи на командния ред argc и argv за това.
Параметърът argc е от тип int и съдържа броя на параметрите, предадени на основната функция. Освен това argc винаги е поне 1, дори когато не се предава информация към главната функция, тъй като името на приложението се счита за първия параметър.
Параметърът argv е масив от указатели към низове. През командния ред могат да се предават само данни от тип низ.

При стартиране на програмата чрез команда Windows линияможете да изпратите някаква информация към него. В този случай командният ред ще изглежда така:
Диск:\path\name.exe аргумент1 аргумент2 ...

Аргументите на командния ред са разделени с един или повече интервали.

Аргументът argv съдържа пълното име на приложението:

#включи
използване на пространство от имена std;

cout<< argv << endl;

връщане 0;
}

Резултат от изпълнението

Пример: изчисляване на произведението на две цели числа
Програмата използва функцията за преобразуване на низ към цяло число StrToInt() от тук.

#включи
използване на пространство от имена std;
int StrToInt(char*s) (...)
int main(int argc, char * argv) (

Int a = 0, b=0;

Ако (argc > 1)

a = StrToInt(argv);

Ако (argc > 2)

b = StrToInt(argv);

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

връщане 0;
}

Програмата се стартира като

Резултат от изпълнението

Отстраняване на грешки в програма с аргументи на командния ред

За да подадете аргументи на командния ред при отстраняване на грешки в програма, трябва да влезете в менюто Имотипроект.

В раздела Конфигурационни свойства -> Отстраняване на грешкиизбирам Командни аргументии задайте техните стойности.

Когато стартирате програмата в режим на отстраняване на грешки, въведените аргументи ще бъдат третирани от програмата като аргументи на командния ред.

Понякога при стартиране на програма е полезно да й се предаде някаква информация. Обикновено тази информация се предава на функцията main() чрез аргументи на командния ред. Аргумент на командния реде информация, която се въвежда в командния ред на операционната система след името на програмата. Например, за да започнете да компилирате програма, трябва да въведете следното в командния ред след подканата:

вв име_на_програма

име_на_програмае аргумент от командния ред, който указва името на програмата, която ще компилирате.

За приемане на аргументи от командния ред се използват два специални вградени аргумента: argc и argv. Параметърът argc съдържа броя на аргументите в командния ред и е цяло число и винаги е поне 1, тъй като първият аргумент е името на програмата. А параметърът argv е указател към масив от указатели към низове. В този масив всеки елемент сочи към някакъв аргумент от командния ред. Всички аргументи на командния ред са низове, така че конвертирането на произволни числа в желания двоичен формат трябва да бъде осигурено в програмата, когато е разработена.

Ето прост пример за използване на аргумента на командния ред. Екранът показва думата Hello и вашето име, което трябва да бъде посочено като аргумент на командния ред.

#включи #включи int main(int argc, char *argv) ( if(argc!=2) ( printf("Забравихте да въведете името си.\n"); exit(1); ) printf("Здравейте %s", argv) ; върне 0; )

Ако сте нарекли името на тази програма (име) и вашето име е Том, тогава, за да стартирате програмата, въведете името Том в командния ред. В резултат на стартиране на програмата на екрана ще се появи съобщението Hello, Tom.

В много среди всички аргументи на командния ред трябва да бъдат разделени един от друг с интервал или раздел. Запетаите, точката и запетаята и подобни знаци не се считат за разделители. Например,

Бягай Спот, бягай

се състои от три символни низа, докато

Ерик, Рик, Фред

е низ от един знак - запетаите обикновено не се считат за разделители.

Ако низът съдържа интервали, тогава в някои среди низът може да бъде ограден в двойни кавички, за да се предотврати създаването на множество аргументи. В резултат на това целият низ ще се счита за един аргумент. За да научите повече за това как са зададени опциите на командния ред във вашата операционна система, вижте документацията за тази система.

Много е важно да декларирате правилно argv. Ето как го правят най-често:

Char *argv;

Празните квадратни скоби показват, че масивът е с неопределена дължина. Вече можете да получите достъп до отделни аргументи чрез индексиране на масива argv. Например argv сочи към първия символен низ, който винаги е името на програмата; argv сочи към първия аргумент и т.н.

Друг малък пример за използване на аргументи на командния ред е програмата за обратно броене по-долу. Тази програма отброява обратно от някаква стойност (посочена в командния ред) и издава звуков сигнал, когато достигне 0. Имайте предвид, че първият аргумент, съдържащ първоначалната стойност, се преобразува в целочислена стойност с помощта на стандартната функция atoi (). Ако вторият аргумент на командния ред (и ако вземем името на програмата като трети аргумент) е низът "дисплей" (извежда се на екрана), тогава резултатът от обратното броене (в обратен ред) ще бъде показан на екрана.

/* Програма за обратно броене. */ #включи #включи #включи #включи 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; }

Имайте предвид, че ако аргументите на командния ред не са посочени, ще се покаже съобщение за грешка. Програмите с аргументи на командния ред често правят следното: когато потребителят стартира тези програми, без да въведе необходимата информация, се показват инструкции как правилно да се уточнят аргументите.

За достъп до един знак в един от аргументите на командния ред, въведете втория индекс в argv. Например, следната програма отпечатва символ по знак всички аргументи, с които е била извикана:

#включи int main(int argc, char *argv) ( int t, i; for(t=0; t

Не забравяйте, че първият индекс на argv осигурява достъп до низа, а вторият индекс осигурява достъп до неговите отделни знаци.

Обикновено argc и argv се използват за предаване на първоначалните команди към програмата, които ще са й необходими при стартиране. Например аргументите на командния ред често указват информация като име на файл, опция или алтернативно поведение. Използването на аргументи на командния ред придава на вашата програма "професионален вид" и я прави по-лесна за използване в пакетни файлове.

Имената argc и argv са традиционни, но не са задължителни. Можете да наименувате тези два параметъра във функцията main() както желаете. Освен това някои компилатори може да поддържат -допълнителни аргументи за main(), така че не забравяйте да проверите документацията за вашия компилатор.

Когато една програма не изисква параметри на командния ред, най-често е изрично да се декларира функцията main() да няма параметри. В този случай ключовата дума void се използва в списъка с параметри на тази функция.

Borland C++ поддържа три main() аргумента. Първите две са традиционните argc и argv. Това са единствените аргументи към функцията main(), дефинирана от стандарта ANSI C. Те позволяват аргументите от командния ред да бъдат предавани на програмата. Аргументите на командния ред са информацията, която следва името на програмата в командния ред на операционната система. Например, когато една програма се компилира с вградения компилатор на Borland, bcc обикновено се въвежда име_на_програма

Където име_на_програмае програмата, която трябва да се компилира. Името на програмата се предава на компилатора като аргумент.

Параметърът argc съдържа броя на аргументите на командния ред и е цяло число. Винаги е поне 1, защото името на програмата е квалифицирано като първи аргумент. Параметърът argv е указател към масив от символни указатели. Всеки елемент от този масив сочи към аргумент на командния ред. Всички аргументи на командния ред са низове. Всички числа се конвертират от програмата във вътрешен формат. Следната програма отпечатва „Hello“, последвано от потребителското име, ако е въведено точно след името на програмата:

#включи

{
ако (argc!=2)
{
printf("Забравихте да въведете името си\n");
връщане 1;
}
printf("Здравей %s", argv);
връщане 0;
}

Ако извикате името на тази програма и потребителското име е Сергей, тогава за да стартирате програмата, трябва да въведете:
име Сергей.
В резултат на програмата ще се появи:
Здравей Сергей.

Аргументите на командния ред трябва да бъдат разделени с интервали или табулатори. Запетаите, точката и запетаята и подобни знаци не се считат за разделители. Например:

Състои се от три реда, докато

Хърб, Рик, Фред

Това е един ред - запетаите не са разделители.

Ако искате да предадете низ, съдържащ интервали или табулатори като един аргумент, оградете го в двойни кавички. Например, това е един аргумент:

"това е тест"

Важно е да декларирате правилно argv. Най-типичният метод е:

Празните скоби показват, че масивът няма фиксирана дължина. Можете да получите достъп до отделни елементи, като използвате argv индексиране. Например argv сочи към първия ред, който винаги съдържа името на програмата. argv сочи към следващия ред и т.н.

По-долу е даден малък пример за използване на аргументи на командния ред. Той отброява обратно от стойността, зададена в командния ред, и излъчва сигнал, когато се достигне нула. Имайте предвид, че първият аргумент съдържа число, преобразувано в цяло число с помощта на стандартната функция atoi(). Ако низът "display" присъства като втори аргумент, тогава самият брояч ще се покаже на екрана.

/* програма за броене */

#включи
#включи
#включи
int main(int argc, char *argv)
{
int disp, брой;
ако (argc<2)
{
printf("Трябва да въведете дължината на броя\n");
printf("на командния ред. Опитайте отново.\n");
връщане 1;
}
if (argc==3 && !strcmp(argv,"display")) disp = 1;
иначе disp = 0;
for(count=atoi(argv); count; -count)
if (disp) printf("%d", count);
printf("%c", "\a"); /* на повечето компютри това е повикване */
връщане 0;
}

Имайте предвид, че ако не са посочени аргументи, се появява съобщение за грешка. Това е най-типично за програмите, които използват аргументи от командния ред, за да издават инструкции, ако е направен опит за стартиране на програмата без правилната информация.

За достъп до отделни символи от командния ред добавете втори индекс към argv. Например, следната програма отпечатва всички аргументи, с които е извикана, един знак наведнъж:

#включи
int main(int argc, char *argv)
{
int t, i;
за (t=0; t {
i = 0;
докато (argv[t][i])
{
printf("%c", argv[t][i]);
}
printf(");
}
връщане 0;
}

Трябва да се помни, че първият индекс е за достъп до низа, а вторият е за достъп до символа на низа.

Обикновено argc и argv се използват за получаване на команди на източника. Теоретично можете да имате до 32767 аргумента, но повечето операционни системи дори не ви позволяват да се доближите до това. Обикновено тези аргументи се използват за указване на име на файл или опции. Използването на аргументи на командния ред придава на програмата професионален вид и позволява програмата да се използва в пакетни файлове.

Ако включите файла WILDARGS.OBJ, доставен с Borland C++, можете да използвате заместващи символи в аргументи от тип *.EXE. (Borland C++ обработва шаблоните автоматично и съответно увеличава argc.) Например, ако свържете WILDARGS.OBJ към следната програма, тя ще отпечата колко файла съответстват на името на файла, посочен в командния ред:

/* Свържете тази програма с WILDARGS.OBJ */

#включи
int main(int argc, char *argv)
{
регистър int i;
printf("%d файла отговарят на определено име\n", argc-1);
printf("Те са: ");
за (i=1; i printf("%s", argv[i]);
връщане 0;
}

Ако наречем тази програма WA, след това я стартираме по следния начин, получаваме броя на файловете, които имат разширение EXE, и списък с имената на тези файлове:

В допълнение към argc и argv, Borland C++ предоставя и трети аргумент на командния ред -env. Параметърът env позволява на програмата достъп до информация за средата на операционната система. Параметърът env трябва да следва argc и argv и се декларира по следния начин:

Както можете да видите, env се декларира по същия начин като argv. Точно като argv, това е указател към масив от низове. Всеки ред е низ от среда, както е дефиниран от операционната система. Параметърът env няма аналог на параметъра argc, който казва колко линии на средата има. Вместо това последният ред на средата е нула. Следната програма отпечатва всички низове на средата, дефинирани в момента в операционната система:

/* тази програма отпечатва всички редове на средата */

#включи
int main(int argc, char *argv, char *env)
{
int t;
за (t=0; env[t]/ t++)
printf("%s\n", env[t]);
връщане 0;
}

Имайте предвид, че въпреки че argc и argv не се използват от програмата, те трябва да присъстват в списъка с параметри. C не знае имената на параметрите. Вместо това тяхното използване се определя от реда, в който са декларирани параметрите. Всъщност можете да наричате параметъра както искате. Тъй като argc, argv и env са традиционни имена, най-добре е да продължите да ги използвате, така че всеки, който чете програмата, да може незабавно да разпознае, че това са аргументи на функцията main().

За програмите типична задача е да намерят стойността, дефинирана в низа на средата. Например, съдържанието на низа PATH позволява на програмите да използват пътища за търсене. Следната програма демонстрира как да намерите низове, които декларират стандартни пътища за търсене. Той използва стандартната библиотечна функция strstr(), която има следния прототип:

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

Функцията strstr() търси низа, към който сочи str1, в низа, към който сочи str2. Ако се намери такъв низ, тогава се връща указател към първата позиция. Ако не бъде намерено съвпадение, функцията връща NULL.

/* програмата търси в низовете на средата за низ, съдържащ PATH */

#включи
#включи
int main (int argc, char *argv, char *env)
{
int t;
за (t=0; env[t]; t++)
{
if(strstr(env[t], "PATH"))
printf("%s\n", env[t]);
}
връщане 0;
}