Rheinwerk Computing < openbook > Rheinwerk Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort
Vorwort des Gutachters
1 Einstieg in C
2 Das erste Programm
3 Grundlagen
4 Formatierte Ein-/Ausgabe mit »scanf()« und »printf()«
5 Basisdatentypen
6 Operatoren
7 Typumwandlung
8 Kontrollstrukturen
9 Funktionen
10 Präprozessor-Direktiven
11 Arrays
12 Zeiger (Pointer)
13 Kommandozeilenargumente
14 Dynamische Speicherverwaltung
15 Strukturen
16 Ein-/Ausgabe-Funktionen
17 Attribute von Dateien und das Arbeiten mit Verzeichnissen (nicht ANSI C)
18 Arbeiten mit variabel langen Argumentlisten – <stdarg.h>
19 Zeitroutinen
20 Weitere Headerdateien und ihre Funktionen (ANSI C)
21 Dynamische Datenstrukturen
22 Algorithmen
23 CGI mit C
24 MySQL und C
25 Netzwerkprogrammierung und Cross–Plattform-Entwicklung
26 Paralleles Rechnen
27 Sicheres Programmieren
28 Wie geht’s jetzt weiter?
A Operatoren
B Die C-Standard-Bibliothek
Stichwort

Buch bestellen
Ihre Meinung?

Spacer
<< zurück
C von A bis Z von Jürgen Wolf
Das umfassende Handbuch
Buch: C von A bis Z

C von A bis Z
3., aktualisierte und erweiterte Auflage, geb., mit CD und Referenzkarte
1.190 S., 39,90 Euro
Rheinwerk Computing
ISBN 978-3-8362-1411-7
Pfeil 13 Kommandozeilenargumente
Pfeil 13.1 Argumente an die Hauptfunktion übergeben
Pfeil 13.2 Optionen (Schalter) aus der Kommandozeile auswerten

In der heutigen »Look&Feel«-Zeit scheinen Kommandozeilenprogramme schon ein wenig veraltet zu sein. Die nächste Generation wird mit Begriffen wie »Kommandozeile« oder »Konsole« wohl nichts mehr anzufangen wissen.

13 Kommandozeilenargumente

Wenn aber z. B. ältere Programme überholt werden müssen, wird der Umgang mit der Kommandozeile wieder wichtig. Bei Betriebssystemen wie Linux, UNIX oder FreeBSD ist es nach wie vor üblich (teilweise sogar unerlässlich), sehr viel mit einer Kommandozeile zu arbeiten.

Beim Schreiben eines Konsolenprogramms für Linux/UNIX oder MS-DOS (Eingabeaufforderung) sind Kommandozeilenparameter immer noch eines der wichtigsten Konzepte. Da Konsolenprogramme keine grafische Oberfläche besitzen, stellt die Kommandozeile die wichtigste Schnittstelle zwischen dem Anwender und dem Programm dar.


Hinweis

Dem Programm werden Argumente beim Aufruf übergeben. Unter MS-Windows können Sie hierfür die Eingabeaufforderung cmd.exe verwenden. Unter Linux genügt eine einfache Konsole bzw. Shell. Sofern Sie Entwicklungsumgebungen (IDEs) verwenden, müssen Sie Kommandozeilenargumente anders übergeben. Viele Entwicklungsumgebungen bieten hierfür beim Menü Ausführen noch ein Untermenü Parameter oder so ähnlich (abhängig von der IDE), um die Argumente noch vor dem Programmstart festzulegen. Mehr dazu finden Sie auf der Buch-CD.



Rheinwerk Computing - Zum Seitenanfang

13.1 Argumente an die Hauptfunktion übergeben topZur vorigen Überschrift

Um einem Programm beim Start Argumente zu übergeben, wird eine parametrisierte Hauptfunktion benötigt. Ihre Syntax sieht wie folgt aus:

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

Diese Hauptfunktion main() besitzt zwei Parameter mit den Namen argc und argv. Die Namen dieser Parameter sind so nicht vorgeschrieben. Sie können genauso gut Folgendes schreiben:

int main(int argumenten_zaehler, char *argumenten_vektor[]) {
   /* ... */
}

