5.8. Параметры функции main()

Теория

Зачем нужен этот пункт

Во многих первых программах функция main записывается без параметров:

int main(void)
{
    return 0;
}

Такой вариант подходит, если программа не должна получать данные при запуске. Но иногда удобно передавать программе информацию прямо из командной строки. Например, имя файла, режим работы, число, путь к каталогу или несколько параметров сразу.

Для этого у функции main могут быть параметры. Они позволяют программе получить доступ к словам, которые пользователь написал после имени исполняемого файла.

После изучения этого пункта нужно понимать:

Обычная форма функции 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

В этом примере:

В 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

Эта программа показывает типичную схему работы с параметрами командной строки:

  1. проверить количество параметров через argc;
  2. взять нужные строки из argv;
  3. при необходимости преобразовать строки к числам;
  4. выполнить основную часть программы.

Параметры с пробелами

Командная строка обычно разделяет аргументы пробелами. Поэтому если написать:

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!

Разберём программу по шагам.

Типичные ошибки

Ошибка 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.

Практические рекомендации

Что нужно запомнить

Самопроверка перед переходом дальше

  1. Для чего функции main нужны параметры?
  2. Что хранится в параметре argc?
  3. Что означает запись char *argv[]?
  4. Что обычно находится в argv[0]?
  5. С какого элемента argv начинаются пользовательские параметры?
  6. Почему при двух пользовательских параметрах argc обычно равно 3?
  7. Почему строку "25" из argv нельзя сразу считать числом типа int?
  8. Что может произойти, если обратиться к argv[1], когда пользователь не передал параметров?
  9. Как передать программе параметр, содержащий пробел?
  10. Для чего используется параметр envp?