Какво означава int main в c. Разлика между int main() и int main(void)? Формални и фактически параметри

Основна функция.

Всяка C и C++ програма трябва да има основна функция; и от вас зависи къде ще го поставите. Някои програмисти го поставят в началото на файла, други в края. Въпреки това, независимо от нейната позиция, трябва да запомните следното: Аргументи към функцията "main". Процедурата за стартиране на Borland C++ изпраща три параметъра (аргумента) към основната функция: argc, argv и env. - argc, цяло число, е броят на аргументите на командния ред, изпратени към основната функция, - argv е масив от указатели към низове (char *). Под DOS 3.x и по-нови, argv се дефинира като пълния път на програмата, която трябва да бъде стартирана. Когато работи под по-стари версии на DOS, argv сочи към нулев низ (""). argv сочи към първия ред на командния ред след името на програмата. argv сочи към втория ред на командния ред след името на програмата. argv сочи към последния аргумент, изпратен на main. argv съдържа NULL. - env е също масив от указатели към низове. Всеки елемент env съдържа низ във формата ENVVAR=стойност. ENVVAR е името на променлива на средата, като PATH или 87.<значение>това е стойността на дадена променлива на средата, например C:\DOS;C:\TOOLS (за PATH) или YES (за 87). Имайте предвид обаче, че ако посочите някои от тези аргументи, трябва да ги посочите в следния ред: argc, argv, env. Например следните декларации на аргументи са валидни: main() main(int argc) /* валиден, но не много добър */ main(int argc, char *argv) main(int argc, char *argv, char *env) Main (int) декларация argc) не е много удобно, защото знаейки броя на параметрите, вие сами нямате достъп до тях. Аргументът env винаги е достъпен чрез глобалната променлива environ. Вижте променливата environ (в глава 3) и функциите putenv и getenv (в глава 2). Параметрите argc и argv също са достъпни чрез променливите _argc и _argv. Примерна програма, използваща argc, argv и env. Това е примерна програма, ARGS.EXE, която демонстрира най-лесния начин за използване на аргументите, предадени на основната функция. /* ARGS.C програма */ #include #включи void main(int argc, char *argv, char *env) ( int i; printf("Стойността на argc е %d \n\n",argc); printf("Командният ред съдържа %d параметъра \n\ n" ,argc); за (i=0; i<=argc; i++) printf(" argv[%d]: %s\n",i,argv[i]); printf("Среда содержит следующие строки:\n"); for (i=0; env[i] != NULL; i++) printf(" env[%d]: %s\n",i,env[i]); return 0; } Предположим, что вы запускаете программу ARGS.EXE со следующей командной строкой: C:> args first_arg "arg с празни места" 3 4 "предпоследен" стоп! Обърнете внимание, че можете да изпратите аргумент с празни места, като го поставите в двойни кавички, както е показано в примера „аргумент с празни места“ и „предпоследен“ в извикването на програмата. В резултат на стартиране на програмата ще получите нещо като следното: Стойността на argc е 7 Командният ред съдържа 7 параметъра argv: c:\turboc\testargs.exe argv: first_arg argv: arg с празно argv: 3 argv : 4 argv: предпоследен argv: спри! Средата съдържа следните редове: env: COMSPEC=C:\COMMAND.COM env: PROMPT=$p $g env: PATH=C:\SPRINT;C:\DOS;C:\BC Максимална обща дължина на командния ред изпратено до основната функция (включително интервалите и името на самата програма), не може да надвишава 128 знака; Това са ограничения на DOS. Символи за екраниране на командния ред Аргументите на командния ред могат да съдържат символи за екраниране. Те обаче могат да се разширяват за всички имена на файлове, които съответстват на аргумента, по същия начин, както се прави например с командата за копиране на DOS. За да използвате екраниращи символи, когато свързвате вашата програма с линкера, трябва да включите обектния файл WILDARGS.OBJ, който идва с Borland C++. Ако файлът WILDARGS.OBJ е прикачен към вашата програма, можете да използвате аргументи като "*.*" в командния ред. В този случай имената на всички файлове, отговарящи на тази маска, се въвеждат в масива argv. Максималният размер на масива argv зависи само от размера на областта на динамичната памет. Ако не са намерени подходящи файлове за дадена маска, тогава аргументът се предава във формата, в която е въведен в командния ред. (Тоест на основната функция се предава низ, съдържащ екраниращи знаци). Аргументите, оградени в двойни кавички („...“), не се разширяват. Пример. Следните команди компилират файла ARGS.C и го свързват с модула WILDARGS.OBJ и след това стартират получената програма ARGS.EXE: bcc args wildarg.obj args C:\BORLANDC\INCLUDE\*.H "*.C" Когато стартирате ARGS.EXE, първият аргумент се разширява до имената на всички файлове с разширение H в директорията Borland C++ INCLUDE. Имайте предвид, че всички редове включват пълния маршрут (например C:\TC\INCLUDE\ALLOC.H). Аргументът *.C не е разширен, защото той е ограден в кавички. Ако работите в интегрирана среда (BC.EXE), тогава просто трябва да посочите в менюто на проекта името на файла на проекта, който трябва да съдържа следните редове: ARGS WILDARGS.OBJ След това, като използвате "Run/Arguments ", трябва да зададете параметрите на командния ред. Коментирайте. Ако искате обработката на екраниращи символи да се извършва винаги, т.е. За да може WILDARGS.OBJ да бъде автоматично свързан от редактора на връзки, трябва да промените вашата стандартна библиотека C?.LIB, за да включите файла WILDARGS.OBJ. За да направите това, премахнете SETARGV от библиотеката и добавете WILDARGS. Това може да стане със следните команди (приемаме, че стандартните библиотеки и WILDARGS.OBJ се съдържат в текущата директория): TLIB е описана в Глава 7, Помощни програми, на Ръководството на потребителя. tlib cs -setargv +wildargs tlib cc - setargv +wildargs tlib cm -setargv +wildargs tlib cl -setargv +wildargs tlib ch -setargv +wildargs Компилиране с помощта на превключвателя -p (Конвенция за извикване на Pascal) Ако компилирате програмата си с помощта на конвенцията за извикване на Pascal (описана подробно в Глава 9 " Взаимодействие с асемблер", "Ръководство на програмиста"), трябва да запомните, че основната функция трябва да бъде изрично декларирана като C функция. Това може да стане с помощта на ключова дума cdecl е нещо подобно: cdecl main(int argc, char *argv, char *env) Стойността, върната от основната функция. Основната функция връща стойност, която е изходният код на програмата: това е цяло число. Ако обаче вашата програма използва функцията exit (или _exit) за изход, тогава върнатата стойност ще бъде аргументът на тази функция. Например, ако вашата програма съдържа извикване: exit(1), тогава кодът за изход ще бъде 1. Ако използвате интегрираната среда на Borland C++ (BC.EXE), за да стартирате програмата, тогава можете да видите върнатата стойност на main функция, като изберете "Файл | Получаване на информация ".