Der erste Parameter beinhaltet die Anzahl von Argumenten, die dem Programm beim Start übergeben wurden. Dabei handelt es sich um einen Integerwert. Im zweiten Parameter stehen die einzelnen Argumente. Diese werden als Strings in einer Stringtabelle gespeichert. Folgendes Beispiel demonstriert dies:

/* argument.c */
#include <stdio.h>
#include <stdlib.h>

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

   for(i=0; i < argc; i++) {
      printf("argv[%d] = %s ", i, argv[i]);
      printf("\n");
   }
   return EXIT_SUCCESS;
}

Das Listing wurde z. B. unter dem Namen argument.c gespeichert und anschließend übersetzt. Wenn Sie das Programm starten, wird auf dem Bildschirm der Programmname ausgegeben:

argv[0] = argument

Starten Sie das Programm jetzt nochmals mit folgender Eingabe (argument sei wieder der Programmname):

argument Hallo Welt

Abbildung 13.1 zeigt die Ausgabe, die Sie dann erhalten.

Abbildung 13.1 Argumente aus der Kommandozeile auswerten

In argv[0] befindet sich meistens der Programmname, das muss aber nicht so sein. Ein Beispiel:

char *argv_for_new_app[] = {"ganzAndererName", ....argumente};
char *application = "/bin/bash";

execve(application, argv_for_new_app, envp);

Somit ist in argv[0] der Bash nun eben »ganzAndererName« zu lesen. Das ist u. a. ein effektiver Workaround für DOS/Windows-Plattformen, die keine Symlinks haben (d. h., manche Programme erkennen ihre Funktion an argv[0]).

Die einzelnen Argumente, die dem Programm übergeben werden, müssen immer durch mindestens ein Leerzeichen getrennt sein. Wenn Sie zum Beispiel

argument HalloWelt

schreiben, wäre die Ausgabe stattdessen:

argv[0] = argument
argv[1] = HalloWelt

Der Parameter int argc zählt die Anzahl der Strings, die dem Programm beim Aufruf mitgegeben wurden. Dazu ein Beispiel:

/* arg_counter.c */
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv) {
   printf("Insgesamt %d Argumente\n", argc-1);
   printf("Letztes Argument: %s\n", argv[argc-1]);
   return EXIT_SUCCESS;
}

Bei diesem Beispiel werden die Anzahl der Argumente und das letzte Argument ausgegeben. Als Programmaufruf dient etwa:

argument abc xyz

In der Stringtabelle char **argv befinden sich die Strings, die Sie in Abbildung 13.2 sehen.

Abbildung 13.2 Inhalt der Stringtabelle »argv«

Falls dezimale Werte anstelle von Strings als Argumente übergeben werden, handelt es sich dabei weiterhin um Strings. Wird der dezimale Wert benötigt, so muss der String erst in einen solchen Wert konvertiert werden. Hier sehen Sie ein Beispiel einer solchen Konvertierung:

/* calc.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[]) {
   int i, j ;
   long y, erg;

   if(argc < 4) {
      printf("Benötige mindestens 4 Argumente!\n");
      printf("Aufruf: %s <zahl><op><zahl> ...\n", *argv);
      return EXIT_FAILURE;
   }
   /* 1.Zahl in einen Integer konvertieren*/
   erg = strtol(argv[1], NULL, 10);
   if( erg == 0 ) {
      printf("Keine gültige Ganzzahl ... \n");
      return EXIT_FAILURE;
   }

   for(i = 1; i < argc-1; i += 2) {
      for(j=i+1; j < i+2; j++) {
         y = strtol(argv[i+2], NULL, 10);
         if( y == 0 ) {
            printf("Keine gültige Ganzzahl ... \n");
            printf("argc: %d (%s)?!\n", i+2, argv[i+2]);
            return EXIT_FAILURE;
         }
         if(strcmp(argv[j],"+") == 0)
            erg += y;
         else if(strcmp(argv[j],"-") == 0)
            erg -= y;
          else if(strcmp(argv[j], "x") == 0)
             erg *= y;
          else if(strcmp(argv[j],"/") == 0)
             erg/=y;
          else {
             printf("Ungültiger Operand: %s\n", argv[j]);
             return EXIT_FAILURE;
          }
      }
   }
   printf("%ld\n",erg);
   return EXIT_SUCCESS;
}

