5.8. Параметры функции main()
Теория
Зачем нужен этот пункт
Во многих первых программах функция main записывается без параметров:
int main(void)
{
return 0;
}
Такой вариант подходит, если программа не должна получать данные при запуске. Но иногда удобно передавать программе информацию прямо из командной строки. Например, имя файла, режим работы, число, путь к каталогу или несколько параметров сразу.
Для этого у функции main могут быть параметры. Они позволяют программе получить доступ
к словам, которые пользователь написал после имени исполняемого файла.
После изучения этого пункта нужно понимать:
- что такое аргументы командной строки;
- что хранится в параметре
argc; - что хранится в параметре
argv; - почему
argv[0]обычно содержит имя программы; - как проверить количество переданных параметров;
- почему все параметры командной строки сначала являются строками;
- для чего может использоваться параметр
envp.
Обычная форма функции main
Если программа не получает параметры из командной строки, удобно использовать такую запись:
int main(void)
{
return 0;
}
Здесь void в круглых скобках означает, что функция main не принимает параметров.
Возвращаемое значение типа int передаётся операционной системе после завершения программы.
Обычно return 0; означает успешное завершение.
Но если программа должна получить параметры запуска, заголовок функции main записывают иначе:
int main(int argc, char *argv[])
{
return 0;
}
Здесь появляются два параметра: argc и argv.
Что такое командная строка
Командная строка — это строка, из которой операционная система запускает программу. В простейшем случае в ней записано только имя программы.
program.exe
Но после имени программы можно записать дополнительные слова:
program.exe 10 20 data.txt
В этом примере:
program.exe— имя запускаемой программы;10,20,data.txt— параметры, переданные программе.
В Linux или macOS запуск может выглядеть так:
./program 10 20 data.txt
Смысл тот же: сначала указывается имя программы, затем через пробел записываются параметры.
Параметр argc
Параметр argc имеет тип int. Его имя обычно расшифровывают как
argument count, то есть «количество аргументов».
int main(int argc, char *argv[])
{
printf("argc = %d\n", argc);
return 0;
}
Значение argc показывает, сколько строк находится в массиве argv.
Важно: обычно в это количество входит не только то, что пользователь написал после имени программы,
но и само имя программы.
Например, если программа запущена так:
program.exe 10 20 data.txt
то значение argc обычно будет равно 4:
argv[0] - имя программы
argv[1] - "10"
argv[2] - "20"
argv[3] - "data.txt"
Поэтому количество пользовательских параметров часто вычисляют как argc - 1.
Параметр argv
Параметр argv — это массив указателей на строки. Его имя обычно расшифровывают как
argument vector, то есть «массив аргументов».
int main(int argc, char *argv[])
Запись char *argv[] означает: argv — это массив, элементы которого являются
указателями на строки типа char.
Каждый элемент argv[i] указывает на отдельную строку:
argv[0] -- строка с именем программы
argv[1] -- первый параметр после имени программы
argv[2] -- второй параметр
...
argv[argc - 1] -- последний параметр
Так как в Си строки представляются массивами символов, доступ к каждому аргументу выполняется как
к обычной строке. Например, его можно вывести спецификатором %s:
printf("%s\n", argv[1]);
Первый пример: вывод всех параметров командной строки
Следующая программа выводит все строки, которые были переданы в argv.
#include <stdio.h>
int main(int argc, char *argv[])
{
int i;
for (i = 0; i < argc; i++)
printf("argv[%d] -> %s\n", i, argv[i]);
return 0;
}
Пусть программа запущена так:
program.exe 11 22 33
Тогда возможный результат будет таким:
argv[0] -> program.exe
argv[1] -> 11
argv[2] -> 22
argv[3] -> 33
В некоторых системах argv[0] может содержать не просто имя файла, а полный путь к программе.
Например:
C:\VVP\program.exe
Поэтому не стоит строить логику программы на предположении, что argv[0] всегда имеет строго
один и тот же вид. Но обычно он действительно содержит имя или путь запускаемой программы.
Почему параметры командной строки являются строками
Важно запомнить: всё, что приходит через argv, сначала является строкой.
Например, при запуске:
program.exe 123
параметр argv[1] — это не число 123, а строка "123".
Если нужно использовать это значение как число, его надо преобразовать.
Для простого преобразования строки в целое число можно использовать функцию atoi
из заголовочного файла stdlib.h.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
int number;
if (argc < 2)
{
printf("Не передано число.\n");
return 1;
}
number = atoi(argv[1]);
printf("number = %d\n", number);
printf("number * 2 = %d\n", number * 2);
return 0;
}
Пример запуска:
program.exe 15
Результат:
number = 15
number * 2 = 30
Для учебных примеров atoi достаточно понятна, но у неё есть недостаток: она плохо сообщает
об ошибках преобразования. В более серьёзных программах лучше использовать функции вроде
strtol, но для первого знакомства с параметрами main достаточно понять сам принцип:
из командной строки приходят строки, а не готовые числа.
Проверка количества параметров
Программа не должна обращаться к argv[1], argv[2] и другим элементам, если
пользователь их не передал. Иначе программа обратится к несуществующему аргументу.
Поэтому перед использованием параметров командной строки почти всегда проверяют argc.
#include <stdio.h>
int main(int argc, char *argv[])
{
if (argc != 3)
{
printf("Формат запуска:\n");
printf("program.exe имя_файла режим\n");
return 1;
}
printf("Имя файла: %s\n", argv[1]);
printf("Режим: %s\n", argv[2]);
return 0;
}
Здесь программа ожидает ровно два пользовательских параметра:
program.exe data.txt read
Почему проверка выполняется на argc != 3, а не на argc != 2?
Потому что argv[0] тоже учитывается. Значит:
argv[0] - program.exe
argv[1] - data.txt
argv[2] - read
Пример: сложение двух чисел из командной строки
Напишем программу, которая получает два целых числа из командной строки и выводит их сумму.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
int a;
int b;
int sum;
if (argc != 3)
{
printf("Ошибка запуска.\n");
printf("Нужно передать два целых числа.\n");
printf("Пример: program.exe 10 25\n");
return 1;
}
a = atoi(argv[1]);
b = atoi(argv[2]);
sum = a + b;
printf("%d + %d = %d\n", a, b, sum);
return 0;
}
Пример запуска:
program.exe 10 25
Результат:
10 + 25 = 35
Эта программа показывает типичную схему работы с параметрами командной строки:
- проверить количество параметров через
argc; - взять нужные строки из
argv; - при необходимости преобразовать строки к числам;
- выполнить основную часть программы.
Параметры с пробелами
Командная строка обычно разделяет аргументы пробелами. Поэтому если написать:
program.exe hello world
программа получит два отдельных параметра:
argv[1] - "hello"
argv[2] - "world"
Если нужно передать одну строку с пробелом, её обычно заключают в кавычки:
program.exe "hello world"
Тогда программа получит один пользовательский параметр:
argv[1] - "hello world"
Конкретные правила обработки кавычек могут немного зависеть от операционной системы и командной оболочки. Но общее правило полезно запомнить: без кавычек пробел обычно разделяет параметры.
Разные записи параметра argv
В заголовке main можно встретить несколько похожих записей:
int main(int argc, char *argv[])
int main(int argc, char **argv)
Для параметра функции эти записи практически означают одно и то же: argv позволяет работать
с массивом указателей на строки.
В учебных программах запись char *argv[] обычно понятнее, потому что сразу видно:
argv используется как массив.
Третий параметр main: envp
В некоторых реализациях функции main разрешают использовать третий параметр:
int main(int argc, char *argv[], char *envp[])
Параметр envp — это массив указателей на строки, содержащие информацию об окружении,
в котором запущена программа.
Окружение — это набор строк вида:
PATH=...
TEMP=...
HOME=...
USERNAME=...
Каждая такая строка обычно описывает одну переменную среды. Например, переменная PATH
может содержать список каталогов, в которых операционная система ищет исполняемые файлы.
Пример программы, выводящей параметры командной строки и строки окружения:
#include <stdio.h>
int main(int argc, char *argv[], char *envp[])
{
int n;
printf("Программа: %s\n", argv[0]);
printf("Число параметров при запуске: %d\n", argc - 1);
for (n = 1; n < argc; n++)
printf("%d-й параметр: %s\n", n, argv[n]);
printf("\nСписок переменных окружения:\n");
for (n = 0; envp[n] != NULL; n++)
printf("%s\n", envp[n]);
return 0;
}
В обычных учебных программах третий параметр используется редко. Намного чаще применяются только
argc и argv.
Также важно учитывать, что вариант с envp не является таким же универсальным, как
стандартные формы int main(void) и int main(int argc, char *argv[]).
Поэтому, если окружение не требуется, лучше не добавлять третий параметр.
Мини-разбор программы
Разберём программу, которая принимает имя пользователя и число повторений, а затем несколько раз выводит приветствие.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
int count;
int i;
if (argc != 3)
{
printf("Формат запуска:\n");
printf("program.exe имя количество\n");
return 1;
}
count = atoi(argv[2]);
if (count <= 0)
{
printf("Количество должно быть положительным.\n");
return 1;
}
for (i = 0; i < count; i++)
printf("Привет, %s!\n", argv[1]);
return 0;
}
Пример запуска:
program.exe Danya 3
Результат:
Привет, Danya!
Привет, Danya!
Привет, Danya!
Разберём программу по шагам.
-
argcдолжен быть равен3, потому что ожидается имя программы, имя пользователя и количество повторений. -
argv[1]содержит имя пользователя. -
argv[2]содержит количество повторений, но в виде строки. -
atoi(argv[2])преобразует строку в целое число. - Если число неположительное, программа выводит сообщение об ошибке.
-
Цикл
forвыводит приветствие нужное количество раз.
Типичные ошибки
Ошибка 1. Забыть, что argv[0] тоже считается
Если программа ожидает два пользовательских параметра, проверять нужно не argc == 2,
а argc == 3.
if (argc != 3)
{
printf("Нужно передать два параметра.\n");
return 1;
}
Ошибка 2. Обратиться к argv[1] без проверки argc
int main(int argc, char *argv[])
{
printf("%s\n", argv[1]); /* Опасно, если параметр не передан */
return 0;
}
Правильнее сначала проверить количество аргументов:
if (argc < 2)
{
printf("Параметр не передан.\n");
return 1;
}
Ошибка 3. Считать argv[1] числом
/* argv[1] - это строка, а не int */
printf("%d\n", argv[1]);
Если нужен числовой тип, строку надо преобразовать:
int n;
n = atoi(argv[1]);
printf("%d\n", n);
Ошибка 4. Не учитывать пробелы в параметрах
Запуск:
program.exe Ivan Petrov
передаст два параметра: Ivan и Petrov. Если нужно передать одно полное имя,
используйте кавычки:
program.exe "Ivan Petrov"
Ошибка 5. Считать envp обязательным
В большинстве программ третий параметр не нужен. Для обычной передачи параметров запуска достаточно
argc и argv.
Практические рекомендации
-
Используйте
int main(void), если программе не нужны параметры командной строки. -
Используйте
int main(int argc, char *argv[]), если программе нужно получать параметры при запуске. -
Всегда проверяйте
argcперед обращением кargv[1],argv[2]и следующим элементам. -
Помните, что пользовательские параметры начинаются с
argv[1], потому чтоargv[0]обычно содержит имя программы. - Все параметры командной строки сначала обрабатывайте как строки.
-
Для простых учебных программ можно использовать
atoi, но в серьёзных программах лучше применять более строгие функции преобразования и проверку ошибок. - Если параметр может содержать пробелы, при запуске программы заключайте его в кавычки.
-
Не используйте
envpбез необходимости: чаще всего он не нужен начинающему программисту.
Что нужно запомнить
-
Функция
mainможет принимать параметры командной строки. -
argcхранит количество элементов массиваargv. -
argv— массив указателей на строки. -
argv[0]обычно содержит имя или путь запускаемой программы. -
argv[1],argv[2]и далее содержат параметры, записанные после имени программы. -
Количество пользовательских параметров обычно равно
argc - 1. -
Все значения в
argvявляются строками, даже если внешне они похожи на числа. -
Перед использованием параметров нужно проверять
argc. -
envpможет передавать программе строки окружения, но используется редко.
Самопроверка перед переходом дальше
- Для чего функции
mainнужны параметры? - Что хранится в параметре
argc? - Что означает запись
char *argv[]? - Что обычно находится в
argv[0]? - С какого элемента
argvначинаются пользовательские параметры? - Почему при двух пользовательских параметрах
argcобычно равно3? - Почему строку
"25"изargvнельзя сразу считать числом типаint? - Что может произойти, если обратиться к
argv[1], когда пользователь не передал параметров? - Как передать программе параметр, содержащий пробел?
- Для чего используется параметр
envp?