Аргументы функции c. Аргументы функции main
Однажды заинтересовался, содержимым стека функции main процесса в linux. Провел некоторые изыскания и теперь представляю вам результат.
Варианты описания функции main:
1. int main()
2. int main(int argc, char **argv)
3. int main(int argc, char **argv, char **env)
4. int main(int argc, char **argv, char **env, ElfW(auxv_t) auxv)
5. int main(int argc, char **argv, char **env, char **apple)
Argc - число параметров
argv - нуль-терминальный массив указателей на строки параметров командной строки
env - нуль-терминальный массив указателей на строки переменных окружения. Каждая строка в формате ИМЯ=ЗНАЧЕНИЕ
auxv - массив вспомогательных значение (доступно только для PowerPC )
apple - путь к исполняемому файлу (в MacOS и Darwin )
Вспомогательный вектор - массив с различной дополнительной информацией, такой как эффективный идентификатор пользователя, признак setuid бита, размер страницы памяти и т.п.
Размер сегмента стека можно глянуть в файле maps:
cat /proc/10918/maps
…
7ffffffa3000-7ffffffff000 rw-p 00000000 00:00 0
…
Перед тем, как загрузчик передаст управление в main, он инициализирует содержимое массивов параметров командной строки, переменных окружения, вспомогательный вектор.
После инициализации верхняя часть стека выглядит примерно так, для 64битной версии.
Старший адрес сверху.
1. | 0x7ffffffff000 | Верхняя точка сегмента стека. Обращение вызывает segfault | |||
0x7ffffffff0f8 | NULL | void* | 8 | 0x00" | |
2. | filename | char | 1+ | «/tmp/a.out» | |
char | 1 | 0x00 | |||
... | |||||
env | char | 1 | 0x00 | ||
... | |||||
char | 1 | 0x00 | |||
3. | 0x7fffffffe5e0 | env | char | 1 | .. |
char | 1 | 0x00 | |||
... | |||||
argv | char | 1 | 0x00 | ||
... | |||||
char | 1 | 0x00 | |||
4. | 0x7fffffffe5be | argv | char | 1+ | «/tmp/a.out» |
5. | Массив случайной длины | ||||
6. | данные для auxv | void* | 48" | ||
AT_NULL | Elf64_auxv_t | 16 | {0,0} | ||
... | |||||
auxv | Elf64_auxv_t | 16 | |||
7. | auxv | Elf64_auxv_t | 16 | Ex.: {0x0e,0x3e8} | |
NULL | void* | 8 | 0x00 | ||
... | |||||
env | char* | 8 | |||
8. | 0x7fffffffe308 | env | char* | 8 | 0x7fffffffe5e0 |
NULL | void* | 8 | 0x00 | ||
... | |||||
argv | char* | 8 | |||
9. | 0x7fffffffe2f8 | argv | char* | 8 | 0x7fffffffe5be |
10. | 0x7fffffffe2f0 | argc | long int | 8" | число аргументов + 1 |
11. | Локальные переменные и аргументы, функций вызываемых до main | ||||
12. | Локальные переменные main | ||||
13. | 0x7fffffffe1fc | argc | int | 4 | число аргументов + 1 |
0x7fffffffe1f0 | argv | char** | 8 | 0x7fffffffe2f8 | |
0x7fffffffe1e8 | env | char** | 8 | 0x7fffffffe308 | |
14. | Переменные локальных функций |
" - описания полей в документах не нашел, но в дампе явно видны.
Для 32 битов не проверял, но скорее всего достаточно только разделить размеры на два.
1. Обращение к адресам, выше верхней точки, вызывает Segfault.
2. Строка, содержащая путь к исполняемому файлу.
3. Массив строк с переменными окружения
4. Массив строк с параметрами командной строки
5. Массив случайной длинны. Его выделение можно отключить командами
sysctl -w kernel.randomize_va_space=0
echo 0 > /proc/sys/kernel/randomize_va_space
6. Данные для вспомогательного вектора (например строка «x86_64»)
7. Вспомогательный вектор. Подробнее ниже.
8. Нуль-терминальный массив указателей на строки переменных окружения
9. Нуль-терминальный массив указателей на строки параметров командной строки
10.Машинное слово, содержащее число параметров командной строки (один из аргументов «старших» функций см. п. 11)
11.Локальные переменные и аргументы, функций вызываемых до main(_start,__libc_start_main..)
12.Переменные, объявленные в main
13.Аргументы функции main
14.Переменные и аргументы локальных функций.
Вспомогательный вектор
Для i386 и x86_64 нельзя получить адрес первого элемента вспомогательного вектора, однако содержимое этого вектора можно получить другими способами. Один из них - обратиться к области памяти, лежащей сразу за массивом указателей на строки переменных окружения.
Это должно выглядеть примерно так:
#include
Структуры Elf{32,64}_auxv_t описаны в /usr/include/elf.h. Функции заполнения структур в linux-kernel/fs/binfmt_elf.c
Второй способ получить содержимое вектора:
hexdump /proc/self/auxv
Самый удобочитаемое представление получается установкой переменной окружения LD_SHOW_AUXV.
LD_SHOW_AUXV=1 ls
AT_HWCAP: bfebfbff //возможности процессора
AT_PAGESZ: 4096 //размер страницы памяти
AT_CLKTCK: 100 //частота обновления times()
AT_PHDR: 0x400040 //информация о заголовке
AT_PHENT: 56
AT_PHNUM: 9
AT_BASE: 0x7fd00b5bc000 //адрес интерпретатора, то бишь ld.so
AT_FLAGS: 0x0
AT_ENTRY: 0x402490 //точка входа в программу
AT_UID: 1000 //идентификаторы пользователя и группы
AT_EUID: 1000 //номинальные и эффективные
AT_GID: 1000
AT_EGID: 1000
AT_SECURE: 0 //поднят ли setuid флаг
AT_RANDOM: 0x7fff30bdc809 //адрес 16 случайных байт,
генерируемых при запуске
AT_SYSINFO_EHDR: 0x7fff30bff000 //указатель на страницу, используемую для
//системных вызовов
AT_EXECFN: /bin/ls
AT_PLATFORM: x86_64
Слева - название переменной, справа значение. Все возможные названия переменных и их описание можно глянуть в файле elf.h. (константы с префиксом AT_)
Возвращение из main()
После инициализации контекста процесса управление передается не в main(), а в функцию _start().
main() вызывает уже из __libc_start_main. Эта последняя функция имеет интересную особенность - ей передается указатель на функцию, которая должна быть выполнена после main(). И указатель этот передается естественно через стек.
Вообще аргументы __libc_start_main имеют вид, согласно файла glibc-2.11/sysdeps/ia64/elf/start.S
/*
* Arguments for __libc_start_main:
* out0: main
* out1: argc
* out2: argv
* out3: init
* out4: fini //функция вызываемая после main
* out5: rtld_fini
* out6: stack_end
*/
Т.е. чтобы получить адрес указателя fini нужно сместиться на два машинных слова от последней локальной переменной main.
Вот что получилось(работоспособность зависит от версии компилятора):
#include
Надеюсь, было интересно.
Удач.
Спасибо пользователю Xeor за полезную наводку.
При автоматизированном создании консольного приложения в языке программирования С++, автоматически создается главная функция очень похожая на эту:
int
main(int
argc, char
* argv)
{…}
Заголовок функции содержит сигнатуру главной функции main()
с аргументами argс
и argv
.
Если программу запускать через командную строку, то существует возможность передать какую-либо информацию этой программе. Для этого существуют аргументы командной строки argc
и argv
.
Параметр argc
имеет тип int
, и содержит количество параметров, передаваемых в функцию main
. Причем argc
всегда не меньше 1, даже когда функции main
не передается никакой информации, так как первым параметром считается имя приложения.
Параметр argv
представляет собой массив указателей на строки. Через командную строку можно передать только данные строкового типа.
При запуске программы через командную строку Windows можно передавать ей некоторую информацию. При этом командная строка будет иметь вид:
Диск:\путь\имя.exe аргумент1 аргумент2 …
Аргументы командной строки разделяются одним или несколькими пробелами.
Аргумент argv содержит полное имя приложения:
#include
using namespace
std;
cout << argv << endl;
Return
0;
}
Результат выполнения
Пример
: вычисление произведения двух целых чисел
В программе используется функция преобразования строки в целое число StrToInt()
отсюда .
#include
using namespace
std;
int
StrToInt(char
*s) {…}
int
main(int
argc, char
* argv) {
Int a = 0, b=0;
If (argc > 1)
a = StrToInt(argv);
If (argc > 2)
b = StrToInt(argv);
cout << a <<«*» << b << «= « << a*b << endl;
Return
0;
}
Запуск программы осуществляется как
Результат выполнения
Отладка программы с аргументами командной строки
Для передачи аргументов командной строки при отладке программы необходимо обратиться к меню Свойства
проекта.
На вкладке Свойства конфигурации ->Отладка
выбрать Аргументы команды
и задать их значения.
При запуске программы в режиме отладки введенные аргументы будут восприниматься программой как аргументы командной строки.
Borland С++ поддерживает три аргумента main(). Первые два - это традиционные argc и argv. Это единственные аргументы функции main(), определяемые стандартом ANSI С. Они позволяют передавать аргументы командной строки в программу. Аргументы командной строки - это информация, следующая за именем программы в командной строке операционной системы. Например, когда программа компилируется с помощью строчного компилятора Borland, набирается, как правило, bcc имя_ программы
Где имя_программы - это программа, которую необходимо откомпилировать. Имя программы передается компилятору в качестве аргумента.
Параметр argc содержит число аргументов командной строки и является целым числом. Он всегда равен, по крайней мере, 1, поскольку имя программы квалифицируется как первый аргумент. Параметр argv - это указатель на массив символьных указателей. Каждый элемент данного массива указывает на аргумент командной строки. Все аргументы командной строки - это строки. Все числа конвертируются программой во внутренний формат. Следующая программа выводит «Hello», а затем имя пользователя, если его набрать прямо за именем программы:
#include
{
if(argc!=2)
{
printf ("You forgot to type your name\n");
return 1;
}
printf("Hello %s", argv);
return 0;
}
Если назвать данную программу name, а имя пользователя Сергей, то для запуска программы следует набрать:
name Сергей.
В результате работы программы появится:
«Hello Сергей».
Аргументы командной строки должны отделяться пробелами или табуляциями. Запятые, точки с запятыми и им подобные символы не рассматриваются как разделители. Например:
Состоит из трех строк, в то время как
Herb,Rick,Fred
Это одна строка - запятые не являются разделителями.
Если необходимо передать строку, содержащую пробелы или табуляции в виде одного аргумента, следует ее заключить в двойные кавычки. Например, это один аргумент:
"this is a test"
Важно правильно объявить argv. Наиболее типичным методом является:
Пустые скобки указывают на то, что массив не имеет фиксированной длины. Можно получить доступ к отдельным элементам с помощью индексации argv. Например, argv указывает на первую строку, всегда содержащую имя программы. argv указывает на следующую строку и так далее.
Ниже приведен небольшой пример по использованию аргументов командной строки. Он отсчитывает в обратном порядке от значения, указанного в командной строке, и при достижении нуля подает сигнал. Обратим внимание, что первый аргумент содержит число, преобразованное в целое число с использованием стандартной функции 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,"display")) disp = 1;
else disp = 0;
for(count=atoi(argv); count; -count)
if (disp) printf("%d ", count);
printf("%c", "\a"); /* на большинстве компьютеров это звонок */
return 0;
}
Обратим внимание, что если не указаны аргументы, появляется сообщение об ошибке. Это наиболее типично для программ, использующих аргументы командной строки для выдачи инструкций, если была попытка запустить программу без правильной информации.
Для доступа к отдельным символам командной строки следует добавить второй индекс к argv. Например, следующая программа выводит все аргументы, с которыми она вызывалась, по одному символу за раз:
#include
int main(int argc, char *argv)
{
int t, i;
for(t=0; t
i = 0;
while(argv[t][i])
{
printf("%c", argv[t][i]);
}
printf (" ");
}
return 0;
}
Надо помнить, что первый индекс предназначен для доступа к строке, а второй - для доступа к символу строки.
Обычно 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
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;
}
Иногда при запуске программы бывает полезно передать ей какую-либо информацию. Обычно такая информация передается функции main() с помощью аргументов командной строки. Аргумент командной строки - это информация, которая вводится в командной строке операционной системы вслед за именем программы. Например, чтобы запустить компиляцию программы, необходимо в командной строке после подсказки набрать примерно следующее:
Cc имя_программы
имя_программы
представляет собой аргумент командной строки, он указывает имя той программы, которую вы собираетесь компилировать.
Чтобы принять аргументы командной строки, используются два специальных встроенных аргумента: argc и argv . Параметр argc содержит количество аргументов в командной строке и является целым числом, причем он всегда не меньше 1, потому что первым аргументом считается имя программы. А параметр argv является указателем на массив указателей на строки. В этом массиве каждый элемент указывает на какой-либо аргумент командной строки. Все аргументы командной строки являются строковыми, поэтому преобразование каких бы то ни было чисел в нужный двоичный формат должно быть предусмотрено в программе при ее разработке.
Вот простой пример использования аргумента командной строки. На экран выводятся слово Привет и ваше имя, которое надо указать в виде аргумента командной строки.
#include
Если вы назвали эту программу name (имя) и ваше имя Том, то для запуска программы следует в командную строку ввести name Том. В результате выполнения программы на экране появится сообщение Привет, Том.
Во многих средах все аргументы командной строки необходимо отделять друг от друга пробелом или табуляцией. Запятые, точки с запятой и тому подобные символы разделителями не считаются. Например,
Run Spot, run
состоит из трех символьных строк, в то время как
Эрик, Рик, Фред
представляет собой одну символьную строку - запятые, как правило, разделителями не считаются.
Если в строке имеются пробелы, то, чтобы из нее не получилось несколько аргументов, в некоторых средах эту строку можно заключать в двойные кавычки. В результате вся строка будет считаться одним аргументом. Чтобы подробнее узнать, как в вашей операционной системе задаются параметры командной строки, изучите документацию этой системы.
Очень важно правильно объявлять argv . Вот как это делают чаще всего:
Char *argv;
Пустые квадратные скобки указывают на то, что у массива неопределенная длина. Теперь получить доступ к отдельным аргументам можно с помощью индексации массива argv . Например, argv указывает на первую символьную строку, которой всегда является имя программы; argv указывает на первый аргумент и так далее.
Другим небольшим примером использования аргументов командной строки является приведенная далее программа countdown (счет в обратном порядке). Эта программа считает в обратном порядке, начиная с какого-либо значения (указанного в командной строке), и подает звуковой сигнал, когда доходит до 0. Обратите внимание, что первый аргумент, содержащий начальное значение, преобразуется в целое значение с помощью стандартной функции atoi() . Если вторым аргументом командной строки (а если считать аргументом имя программы, то третьим) является строка «display» (вывод на экран), то результат отсчета (в обратном порядке) будет выводиться на экран.
/* Программа счета в обратном порядке. */
#include
Обратите внимание, если аргументы командной строки не будут указаны, то будет выведено сообщение об ошибке. В программах с аргументами командной строки часто делается следующее: в случае, когда пользователь запускает эти программы без ввода нужной информации, выводятся инструкции о том, как правильно указывать аргументы.
Чтобы получить доступ к отдельному символу одного из аргументов командной строки, введите в argv второй индекс. Например, следующая программа посимвольно выводит все аргументы, с которыми ее вызвали:
#include Помните, первый индекс argv обеспечивает доступ к строке, а второй индекс - доступ к ее отдельным символам. Обычно argc и argv используют для того, чтобы передать программе начальные команды, которые понадобятся ей при запуске. Например, аргументы командной строки часто указывают такие данные, как имя файла, параметр или альтернативное поведение. Использование аргументов командной строки придает вашей программе «профессиональный внешний вид» и облегчает ее использование в пакетных файлах. Имена argc и argv являются традиционными, но не обязательными. Эти два параметра в функции main() вы можете назвать как угодно. Кроме того, в некоторых компиляторах для main() могут поддерживаться-дополнительные аргументы, поэтому обязательно изучите документацию к вашему компилятору. Когда для программы не требуются параметры командной строки, то чаще всего явно декларируют функцию main() как не имеющую параметров. В таком случае в списке параметров этой функции используют ключевое слово void . Теги: Параметры командной строки
С
и - компилируемый язык. После сборки программа представляет собой исполняемый файл (мы не рассматриваем создание динамических библиотек,
драйверов и т.д.). Наши программы очень простые и не содержат библиотек времени выполнения (Runtime libraries), поэтому могут быть перенесены на компьютер с такой же
операционной системой (и подобной архитектурой) и там запущены. Программа во время запуска может принимать параметры. Они являются аргументами функции main.
Общий вид функции main следующий Void main(int argc, char **argv) {
...
}
Первым аргументом argc является число переданных функции параметров. Второй аргумент – массив строк – собственно сами параметры. Так как параметры у функции могут
быть любыми, то они передаются как строки, и уже сама программа должна их разбирать и приводить к нужному типу. Первым аргументом (argv) всегда является имя программы. При этом имя выводится в зависимости от того, откуда была запущена программа.
#include Теперь научимся немного работать с командной строкой. Это понадобится для того, чтобы передавать аргументы нашей программе.
Сочетание клавиш Win+R вызывает окно "Выполнить". Наберите в нём cmd и вы откроете командную строку. Также можно найти cmd.exe поиском в меню Пуск.
В юникс-подобных операционных системах можно вызвать программу "терминал". Мы не будем изучать сколько-нибудь много команд. Только те, которые понадобятся в работе. Стандартная для всех операционных систем команда cd осуществляет переход к нужной папке. Существует два зарезервированных имени - . (точка) и.. (две точки). Точка - это имя текущей папки.
Никуда не переходит
Обращение к родительской папке
Переход в родительскую папку
Для перехода по нужному пишется cd адрес. Например, нужно перейти на windows в папку C:\Windows\System32
Cd C:\Windows\System32
В линуксе если нужно перейти в папку /var/mysql
Cd /var/mysql
Если путь содержит пробелы, то он пишется в двойных кавычках
Cd "D:\Docuents and Settings\Prolog"
Терминал имеет следующие полезные особенности: если нажать стрелку вверх, по появится предыдущая выполненная команда. Если нажать tab, то терминал
попытается дополнить строку до известной ему команды, или дополнить путь, перебирая все папки и файлы в текущей папке.
Ещё одна важная команда dir на windows и ls на linux, выводит на консоль содержимое текущей папки (той папки, в которой вы находитесь в данный момент) Ваша программа вернула своё полное имя. Перейдите в папку, где располагается ваша программа и посмотрите её содержимое Теперь, после того, как мы перешли в нашу папку, можно выполнить нашу программу. Для этого наберите её имя. Заметьте - имя изменилось. Так как программа вызывается из своей папки, то выводится относительно имя. Теперь изменим программу и сделаем так, чтобы она выводила все
аргументы. которые ей переданы.
#include Соберите проект. Перед сборкой убедитесь, что программа закрыта. Теперь вызовите программу, передав ей разные аргументы. Для этого напишите имя программы и через пробел аргументы Давайте теперь напишем программу, которая получает два аргумента числа и выводит их сумму
#include Соберём и вызовем Таким образом работает большинство программ. Кликая на ярлык, вы вызываете программу, на которую он ссылается. Большинство программ также принимают различные аргументы. Например,
можно вызвать браузер firefox из командной строки и передать аргументы
Многие стандартные команды также имеют параметры. В windows принято, что они начинаются с прямого слеша, в юниксе с минуса или двух минусов. Например
Выводит только папки, а в терминале linux
Ls -l
выводит все файлы и папки с указанием атрибутов Для просмотра дополнительных команд windows наберите в командной строке help или смотрите руководство (его легко найти в интернете). Для линукса команд и их опций гораздо больше, а некоторые из них являются самостоятельными языками программирования, так что стоит выучить хотя бы минимальный набор и их опции.Параметры командной строки
Наберите cd C:\
нажимайте tab и смотрите, что происходит.
firefox.exe "www.mozilla.org" "сайт" и он сразу же откроет в двух вкладках сайты по указанным адресам.