Damit lassen sich einfache Rechenoperationen ausführen. Im Folgenden soll eine solche Eingabe demonstriert werden (der Programmname sei hierfür calc):

calc 5 + 5 - 9 x 10 / 2

Intern sieht diese Eingabe so aus:

Abbildung 13.3 Einzelne Argumente für Rechenoperationen auswerten

Hier wurden zehn Argumente eingegeben, wobei jedes dieser zehn Argumente ein Stringende-Zeichen (\0) besitzt. Somit besitzt der Parameter int argc in der Funktion main() den Wert 9. Beachten Sie bei der Eingabe, dass nach jedem Zeichen ein Leerzeichen folgt. Folgendes würde nicht funktionieren:

calc 5+5-9x10/2   /* falsch, nur ein Argument*/

Mit

   if(argc < 4) {
      printf("Benötige mindestens 4 Argumente!\n");
      printf("Aufruf: %s <zahl><op><zahl> ...\n", *argv);
      return EXIT_FAILURE;
   }

wird getestet, ob weniger als vier Argumente eingegeben wurden. Falls dies zutrifft, wird eine entsprechende Fehlermeldung auf dem Bildschirm ausgegeben und das Programm beendet.

Wenn die Mindestanzahl von Argumenten gegeben ist, folgt als Nächstes die Konvertierung der Argumente:

erg = strtol(argv[1], NULL, 10);

Hierbei wird mit der Funktion strtol der String in argv[1] in eine dezimale Zahl konvertiert. Im ersten Fall wird der String "5" in den Integerwert 5 umgewandelt. Die Funktion strtol() ist in der Headerdatei <stdlib.h> deklariert. Mehr zu strtol() und weiteren ähnlichen Funktionen erwartet Sie in Kapitel 20, »Weitere Headerdateien und ihre Funktionen (ANSI C)«.

Weiter mit dem Programmablauf bei den for-Schleifen:

   for(i = 1; i < argc-1; i += 2) {
      for(j=i+1; j < i+2; j++) {
         y = strtol(argv[i+2], NULL, 10);

Die erste for-Schleife durchläuft die ungeraden Zahlen des Feldindex, in dem sich (bei richtiger Anwendung des Programms) dezimale Zahlen befinden: [1]="5", [3]="5", [5]="9", [7]="10", [9]="2". Die zweite for-Schleife durchläuft die geraden Zahlen und dient den Operatoren +, -, * und / ([2]="+", [4]="–", [6]="*", [8]="/"). Danach bekommt die Variable y den dezimalen Wert der Zeichenkette argv[3], der wiederum mit strtol() konvertiert wird.

Jetzt erfolgt die Auswertung des Operators:

         if(strcmp(argv[j],"+") == 0)
            erg += y;

Entspricht argv[2] dem Additionszeichen "+"? In dem Fall ist das zweite Argument tatsächlich das Zeichen "+". Daher kann jetzt der erste Wert (zweites Argument) mit dem zweiten Wert (viertes Argument) addiert (drittes Argument) werden. Der Wert wird in der Variablen erg zwischengespeichert. Genauso läuft dies mit den nächsten Zahlen und Operatoren ab, bis keine Argumente (Zahlen oder Operatoren) mehr vorhanden sind.



Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen. >> Zum Feedback-Formular
<< zurück
  
  Zum Katalog
Zum Katalog: C von A bis Z

 C von A bis Z
Jetzt bestellen


 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchtipps
Zum Katalog: C/C++






 C/C++


Zum Katalog: Einstieg in C






 Einstieg in C


Zum Katalog: Schrödinger programmiert C++






 Schrödinger
 programmiert C++


Zum Katalog: C++ Handbuch






 C++ Handbuch


Zum Katalog: IT-Handbuch für Fachinformatiker






 IT-Handbuch für
 Fachinformatiker


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo




Copyright © Rheinwerk Verlag GmbH 2009
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


[Rheinwerk Computing]

Rheinwerk Verlag GmbH, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, service@rheinwerk-verlag.de