Страница 53 от 85

1.5.3. Предаване на параметри към основната функция

Основната функция, която започва изпълнението на C програма, може да бъде дефинирана с параметри, които се предават от външната среда, например от командния ред. Външната среда има свои собствени правила за представяне на данни, или по-скоро всички данни се представят под формата на символни низове. За да предадат тези низове към основната функция, се използват два параметъра, като първият параметър се използва за предаване на броя низове, които трябва да бъдат предадени, а вторият се използва за предаване на самите низове. Общите (но не задължителни) имена за тези параметри са argc и argv. Параметърът argc е от тип int, стойността му се формира от анализ на командния ред и е равна на броя думи в командния ред, включително името на извиканата програма (дума е всеки текст, който не съдържа интервал характер). Параметърът argv е масив от указатели към низове, всеки от които съдържа една дума от командния ред. Ако една дума трябва да съдържа знак за интервал, тя трябва да бъде оградена в кавички, когато я записвате в командния ред.

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

Заглавката на основната функция изглежда така:

Ако например командният ред на програма на езика за програмиране C изглежда така:

A:\>cprog работи "C програма" 1

тогава аргументите argc, argv, argp са представени в паметта, както е показано на диаграмата на фиг. 1.

Argc[4]
argv --> -->
-->
-->
-->
argp --> -->
-->
-->
-->
Фиг. 1. Оформление на опциите на командния ред

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

Следващият пример е програма, която отпечатва действителните аргументи, предадени на основната функция от операционната система и параметрите на операционната система.

Пример:
int main (int argc, char *argv, char *argp)
( int i=0;
printf("\nИме на програмата %s", argv);
за (i=1; i>=argc; i++)
printf("\n аргумент %d е %s", argv[i]);
printf("\nНастройки на операционната система:");
докато (*argp)
( printf ("\n %s",*argp);
argp++;
}
връщане (0);
}

