Язык программирования C++. Вводный курс

Функция main(): разбор параметров командной строки


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

prog -d -o of lie dataO

Фактические параметры являются аргументами функции main() и могут быть получены из массива C-строк с именем argv; мы покажем, как их использовать.

Во всех предыдущих примерах определение main()

содержало пустой список:

int main() { ... }

Развернутая сигнатура main()

позволяет получить доступ к параметрам, которые были заданы пользователем в командной строке:

int main( int argc, char *argv[] ){...}

argc

содержит их количество, а argv – C-строки, представляющие собой отдельные значения (в командной строке они разделяются пробелами). Скажем, при запуске команды

prog -d -o ofile data0

argc



получает значение 5, а argv

включает следующие строки:

argv[ 0 ] = "prog";

argv[ 1 ] = "-d";

argv[ 2 ] = "-o";

argv[ 3 ] = "ofile";

argv[ 4 ] = "dataO";

В argv[0]

всегда входит имя команды (программы). Элементы с индексами от 1 до argc-1

служат параметрами.

Посмотрим, как можно извлечь и использовать значения, помещенные в argv. Пусть программа из нашего примера вызывается таким образом:

prog [-d] [-h] [-v]

     [-o output_file] [-l limit_value]

     file_name

     [ file_name [file_name [ ... ]]]

Параметры в квадратных скобках являются необязательными. Вот, например, запуск программы с их минимальным количеством – одним лишь именем файла:

prog chap1.doc

Но можно запускать и так:

prog -l 1024 -o chap1-2.out chapl.doc chap2.doc

prog d chap3.doc

prog -l 512 -d chap4.doc

При разборе параметров командной строки выполняются следующие основные шаги:

1.      По очереди извлечь каждый параметр из argv. Мы используем для этого цикл for с начальным индексом 1

(пропуская, таким образом, имя программы):

for ( int ix = 1; ix < argc; ++ix ) {

    char *pchar = argv[ ix ];

    // ...

}

2.      Определить тип параметра. Если строка начинается с дефиса (-), это одна из опций { h, d, v, l, o}. В противном случае это может быть либо значение, ассоциированное с опцией (максимальный размер для -l, имя выходного файла для -o), либо имя входного файла. Чтобы определить, начинается ли строка с дефиса, используем инструкцию switch:




switch ( pchar[ 0 ] ) {

   case '-': {

     //  -h, -d, -v, -l, -o

   }

   default: {

     // обработаем максимальный размер для опции -1

     //            имя выходного файла для       -o

     //            имена входных файлов ...

   }
}

Реализуем обработку двух случаев пункта 2.

Если строка начинается с дефиса, мы используем switch по следующему символу для определения конкретной опции. Вот общая схема этой части программы:



case '-': {

  switch( pchar[ 1 ] )

  {

    case 'd':

      // обработка опции debug

      break;

    case 'v':

      // обработка опции version

      break;

    case 'h':

      // обработка опции help

      break;

    case 'o':

      // приготовимся обработать выходной файл

      break;

    case 'l':

      // приготовимся обработать макс.размер

      break;

    default:

      // неопознанная опция:

      // сообщить об ошибке и завершить выполнение

  }
}

Опция -d

задает необходимость отладки. Ее обработка заключается в присваивании переменной с объявлением

bool debug_on = false;

значения true:



case 'd':

  debug_on = true;
break;

В нашу программу может входить код следующего вида:



if ( debug_on )
    display_state_elements( obj );

Опция -v

выводит номер версии программы и завершает исполнение:



case 'v':

  cout << program_name << "::"

       << program_version << endl;
  return 0;

Опция -h

запрашивает информацию о синтаксисе запуска и завершает исполнение. Вывод сообщения и выход из программы выполняется функцией usage():



case 'h':

  // break не нужен: usage() вызывает exit()
  usage();

Опция -o

сигнализирует о том, что следующая строка содержит имя выходного файла. Аналогично опция -l

говорит, что за ней указан максимальный размер. Как нам обработать эти ситуации?

