Аргументы функции MAIN()
Borland С++ поддерживает три аргумента main(). Первые два — это традиционные argc и argv. Это единственные аргументы функции main(), определяемые стандартом ANSI С. Они позволяют передавать аргументы командной строки в программу. Аргументы командной строки — это информация, следующая за именем программы в командной строке операционной системы. Например, когда программа компилируется с помощью строчного компилятора Borland, набирается, как правило, bcc имя_ программы
где имя_программы — это программа, которую необходимо откомпилировать. Имя программы передается компилятору в качестве аргумента.
Параметр argc содержит число аргументов командной строки и является целым числом. Он всегда равен, по крайней мере, 1, поскольку имя программы квалифицируется как первый аргумент. Параметр argv — это указатель на массив символьных указателей. Каждый элемент данного массива указывает на аргумент командной строки. Все аргументы командной строки — это строки. Все числа конвертируются программой во внутренний формат. Следующая программа выводит «Hello», а затем имя пользователя, если его набрать прямо за именем программы:
#include
int main(int argc, char *argv[])
if(argc!=2)
printf («You forgot to type your name\n»);
return 1;
>
printf(«Hello %s», argv[1]);
return 0;
>
Если назвать данную программу name, а имя пользователя Сергей, то для запуска программы следует набрать:
name Сергей.
В результате работы программы появится:
«Hello Сергей».
Аргументы командной строки должны отделяться пробелами или табуляциями. Запятые, точки с запятыми и им подобные символы не рассматриваются как разделители. Например:
состоит из трех строк, в то время как
это одна строка — запятые не являются разделителями.
Если необходимо передать строку, содержащую пробелы или табуляции в виде одного аргумента, следует ее заключить в двойные кавычки. Например, это один аргумент:
Важно правильно объявить argv. Наиболее типичным методом является:
Пустые скобки указывают на то, что массив не имеет фиксированной длины. Можно получить доступ к отдельным элементам с помощью индексации argv. Например, argv[0] указывает на первую строку, всегда содержащую имя программы. argv[1] указывает на следующую строку и так далее.
Ниже приведен небольшой пример по использованию аргументов командной строки. Он отсчитывает в обратном порядке от значения, указанного в командной строке, и при достижении нуля подает сигнал. Обратим внимание, что первый аргумент содержит число, преобразованное в целое число с использованием стандартной функции atoi(). Если в качестве второго аргумента присутствует строка «display», то на экране будет отображаться сам счетчик.
#include
#include
# include
int main(int argc,, char *argv[])
int disp, count;
if(argc <2)
printf(«You must enter the length of the count\n»);
printf («on the command line. Try again.\n»);
return 1;
>
if (argc==3 && !strcmp(argv[2],»display»)) disp = 1;
else disp = 0;
for(count=atoi(argv[1]); count; -count)
if (disp) printf(«%d «, count);
printf(«%c», ‘\a’); /* на большинстве компьютеров это звонок */
return 0;
>
Обратим внимание, что если не указаны аргументы, появляется сообщение об ошибке. Это наиболее типично для программ, использующих аргументы командной строки для выдачи инструкций, если была попытка запустить программу без правильной информации.
Для доступа к отдельным символам командной строки следует добавить второй индекс к argv. Например, следующая программа выводит все аргументы, с которыми она вызывалась, по одному символу за раз:
Надо помнить, что первый индекс предназначен для доступа к строке, а второй — для доступа к символу строки.
Обычно argc и argv используются для получения исходных команд. Теоретически можно иметь до 32767 аргументов, но большинство операционных систем не позволяют даже близко подойти к этому. Обычно данные аргументы используются для указания имени файла или опций. Использование аргументов командной строки придает программе профессиональный вид и допускает использование программы в командных файлах.
Если подсоединить файл WILDARGS.OBJ, поставляемый с Borland С++, то можно будет использовать шаблоны в аргументах типа *.EXE. (Borland С++ автоматически обрабатывает шаблоны и соответствующим образом увеличивает argc.) Например, если подсоединить к следующей программе WILDARGS.OBJ, она выдаст, сколько файлов соответствует имени указанного в командной строке файла:
/* Скомпонуйте данную программу с WILDARGS.OBJ */
#include
int main(int argc, char *argv[])
register int i;
printf(«%d files match specified name\n», argc-1);
printf(«They are: «);
for(i=1; i printf («%s «, argv[i]);
return 0;
>
Если назвать данную программу WA, затем запустить ее как указано ниже, получим число файлов, имеющих расширение ЕХE, и список имен этих файлов:
Помимо argc и argv Borland С++ также предоставляет третий аргумент командной строки -env. Параметр env позволяет программе получить доступ к информации о среде операционной системы. Параметр env должен следовать за argc и argv и объявляется следующим образом:
Как можно видеть, env объявляется так же, как и argv. Так же, как и argv, это указатель на массив строк. Каждая строка — это строка среды, определенная операционной системой. Параметр env не имеет аналога параметра argc, который сообщал бы, сколько имеется строк среды. Вместо этого последняя строка среды нулевая. Следующая программа выводит все строки среды, определенные на текущий момент в операционной системе:
/* данная программа выводит все строки окружения */
#include
int main(int argc, char *argv[], char *env[])
int t;
for(t=0; env[t]/ t++)
printf(«%s\n», env[t]);
return 0;
>
Обратим внимание, что хотя argc и argv не используются программой, они должны присутствовать в списке параметров. С не знает имена параметров. Вместо этого их использование определяется по порядку объявления параметров. Фактически можно обозвать параметр как угодно. Поскольку argc, argv и env — это традиционные имена, то лучше их использовать и далее, чтобы любой человек, читающий программу, мог мгновенно понять, что это аргументы функции main().
Для программ типичной задачей является поиск значения, определенного в строке среды. Например, содержимое строки PATH позволяет программам использовать пути поиска. Следующая программа демонстрирует, как найти строки, объявляющие стандартные пути поиска. Она использует стандартную библиотечную функцию strstr(), имеющую следующий прототип:
char *strstr(const char *str1, const char *str2);
Функция strstr() ищет строку, на которую указывает str1 в строке, на которую указывает str2. Если такая строка найдена, то возвращается указатель на первое положение. Если не найдено соответствий, то функция возвращает NULL.
/* программа ищет среди строк окружения строку, содержащую PATH */
#include
#include
int main (int argc, char *argv[], char *env[])
int t;
for(t=0; env[t]; t++)
if(strstr(env[t], «PATH»))
printf(«%s\n», env[t]);
>
return 0;
>
1.5.3. Передача параметров функции main
Функция main, с которой начинается выполнение СИ-программы, может быть определена с параметрами, которые передаются из внешнего окружения например, из командной строки. Во внешнем окружении действуют свои правила представления данных, а точнее, все данные представляются в виде строк символов. Для передачи этих строк в функцию main используются два параметра, первый параметр служит для передачи числа передаваемых строк, второй для передачи самих строк. Общепринятые (но не обязательные) имена этих параметров argc и argv. Параметр argc имеет тип int, его значение формируется из анализа командной строки и равно количеству слов в командной строке, включая и имя вызываемой программы (под словом понимается любой текст не содержащий символа пробел). Параметр argv это массив указателей на строки, каждая из которых содержит одно слово из командной строки. Если слово должно содержать символ пробел, то при записи его в командную строку оно должно быть заключено в кавычки.
Функция main может иметь и третий параметр, который принято называть argp, и который служит для передачи в функцию main параметров операционной системы (среды) в которой выполняется СИ-программа.
Заголовок функции main имеет вид:
int main (int argc, char *argv[], char *argp[])
Если, например, командная строка СИ-программы имеет вид:
A:\>cprog working ‘C program’ 1
то аргументы argc, argv, argp представляются в памяти как показано в схеме на рис.1.
1 2 3 4 5 6 7 8 9 10 11 12 13
argc [ 4 ] argv [ ]--> [ ]--> [A:\cprog.exe\0] [ ]--> [working\0] [ ]--> [C program\0] [ ]--> [1\0] [NULL] argp [ ]--> [ ]--> [path=A:\;C:\\0] [ ]--> [lib=D:\LIB\0] [ ]--> [include=D:\INCLUDE\0] [ ]--> [conspec=C:\COMMAND.COM\] [NULL] Рис.1. Схема размещения параметров командной строки
argc [ 4 ] argv [ ]—> [ ]—> [A:\cprog.exe\0] [ ]—> [working\0] [ ]—> [C program\0] [ ]—> [1\0] [NULL] argp [ ]—> [ ]—> [path=A:\;C:\\0] [ ]—> [lib=D:\LIB\0] [ ]—> [include=D:\INCLUDE\0] [ ]—> [conspec=C:\COMMAND.COM\] [NULL] Рис.1. Схема размещения параметров командной строки
Операционная система поддерживает передачу значений для параметров argc, argv, argp, а на пользователе лежит ответственность за передачу и использование фактических аргументов функции main.
Следующий пример представляет программу печати фактических аргументов, передаваемых в функцию main из операционной системы и параметров операционной системы.
1 2 3 4 5 6 7 8 9 10 11 12 13 14
Пример: int main ( int argc, char *argv[], char *argp[]) { int i=0; printf ("\n Имя программы %s", argv[0]); for (i=1; i>=argc; i++) printf ("\n аргумент %d равен %s", argv[i]); printf ("\n Параметры операционной системы:"); while (*argp) { printf ("\n %s",*argp); argp++; } return (0); }
Доступ к параметрам операционной системы можно также получить при помощи библиотечной функции geteuv, ее прототип имеет следующий вид:
char *geteuv (const char *varname);
Аргумент этой функции задает имя параметра среды, указатель на значение которой выдаст функция geteuv. Если указанный параметр не определен в среде в данный момент, то возвращаемое значение NULL.
Используя указатель, полученный функцией geteuv, можно только прочитать значение параметра операционной системы, но нельзя его изменить. Для изменения значения параметра системы предназначена функция puteuv.
Компилятор языка СИ строит СИ-программу таким образом, что вначале работы программы выполняется некоторая инициализация, включающая, кроме всего прочего, обработку аргументов, передаваемых функции main, и передачу ей значений параметров среды. Эти действия выполняются библиотечными функциями _setargv и _seteuv, которые всегда помещаются компилятором перед функцией main.
Если СИ-программа не использует передачу аргументов и значений параметров операционной системы, то целесообразно запретить использование библиотечных функций _setargv и _seteuv поместив в СИ-программу перед функцией main функции с такими же именами, но не выполняющие никаких действий (заглушки). Начало программы в этом случае будет иметь вид:
1 2 3 4 5 6 7 8 9 10 11 12 13
_setargv() { return ; /* пустая функция */ } -seteuv() { return ; /* пустая функция */ } int main() { /* главная функция без аргументов */ . . renurn (0); }
В приведенной программе при вызове библиотечных функций _setargv и _seteuv будут использованы функции помещенные в программу пользователем и не выполняющие никаких действий. Это заметно снизит размер получаемого exe-файла.
Добавить комментарий Отменить ответ
Этот сайт использует Akismet для борьбы со спамом. Узнайте как обрабатываются ваши данные комментариев.
Рубрики
- ARM. Учебный курс
- AVR. Учебный курс
- MegaHard Lab
- MSP430. Учебный курс
- Автоэлектроника
- Готовые устройства
- Диагностика и ремонт
- Инструмент
- Книги
- Начинающим
- Новости
- Радиолюбительские Технологии
- Робототехника
- Софт
Карта людей сообщества
Язык Си в примерах/Использование аргументов командной строки
Программы могут принимать аргументы. Ниже приведен пример программы argv , которая печатает список аргументов, которые были переданы ей в командной строке. Пример ее работы:
bash$ ./argv alpha beta gamma last Argument 0: ./argv Argument 1: alpha Argument 2: beta Argument 3: gamma Argument 4: last
/* Build me with gcc -o argv argv.c */ #include int main (int argc, char * argv[]) int i; for( i = 0 ; i argc; i++) printf("Argument %d: %s\n", i, argv[i]); > if(argc == 1) printf("Command line has no additional arguments\n"); > return 0; >
Например стандартная программа ‘ls’ в Linux в качестве аргумента принимает имена директорий, содержимое которых нужно вывести в стандартный поток вывода. Команда
bash$ ls /home/user
выведет содержимое директории ‘/home/user’.
Команда ‘ls’ имеет множество опций, которые можно передавать в командной строке. О них вы можете узнать, запустив команду ‘ls’ с опцией ‘-h’:
bash$ ls -h
Вообще, программа может получать данные из нескольких источников. Наиболее важные источники это:
- аргументы командной строки;
- стандартный поток ввода;
- файлы;
- средства взаимодействия процессов (signals, sockets, messages, . ).
Научимся использовать первый из них.
Подробнее об аргументах командной строки [ править ]
Основной функцией в программе на языке Си является функция main() . Мы уже познакомились с простейшим способом объявления этой функции:
/* * Простейшая форма main() */ int main() // . return 0; >
Для того, чтобы ваша программа могла анализировать параметры, передаваемые ей через командную строку, функцию main() следует описать несколько сложнее:
/* * main() с обработкой параметров */ int main(int argc, char **argv) // . return 0; >
При такой записи, при вызове вашей программы, параметр argc будет содержать количество параметров командной строки плюс один. Действительные параметры нумеруются с единицы по argc-1 включительно (т.е. всего argc-1 параметров), параметр под номером ноль является служебным — он содержит полный путь и имя исполняемого файла вашей программы.
Для доступа к параметру под номером i следует писать argv[i] . Выражение argv[i] — это строка, передаваемая в соответствии с соглашениями языка Си о строках. С ней можно проделывать все операции, как с обычной строкой (её даже можно модифицировать, но это считается дурным тоном!).
Вот еще один пример программы, работающей со своей командной строкой:
Пример 2 [ править ]
/* * Пример программы, работающей со своей командной строкой */ #include #include int main(int argc, char **argv) if(argc 1) printf("syntax : \n\t%s --help or\n\t./p --add [a] [b]\n", argv[0]); return 0; > if(!strcmp(argv[1], "--help")) printf("You requested help message.\n"); > else if(!strcmp(argv[1], "--add")) if(argc 3) printf("'--add' operation requires two parameters.\n"); > else int a, b; if(sscanf(argv[2], "%d", &a) != 1 || sscanf(argv[3], "%d", &b) != 1) printf("'--add' operation requires two integer parameters.\n"); > else printf("%d + %d = %d\n", a, b, a+b); > > > else printf("Unknown parameter: '%s'. Type %s --help for help.\n", argv[1], argv[0]); > return 0; >
Задачи для самостоятельного решения [ править ]
- Напишите программу, которая интерпретирует свои аргументы как целые числа и выводит на стандартный поток вывода их сумму.
- Напишите программу, которая принимает аргумент — имя файла, и выводит содержимое этого файла.
- в текстовом виде, обозначая не ASCII символы знаками вопроса (если дана опция =-text= );
- в шестнадцатиричном виде (если дана опция =-hex=);
- как есть (по умолчанию).
См. также [ править ]
Как передать аргументы в main c
В прошлых темах функция main определялась без параметров. Однако также можно определить данную функцию с параметрами:
int main(int argc, char* argv[]) < // инструкции >
Первый параметр, argc , представляет тип int и хранит количество аргументов командной строки. Второй параметр, argv[] , представляет собой массив указателей и хранит все переданные аргументы командной строки в виде строк. Таким образом, благодаря данным параметрам мы можем при вызове программы в консоли передать ей некоторые данные.
Например, определим следующую программу:
#include int main(int argc, char* argv[]) < // выводим все переданные аргументы в цикле for (int i <>; i < argc; ++i) < std::cout >
В данном случае просто выводим все аргументы командной строки на консоль. Скомпилируем и просто запустим программу, не передавая ей никаких аргументов:
c:\cpp>g++ hello.cpp -o hello & hello hello
В моем случае код программы расположен в файле «hello.cpp» и компилируется в файл с именем hello. После запуска программы, даже если мы не передаем ей никакх аргументов, в массиве argv[] будет как минимум один элемент — название файла программы. То есть в моем случае в массиве будет одна строка «hello». А первый параметр, argc , будет равен 1.
Передадим программе какие-нибудь аргументы
c:\cpp>g++ hello.cpp -o hello & hello Tom 38 hello Tom 38
Здесь программе при запуске передается два значения — «Tom» и «38». Передаваемые аргументы разделяются пробелом. Причем даже если передается число (как в случае с вторым аргументом), то программа все равно получает его в виде строки. Соответственно теперь в массиве argv будет три элемента.