Параметрите на операционната система също могат да бъдат достъпни с помощта на функцията на библиотеката geteuv; нейният прототип изглежда така:

char *geteuv (const char *varname);

Аргументът на тази функция указва името на параметъра на средата, указател към стойността на който ще бъде върнат от функцията geteuv. Ако зададеният параметър в момента не е дефиниран в средата, върнатата стойност е NULL.

С помощта на указателя, получен от функцията geteuv, можете само да прочетете стойността на параметъра на операционната система, но не можете да го промените. Функцията puteuv се използва за промяна на стойността на системен параметър.

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

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

setargv()
}
-seteuv()
( return ; /* празна функция */
}
int main()
( /* основна функция без аргументи */
...
...
връщане (0);
}

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

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 ", брой);
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;
}

Всяка C програма започва с извикване на функцията main(). Тази функция трябва да присъства във всяка програма.

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

winrar archTasktask.cpp // winrar.exe archTasktask.cpp

където winrar е името на програмата за архивиране, а редовете „ а», « archTask" И " задача. cpp» представлява аргументи на командния ред, които казват на програмата да създаде архив (" а") С име archTaskот един файл задача. cpp.

Когато предавате параметри към функцията main(), тя трябва да бъде дефинирана по следния начин:

int main(int argc, char *argv) ( ) // или void main(...)()

Параметърът argc съдържа броя на аргументите на командния ред и е цяло число и винаги е поне 1, тъй като първият аргумент винаги е името на програмата (името на програмата с пълния път до програмата).

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

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

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

Пример за програма с различни начини за преобразуване на числа в символен формат в цели и реални числа:

#включи

// при стартиране задаваме например следните аргументи: 100 2.7