Если в строке параметра нет дефиса, возможны три варианта: параметр содержит имя выходного файла, максимальный размер или имя входного файла. Чтобы различать эти случаи, присвоим true



переменным, отражающим внутреннее состояние:



// если ofi1e_on==true,

// следующий параметр - имя выходного файла

bool ofi1e_on = false;

// если ofi1e_on==true,

// следующий параметр - максимальный размер
bool limit_on = false;

Вот обработка опций -l и -o в нашей инструкции switch:



case 'l':

  limit_on = true;

  break;

case 'o':

  ofile_on = true;
  break;

Встретив строку, не начинающуюся с дефиса, мы с помощью переменных состояния можем узнать ее содержание:



// обработаем максимальный размер для опции -1

//            имя выходного файла для       -o

//            имена входных файлов ...

default: {

   // ofile_on включена, если -o встречалась

   if ( ofile_on ) {

     // обработаем имя выходного файла

     // выключим ofile_on

   }

   else if ( limit_on ) { // если -l встречалась

     // обработаем максимальный размер

     // выключим limit_on

   } else {

     // обработаем имя входного файла

   }
}

Если аргумент является именем выходного файла, сохраним это имя и выключим ofile_on:



if ( ofile_on ) {

  ofile_on = false;

  ofile = pchar;
}

Если аргумент задает максимальный размер, мы должны преобразовать строку встроенного типа в представляемое ею число. Сделаем это с помощью стандартной функции atoi(), которая принимает строку в качестве аргумента и возвращает int

(также существует функция atof(), возвращающая double). Для использования atoi()

включим заголовочный файл ctype.h. Нужно проверить, что значение максимального размера неотрицательно и выключить limit_on:



// int limit;

else

if ( limit_on ) {

  limit_on = false;

  limit = atoi( pchar );

  if ( limit < 0 ) {

    cerr << program_name << "::"

         << program_version << " : error: "

         << "negative value for limit.\n\n";

    usage( -2 );

  }
}

Если обе переменных состояния равны false, у нас есть имя входного файла. Сохраним его в векторе строк:



else
<


  file_names.push_back( string( pchar ));

При обработке параметров командной строки важен способ реакции на неверные опции. Мы решили, что задание отрицательной величины в качестве максимального размера будет фатальной ошибкой. Это приемлемо или нет в зависимости от ситуации. Также можно распознать эту ситуацию как ошибочную, выдать предупреждение и использовать ноль или какое-либо другое значение по умолчанию.

Слабость нашей реализации становится понятной, если пользователь небрежно относится к пробелам, разделяющим параметры. Скажем, ни одна из следующих двух строк не будет обработана:



prog - d dataOl
prog -oout_file dataOl

(Оба случая мы оставим для упражнений в конце раздела.)

Вот полный текст нашей программы. (Мы добавили инструкции печати для трассировки выполнения.)



#include <iostream>

#include <string>

#include <vector>

#include <ctype.h>

const char *const program_name = "comline";

const char *const program_version = "version 0.01 (08/07/97)";

inline void usage( int exit_value = 0 )

{

  // печатает отформатированное сообщение о порядке вызова

  // и завершает программу с кодом exit_value ...

  cerr << "порядок вызова:\n"

       << program_name << " "

       << "[-d] [-h] [-v] \n\t"

       << "[-o output_file] [-l limit] \n\t"

       << "file_name\n\t[file_name [file_name [ ... ]]]\n\n"

       << "где [] указывает на необязательность опции:\n\n\t"

       << "-h: справка.\n\t\t"

       << "печать этого сообщения и выход\n\n\t"

       << "-v: версия.\n\t\t"

       << "печать информации о версии программы и выход\n\n\t"

       << "-d: отладка.\n\t\t включает отладочную печать\n\n\t"

       << "-l limit\n\t\t"

       << "limit должен быть неотрицательным целым числом\n\n\t"

       << "-o ofile\n\t\t"

       << "файл, в который выводится результат\n\t\t"

       << "по умолчанию результат записывается на стандартный вывод\n\n"

       << "file_name\n\t\t"

       << "имя подлежащего обработке файла\n\t\t"

       << "должно быть задано хотя бы одно имя --\n\t\t"

       << "но максимальное число не ограничено\n\n"

       << "примеры:\n\t\t"

       << "$command chapter7.doc\n\t\t"

       << "$command -d -l 1024 -o test_7_8 "

       << "chapter7.doc chapter8.doc\n\n";

  exit( exit_value );

}

