Wyszukiwanie w witrynie

Krótka analiza opcji przy użyciu getopt w C


Użyj wiersza poleceń, aby zwiększyć elastyczność swoich programów, umożliwiając użytkownikom mówienie im, co mają robić.

Napisanie programu w C do przetwarzania plików jest łatwe, jeśli już wiesz, na jakich plikach będziesz pracować i jakie działania podjąć. Jeśli „na stałe” wpiszesz nazwę pliku do swojego programu lub jeśli twój program jest zakodowany tak, aby robił rzeczy tylko w jeden sposób, wtedy twój program zawsze będzie wiedział, co robić.

Możesz jednak uczynić swój program znacznie bardziej elastycznym, jeśli będzie mógł reagować na polecenia użytkownika przy każdym uruchomieniu programu. Pozwól użytkownikowi powiedzieć programowi, jakich plików ma użyć lub jak zrobić to inaczej. W tym celu musisz przeczytać wiersz poleceń.

Czytanie wiersza poleceń

Kiedy piszesz program w C, możesz zacząć od deklaracji:

int main()

To najprostszy sposób na uruchomienie programu w C. Ale jeśli dodasz te standardowe parametry w nawiasach, twój program będzie mógł odczytać opcje podane mu w wierszu poleceń:

int main(int argc, char **argv)

Zmienna argc to liczba argumentów lub liczba argumentów w wierszu poleceń. Zawsze będzie to liczba równa co najmniej jeden.

Zmienna argv jest podwójnym wskaźnikiem, tablicą ciągów znaków zawierającą argumenty z wiersza poleceń. Pierwszy wpis w tablicy, *argv[0], jest zawsze nazwą programu. Pozostałe elementy tablicy **argv zawierają pozostałe argumenty wiersza poleceń.

Napiszę prosty program, który będzie wyświetlał opcje podane w wierszu poleceń. Jest to podobne do polecenia echo w Linuksie, z tą różnicą, że wypisuje również nazwę programu. Wypisuje także każdą opcję wiersza poleceń w osobnej linii za pomocą funkcji puts:

#include <stdio.h>

int
main(int argc, char **argv)
{
  int i;

  printf("argc=%d\n", argc); /* debugging */

  for (i = 0; i < argc; i++) {
    puts(argv[i]);
  }

  return 0;
}

Skompiluj ten program i uruchom go z niektórymi opcjami wiersza poleceń, a zobaczysz wydrukowaną linię poleceń, każdy element w osobnej linii:

$ ./echo this program can read the command line
argc=8
./echo
this
program
can
read
the
command
line

Ten wiersz poleceń ustawia argc programu na 8, a tablica **argv zawiera osiem wpisów: nazwę programu plus siedem słowa wprowadzone przez użytkownika. I jak zawsze w programach C, tablica zaczyna się od zera, więc elementy są ponumerowane 0, 1, 2, 3, 4, 5, 6, 7. Dlatego możesz przetwarzać wiersz poleceń za pomocą for za pomocą porównania i .

Możesz użyć tego do napisania własnych wersji poleceń cat lub cp systemu Linux. Podstawowa funkcjonalność polecenia cat wyświetla zawartość jednego lub większej liczby plików. Oto prosta wersja cat, która odczytuje nazwy plików z wiersza poleceń:

#include <stdio.h>

void
copyfile(FILE *in, FILE *out)
{
  int ch;

  while ((ch = fgetc(in)) != EOF) {
    fputc(ch, out);
  }
}

int
main(int argc, char **argv)
{
  int i;
  FILE *fileptr;

  for (i = 1; i < argc; i++) {
    fileptr = fopen(argv[i], "r");

    if (fileptr != NULL) {
      copyfile(fileptr, stdout);
      fclose(fileptr);
    }
  }

  return 0;
}

Ta prosta wersja cat odczytuje listę nazw plików z wiersza poleceń i wyświetla zawartość każdego pliku na standardowym wyjściu, po jednym znaku na raz. Na przykład, jeśli mam jeden plik o nazwie hello.txt, który zawiera kilka wierszy tekstu, mogę wyświetlić jego zawartość za pomocą własnego polecenia cat:

$ ./cat hello.txt 
Hi there!
This is a sample text file.

Używając tego przykładowego programu jako punktu wyjścia, możesz napisać własne wersje innych poleceń systemu Linux, takich jak program cp, odczytując tylko dwie nazwy plików: jeden plik do odczytu i drugi do zapisania Kopiuj.

Czytanie opcji wiersza poleceń

Czytanie nazw plików i innego tekstu z wiersza poleceń jest świetne, ale co zrobić, jeśli chcesz, aby Twój program zmieniał swoje zachowanie w oparciu o opcje podane przez użytkownika? Na przykład polecenie cat systemu Linux obsługuje kilka opcji wiersza poleceń, w tym:

  • -b Umieść numery linii obok niepustych linii
  • -E Pokaż końce linii jako $
  • -n Umieść numery linii obok wszystkich linii
  • -s Pomiń drukowanie powtarzających się pustych linii
  • -T Pokaż karty jako ^I
  • -v Rozwlekły; pokaż znaki niedrukowalne przy użyciu notacji ^x i M-x, z wyjątkiem nowych linii i tabulatorów