void main(int a, char *b) (

k = strtol(b, &ptr, 10); // ptr = адрес на грешката в реда

f = strtod(b, &ptr);

sscanf(b, "%d", &k);

sscanf(b, "%lf", &f);

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

Прост пример за използване на аргументи на командния ред:

int main(int argc, char *argv) (

if (argc != 4) (

printf("Невалидни параметри за стартиране на програмата!\n");

k = atoi(argv); // преобразуване на числовия параметър

printf("Здравейте, %s от група %s от %d година",

Ако името на програмата е задача и вашето име е „Вася“, група „PM-11“ от първата година, тогава за да стартирате програмата, трябва да въведете в командния ред:

задача Вася PM-11 1

В резултат на изпълнение на програмата на екрана ще се появи следното съобщение: „Здравей, Вася от 1-ва година група PM-11.“

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

Аргументите на командния ред трябва да бъдат разделени с интервал. Ако има интервали в самия аргумент, тогава, за да се предотврати създаването на множество аргументи, този аргумент трябва да бъде ограден в двойни кавички. В резултат на това целият низ в кавички ще се счита за един аргумент. Например, програмата може да се стартира така: задача „Вася и Петя“ PM-21 2. В резултат на изпълнение на програмата на екрана ще се появи съобщението: „Здравейте, Вася и Петя от 2-ра година PM- 21 група."

Какво е char *argv? Това масив, чиито елементи са указатели, това е масив от указатели. Това означава, че при предаване на параметри на main(), може да се дефинира по следния начин:

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

Задача. Показване на всички аргументи на командния ред (няма нужда да се показва името на програмата).

#включи

void main(int argc, char *argv)(

за (i = 1; i< argc; i++)

printf("%s\n", argv[i]);

Втори вариант =================

#включи

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

докато ((p=*argv) != NULL) (

printf("%s\n", p);

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

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

Как да отстранявате грешки в пр.н.е. програми, които изискват аргументи от командния ред. В менюто Run→Arguments... трябва да въведете аргументи на командния ред. Не е необходимо да посочвате името на програмата. След това можете просто да стартирате и да отстраните грешки в програмата в средата за разработка, както обикновено.

Моля, спрете AdBlock на този сайт.

И така, защо имаме нужда от персонализирани функции? Дефинираните от потребителя функции са необходими, за да улеснят програмистите да пишат програми.

Не забравяйте, че говорихме за парадигми на програмиране, по-точно за структурирано програмиране. Основната идея беше, че всяка програма може да бъде написана само с три основни конструкции: следване, условие и цикъл. Сега ще добавим още една към тези структури - „подпрограми“ - и ще получим нова парадигма процедурно програмиране".

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

Така че в този урок ще обсъдим подробно как функциите се изграждат вътрешно. Ще научим също как да създаваме свои собствени персонализирани функции.

Как работят функциите

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

Списък 1.

Int main(void)( // заглавка на функция // тялото на функцията е написано във фигурни скоби)

Всичко е ясно с тялото на функцията: той описва алгоритъма на функцията. Да погледнем заглавието. Състои се от три задължителни части:

тип връщане;
име на функция;
аргументи на функцията.

Първо се записва връщащият тип, например int , както в основната функция. Ако дадена функция не трябва да върне никаква стойност на програмата, тогава ключовата дума void се записва на това място. Изглежда, че тъй като функцията не връща нищо, тогава няма нужда да пишете нищо. Преди, между другото, това беше направено на езика C, но след това го добавиха за еднаквост. В наши дни съвременните компилатори ще издават предупреждения/грешки, ако не посочите тип на връщане.
В някои езици за програмиране функциите, които не връщат никаква стойност, се наричат процедури (например Pascal). Освен това има различни синтаксиси за създаване на функции и процедури. В езика C няма такава дискриминация.

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

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

Списък 2.

// функция с име srand, която приема цяло число, не връща нищо void srand(int) // функция с име sqrt, която приема реално плаващо число, връща число с плаваща величина float sqrt(float) // функция с име rand, която не приема аргументи, връща цяло число int rand(void) //функция с име pow, която приема два аргумента от тип double, връща реално число от тип double double pow(double, double)

Как да създадете своя собствена функция

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

Фиг.1 Изясняване на структурата на програмата. Декларация на функции.

Както можете да видите, има две места, където това може да се направи.

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

Списък 3.

#включи // деклариране на персонализирана функция с име max_num // вход: два целочислени параметъра с имена a и b // изход: максимумът от двата аргумента int max_num(int a, int b)( int max = b; if (a > b) max = a; return max; ) //главна програма int main(void) ( int x = 0, y = 0; int m = 0; scanf("%d %d", &x, &y); m = max_num( x ,y); printf("max(%d,%d) = %d\n",x,y,m); върне 0; )

Нека опиша подробно как ще работи тази програма. Тялото на основната функция се изпълнява. Създават се целочислените променливи x, y и m. Променливите x и y се четат от клавиатурата. Да кажем, че сме въвели 3 5, тогава x = 3, y = 5. Всичко това трябва да ви е ясно. Сега следващият ред

Списък 4.

M = max_num(x,y);

Променливата m трябва да бъде присвоена на това, което е вдясно от знака =. Там имаме името на функцията, която създадохме сами. Компютърът търси декларацията и описанието на тази функция. Намира се над. Съгласно тази декларация тази функция трябва да приема две цели числа. В нашия случай това са стойностите, записани в променливите x и y. Тези. номера 3 и 5. Моля, обърнете внимание, че не самите променливи x и y се предават на функцията, а само стойностите (две числа), които се съхраняват в тях. Това, което всъщност се предава на функция, когато тя се извиква в програма, се нарича действителните параметри на функцията.

Сега функцията max_num започва да се изпълнява. Първата стъпка е да създадете отделна временна променлива за всеки параметър, описан в заглавката на функцията. В нашия случай се създават две целочислени променливи, наречени a и b. На тези променливи се присвояват стойностите на действителните параметри. Самите параметри, описани в заглавката на функцията, се наричат формални параметри. Така на формалните параметри a и b се присвояват стойностите съответно на действителните параметри 3 и 5. Сега a = 3, b = 5. По-нататък във функцията можем да работим с тези променливи, сякаш са обикновени променливи.

Създава се целочислена променлива с име max и й се присвоява стойност b. След това се проверява условието a > b. Ако е вярно, тогава стойността в променливата max трябва да бъде заменена с .

Следва операторът return, който връща на извикващата програма (основната функция) стойността, записана в променливата max, т.е. 5. След което променливите a, b и max се изтриват от паметта. И се връщаме на линията

Списък 5.

M = max_num(x,y);

Функцията max_num върна стойност 5, което означава, че сега има 5, изписано вдясно от знака =. Тази стойност се записва в променливата m. След това редът се показва на екрана и програмата приключва.

Прочетете внимателно последните 4 параграфа отново, за да разберете напълно как работи програмата.

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

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

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

Списък 6.

#включи int max_num(int, int); int main(void) ( int x =0, y = 0; int m = 0; scanf("%d %d", &x, &y); m = max_num(x,y); printf("max(%d ,%d) = %d\n",x,y,m); return 0; ) int max_num(int a, int b)( int max = b; if (a > b) max = a; return max; )

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