int main( int argc, char* argv[] )

{

  bool debug_on = false;

  bool ofile_on = false;

  bool limit_on = false;

  int limit = -1;

  string ofile;

  vector<string> file_names;

  cout << "демонстрация обработки параметров в командной строке:\n"

       << "argc: " << argc << endl;

  for ( int ix = 1; ix < argc; ++ix )

  {

    cout << "argv[ " << ix << " ]: "

         << argv[ ix ] << endl;

    char *pchar = argv[ ix ];

    switch ( pchar[ 0 ] )

    {

      case '-':

      {

        cout << "встретился \'-\'\n";

        switch( pchar[ 1 ] )

        {

          case 'd':

            cout << "встретилась -d: "

                 << "отладочная печать включена\n";

            debug_on = true;

            break;

          case 'v':

            cout << "встретилась -v: "

                 << "выводится информация о версии\n";

            cout << program_name

                 << " ::  "

                 << program_version

                 << endl;

            return 0;

          case 'h':

            cout << "встретилась -h: "

                 << "справка\n";

            // break не нужен: usage() завершает программу

            usage();

          case 'o':

            cout << "встретилась -o: выходной файл\n";

            ofile_on = true;

            break;

          case 'l':

            cout << "встретилась -l: "

                 << "ограничение ресурса\n";

            limit_on = true;

            break;

          default:

            cerr << program_name

                 << " : ошибка : "

                 << "неопознанная опция: - "

                 << pchar << "\n\n";

            // break не нужен: usage() завершает программу

            usage( -1 );

        }

        break;

      }

      default: // либо имя файла

        cout << "default: параметр без дефиса: "

             << pchar << endl;

        if ( ofile_on ) {

          ofile_on = false;

          ofile = pchar;

        }

        else

        if ( limit_on ) {

          limit_on = false;

          limit = atoi( pchar );

          if ( limit < 0 ) {

            cerr << program_name

                 << " : ошибка : "

                 << "отрицательное значение limit.\n\n";

            usage( -2 );

          }

        }

        else file_names.push_back( string( pchar ));

        break;

    }

  }

  if ( file_names.empty() ) {

    cerr << program_name

         << " : ошибка : "

         << "не задан ни один входной файл.\n\n";

    usage( -3 );

  }

  if ( limit != -1 )

    cout << "Заданное пользователем значение limit: "

         << limit << endl;

  if ( ! ofile.empty() )

    cout << "Заданный пользователем выходной файл: "

         << ofile << endl;

  cout << (file_names.size() == 1 ? "Файл, " : "Файлы, ")

       << "подлежащий(е) обработке:\n";

  for ( int inx = 0; inx < file_names.size(); ++inx )

    cout << "\t" << file_names[ inx ] << endl;
}

a.out -d -l 1024 -o test_7_8 chapter7.doc    chapters.doc

Вот трассировка обработки параметров командной строки:

демонстрация обработки параметров в командной строке:

argc: 8

argv[ 1 ]: -d

встретился '-'

встретилась -d: отладочная печать включена

argv[ 2 ]: -l

встретился '-'

встретилась -l: ограничение ресурса

argv[ 3 ]: 1024

default: параметр без дефиса: 1024

argv[ 4 ]: -o

встретился '-'

встретилась -o: выходной файл

argv[ 5 ]: test_7_8

default: параметр без дефиса: test_7_8

argv[ 6 ]: chapter7.doc

default: параметр без дефиса: chapter7.doc

argv[ 7 ]: chapter8.doc

default: параметр без дефиса: chapter8.doc

Заданное пользователем значение limit: 1024

Заданный пользователем выходной файл: test_7_8

Файлы, подлежащий(е) обработке:

        chapter7.doc

        chapter8.doc


Содержание раздела