Ugrás a tartalomhoz

command-line argument

A Wikiszótárból, a nyitott szótárból
(CLA szócikkből átirányítva)

Angol


Főnév

command-line argument (tsz. command-line arguments)

  1. (informatika) A command-line argument (parancssori argumentum, magyarul: parancssori paraméter) az egyik legegyszerűbb és legelterjedtebb módja annak, hogy külső adatokat adjunk át egy programnak a futtatás pillanatában. Ennek segítségével a program dinamikusan testreszabható anélkül, hogy a forráskódját módosítani kellene, vagy újrafordításra lenne szükség.

A parancssori argumentumokat a parancssorból (például Linux terminálból vagy Windows CMD/Powershellből) lehet megadni a program elindításakor, és a program a futása során ezekhez az értékekhez hozzáférhet.


Mi az a parancssori argumentum?

Egy parancssori argumentum nem más, mint egy karakterlánc (string), amit a parancssorban gépelünk be a program neve után. A rendszer (operációs rendszer vagy shell) ezeket az argumentumokat egy tömbbe helyezi, és átadja őket a programnak a belépési pontban (pl. main függvényben).

Például:

./myprogram file.txt 100 verbose

Itt a myprogram a futtatható program neve, a következő három elem pedig parancssori argumentum:

  • "file.txt"
  • "100"
  • "verbose"


Hogyan kapja meg a program az argumentumokat?

A legtöbb programnyelvben a main függvény speciális szignatúrával rendelkezhet, amely lehetővé teszi az argumentumok fogadását. C++-ban (és C-ben) ez így néz ki:

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

Magyarázat:

  • argc (argument count): egy egész szám, ami megadja, hány argumentumot kaptunk (beleértve magát a program nevét is).
  • argv (argument vector): egy karakterláncokra (stringekre) mutató pointerek tömbje, ahol az egyes argv[i] elemek az argumentumok szöveges tartalmát tartalmazzák.

Fontos:

  • argv[0] mindig a program neve (teljes elérési úttal vagy anélkül).
  • argv[1] az első valódi argumentum.
  • argv[2], argv[3], stb. a további argumentumok.


Egyszerű példa C++-ban

#include <iostream>

int main(int argc, char* argv[]) {
    std::cout << "Number of arguments: " << argc << std::endl;
    for (int i = 0; i < argc; ++i) {
        std::cout << "Argument " << i << ": " << argv[i] << std::endl;
    }
    return 0;
}

Ha ezt így futtatjuk:

./myprogram apple banana cherry

A kimenet:

Number of arguments: 4
Argument 0: ./myprogram
Argument 1: apple
Argument 2: banana
Argument 3: cherry

Mire jó a parancssori argumentum?

1. Testreszabás

A program futtatásakor meghatározhatunk viselkedést:

./backup.sh /home/user/documents --compress --verbose

Itt pl. a --compress és --verbose argumentumok befolyásolják, hogy a backup.sh mit csináljon.

2. Fájlok megadása

Sok programnál a bemeneti vagy kimeneti fájlt is parancssori argumentumban adjuk meg:

./image_converter input.jpg output.png

3. Paraméterek

Paraméterekkel beállíthatunk futás közbeni értékeket:

./simulation 1000 0.05 50
  • 1000: lépések száma
  • 0.05: hibahatár
  • 50: futtatási ismétlések száma


Argumentumok feldolgozása

Mivel az argumentumok szövegként érkeznek, ha számként vagy más típusú adatként akarjuk őket használni, konvertálni kell őket.

Példa:

#include <iostream>
#include <cstdlib>  // atoi, atof

int main(int argc, char* argv[]) {
    if (argc != 3) {
        std::cerr << "Usage: " << argv[0] << " <int> <double>" << std::endl;
        return 1;
    }

    int a = std::atoi(argv[1]);    // string -> int
    double b = std::atof(argv[2]); // string -> double

    std::cout << "a + b = " << (a + b) << std::endl;

    return 0;
}

Futtatás:

./program 10 3.14

Kimenet:

a + b = 13.14

Szokásos argumentumtípusok

  • Pozíciós argumentum: A hely alapján értelmezett argumentum.
    • Pl.: ./compress input.txt output.txt
  • Opció (option/flag): Általában - vagy -- prefixű.
    • Pl.: ./program --verbose --dry-run -o output.txt

Gyakori convention:

myprogram [options] <inputfile> [outputfile]

Példák opciókra:

./myprogram -h                 # help
./myprogram -v                 # verbose
./myprogram -o result.txt file.txt

Opciók feldolgozása

A parancssori opciók feldolgozása néha kézzel történik, de vannak könyvtárak is, amelyek megkönnyítik.

Kézi feldolgozás:

for (int i = 1; i < argc; ++i) {
    std::string arg = argv[i];
    if (arg == "-h" || arg == "--help") {
        std::cout << "Help message\n";
    } else if (arg == "-v" || arg == "--verbose") {
        std::cout << "Verbose mode ON\n";
    } else {
        std::cout << "Unknown argument: " << arg << std::endl;
    }
}

Könyvtárak:

  • getopt (POSIX szabványos)
  • Boost.Program_options (C++ Boost könyvtár)
  • cxxopts (modern C++ header-only lib)


Miért hasznos?

  • Program testreszabása anélkül, hogy újrafordítanánk.
  • Scriptelhetőség: programok automatizált futtatása különböző konfigurációval.
  • Könnyű integráció shell-scriptekkel, batch fájlokkal.


Tipikus hibák

  • Nem ellenőrzik, hogy a felhasználó hány argumentumot adott meg.
  • Nem ellenőrzik, hogy a megadott argumentumok értelmesek-e (pl. nem-szám helyett számra várnak).
  • Nem adják meg a felhasználónak, hogyan kell helyesen használni a programot (usage message).

Jó gyakorlat:

if (argc < 2) {
    std::cerr << "Usage: " << argv[0] << " <filename>\n";
    return 1;
}

Haladó megjegyzés: Unicode

  • A char* argv[] típus nem garantálja Unicode kompatibilitást.
  • Windows alatt a wmain(int argc, wchar_t* argv[]) verzióval Unicode parancssori argumentumokat is fogadhatunk.


Összefoglalás

A command-line argument egy nagyon egyszerű, de erőteljes eszköz:

  • Paramétereket adhatunk át a program futtatásakor.
  • A main(int argc, char* argv[]) mechanizmussal kapjuk meg őket.
  • A program viselkedését dinamikusan módosíthatjuk ezekkel.
  • Pozíciós és opciós argumentumokat is használhatunk.
  • Fontos, hogy megfelelő hibakezelést és usage információt nyújtsunk.

További információk

A lap eredeti címe: „https://hu.wiktionary.org/w/index.php?title=command-line_argument&oldid=3500565”