Te jednoliterowe opcje nazywane są krótkimi opcjami i zawsze zaczynają się od pojedynczego znaku myślnika. Zwykle widzisz te krótkie opcje zapisane osobno, np. cat -E -n, ale możesz także połączyć krótkie opcje w jeden ciąg opcji, np. cat -En.

Na szczęście istnieje prosty sposób na odczytanie ich z wiersza poleceń. Wszystkie systemy Linux i Unix zawierają specjalną bibliotekę C o nazwie getopt, zdefiniowaną w pliku nagłówkowym unistd.h. Aby przeczytać te krótkie opcje, możesz użyć w swoim programie getopt.

W przeciwieństwie do innych systemów uniksowych, getopt w systemie Linux zawsze sprawi, że krótkie opcje pojawią się na początku wiersza poleceń. Załóżmy na przykład, że użytkownik wpisuje cat -E plik -n. Opcja -E znajduje się na początku, ale opcja -n znajduje się po nazwie pliku. Ale jeśli używasz Linuksa getopt, Twój program będzie zawsze zachowywał się tak, jakby użytkownik wpisał cat -E -n plik. To sprawia, że przetwarzanie jest proste, ponieważ getopt może analizować krótkie opcje, pozostawiając w wierszu poleceń listę nazw plików, które Twój program może odczytać za pomocą tablicy **argv.

Używasz getopt w ten sposób:

       #include <unistd.h>

       int getopt(int argc, char **argv, char *optstring);

Ciąg opcji optstring zawiera listę prawidłowych znaków opcji. Jeśli Twój program dopuszcza tylko opcje -E i -n, jako ciągu opcji użyjesz „En”.

Zwykle używasz getopt w pętli, aby przeanalizować wiersz poleceń pod kątem opcji. Przy każdym wywołaniu funkcji getopt funkcja zwraca następną krótką opcję znalezioną w wierszu poleceń lub wartość '?' w przypadku nierozpoznanych krótkich opcji. Gdy getopt nie może znaleźć więcej krótkich opcji, zwraca -1 i ustawia zmienną globalną optind na następny element w **argv po wszystkich krótkich opcjach.

Spójrzmy na prosty przykład. Ten program demonstracyjny nie zastępuje w pełni cat ze wszystkimi opcjami, ale może przeanalizować jego linię poleceń. Za każdym razem, gdy znajdzie prawidłową opcję wiersza poleceń, wypisuje krótki komunikat informujący o jej znalezieniu. Zamiast tego we własnych programach możesz ustawić zmienną lub wykonać inną akcję, która odpowiada tej opcji wiersza poleceń:

#include <stdio.h>
#include <unistd.h>

int
main(int argc, char **argv)
{
  int i;
  int option;

  /* parse short options */

  while ((option = getopt(argc, argv, "bEnsTv")) != -1) {
    switch (option) {
    case 'b':
      puts("Put line numbers next to non-blank lines");
      break;
    case 'E':
      puts("Show the ends of lines as $");
      break;
    case 'n':
      puts("Put line numbers next to all lines");
      break;
    case 's':
      puts("Suppress printing repeated blank lines");
      break;
    case 'T':
      puts("Show tabs as ^I");
      break;
    case 'v':
      puts("Verbose");
      break;
    default:                          /* '?' */
      puts("What's that??");
    }
  }

  /* print the rest of the command line */

  puts("------------------------------");

  for (i = optind; i < argc; i++) {
    puts(argv[i]);
  }

  return 0;
}

Jeśli skompilujesz ten program jako args, możesz wypróbować różne wiersze poleceń, aby zobaczyć, jak analizują krótkie opcje i zawsze pozostawiają resztę wiersza poleceń. W najprostszym przypadku, mając wszystkie opcje z góry, otrzymasz to:

$ ./args -b -T file1 file2
Put line numbers next to non-blank lines
Show tabs as ^I
------------------------------
file1
file2

Teraz wypróbuj tę samą linię poleceń, ale połącz dwie krótkie opcje w jeden ciąg opcji:

$ ./args -bT file1 file2
Put line numbers next to non-blank lines
Show tabs as ^I
------------------------------
file1
file2

Jeśli to konieczne, getopt może „zmienić kolejność” wiersza poleceń, aby poradzić sobie z krótkimi opcjami, które nie są w porządku:

$ ./args -E file1 file2 -T
Show the ends of lines as $
Show tabs as ^I
------------------------------
file1
file2

Jeśli użytkownik poda niepoprawną krótką opcję, getopt wyświetli komunikat:

$ ./args -s -an file1 file2
Suppress printing repeated blank lines
./args: invalid option -- 'a'
What's that??
Put line numbers next to all lines
------------------------------
file1
file2

Pobierz ściągawkę

getopt może zrobić o wiele więcej niż to, co pokazałem. Na przykład krótkie opcje mogą przyjmować własne opcje, takie jak -s string lub -f plik. Możesz także powiedzieć getopt, aby nie wyświetlał komunikatów o błędach, gdy znajdzie nierozpoznane opcje. Przeczytaj stronę podręcznika getopt(3), używając man 3 getopt, aby dowiedzieć się więcej o tym, co getopt może dla Ciebie zrobić.

Jeśli szukasz delikatnych przypomnień na temat składni i struktury getopt() i getopt_long(), pobierz moją ściągawkę getopt. Jedna strona pokazuje krótkie opcje, a druga strona pokazuje długie opcje z minimalnym możliwym kodem i listą zmiennych globalnych, które musisz znać.

Powiązane artykuły: