# 2.6 Kommandozeilenargumente

Quelle: https://inf.zone/lectures/2-arrays/short-2-6-cmdlineargs/

## Video

[Video ansehen](https://oc.streams.uni-bamberg.de/paella7/ui/watch.html?id=2a4b1e2e-478f-4cc7-915e-e2f11a30538e)

### Alternativen

- [Video auf YouTube](https://youtu.be/K-DdcvG5Ynw)
- Download (1080p) (demnächst)
- Download (720p) (demnächst)
- Download (540p) (demnächst)

## Hinweise zu diesem Video

**Korrekturen**

Die Korrekturen betreffen das Video. In den Folien zum Herunterladen sind sie eingearbeitet, soweit sie die Folien betreffen.

- Folie 7: „char \*argv[]“ bedeutet dasselbe wie „string argv[]“ auf Folie 3; string ist in cs50.h nur ein anderer Name für char \*.

**Einordnung**

- Den Exit-Code (`return 1;` in `main` bei falschem Aufruf) zeigt das Video nicht. Er ist Basis-Code und steht in den [Notes 2](https://inf.zone/lectures/2-arrays/notes2/#exit-code).

## Was davon zur Basis gehört

Der Hauptteil dieses Shorts gehört ganz zur Basis.

- **Programmieren können** (Basis-Code): argc/argv benutzen, Exit-Code
- „Die drei Extra-Minuten“ (ab Folie 8): **Kür**.

Was die Labels bedeuten, steht unter [Was Sie zum Bestehen können müssen](https://inf.zone/extras/lernen/#was-sie-zum-bestehen-können-müssen).

## Material

- [Folien](https://inf.zone/download/lectures/2-arrays/2.6-cmdline-arguments.pdf)
- Folien und Transkript: unten auf dieser Seite

## Folien und Transkript

*Folientext aus den PDF-Folien, darunter jeweils der gesprochene Text des Videos. Der gesprochene Text ist maschinell transkribiert und nachkorrigiert, kann aber noch Fehler enthalten; im Video sprechen abwechselnd Prof und eine AI-Figur, die Sprecherwechsel sind nicht markiert. Die Zuordnung zu den Folien ist ungefähr. Die Zeitangaben verlinken auf die Stelle im Video (YouTube). Maßgeblich sind Video und Folien.*

### Folie 1 — Kommandozeilenargumente

[Folie 1 als PDF](https://inf.zone/download/lectures/2-arrays/2.6-cmdline-arguments.pdf#page=1)

#### Transkript

**[Video 00:00–00:35](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=0)**

Dies ist Inf-Einf-B. Heute Kommandozeilenargumente. Hallo und willkommen zu unserer heutigen Vorlesung. Heute sprechen wir über Kommandozeilenargumente, die besten Argumente überhaupt, denn sie sind. Oh nein, fang jetzt nicht schon wieder mit deinen Wortspielen an. Aber sie sind doch wirklich die besten. Sie sind schließlich die einzigen Argumente, die man nicht widerlegen kann, sondern nur falsch eingeben. Das war überraschend treffend. Aber lass uns lieber zum eigentlichen Thema kommen, bevor du noch mehr solcher Scherze aus der Kommandozeile zauberst. Na gut.

**[Video 00:35–01:15](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=35)**

Aber du musst zugeben, das war ein ziemlich guter Anfang, oder? Also lassen Sie uns in die faszinierende Welt der Kommandozeilenargumente eintauchen. Ich hätte jetzt gerade beinahe eintauchen gesagt. Lassen Sie mich das anders formulieren. Beginnen wir mit den Grundlagen der Kommandozeilenargumente. Gut aufgepasst. Ich bin froh, dass du nicht schon wieder diese abgedroschene Phrase benutzt hast. Ich bin mir sicher, jetzt hast du die Aufmerksamkeit der Studierenden. Versprochen. Apropos Aufmerksamkeit, ein kleiner Tipp an unsere Studierende: Aktives Zuhören und handschriftliche Notizen können Wunder bewirken. Das hilft nicht nur beim Verständnis, sondern auch beim Erinnern des Gelernten. Das stimmt. Guter Punkt. Leg jetzt aber mal los, bevor mir noch die Argumente ausgehen.

### Folie 2 — Bisher haben alle unsere Programme mehr oder weniger gleich begonnen.

[Folie 2 als PDF](https://inf.zone/download/lectures/2-arrays/2.6-cmdline-arguments.pdf#page=2)

```c
int main(void) {
```

Da wir Benutzereingaben durch Eingabeaufforderungen im Programm gesammelt haben, mussten wir diese Deklaration von main() nicht ändern.

Wenn wir möchten, dass man einem Programm Daten schon vor der Ausführung übergeben kann, benötigen wir eine neue Form.

#### Transkript

**[Video 01:15–01:31](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=75)**

Dann legen wir mal los. Bisher haben Sie wahrscheinlich alle Ihre Programme auf die gleiche Weise begonnen, nämlich mit der Funktion int main(void). Diese Methode hat uns erlaubt, Eingaben durch Eingabeaufforderungen innerhalb des Programms zu sammeln. Zum Beispiel haben wir in unserem Mario-Programm nachgefragt.

**[Video 01:31–02:09](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=91)**

Wie groß die Pyramide sein soll. Diese Vorgehensweise hat gut funktioniert, aber was ist, wenn wir den Leuten die Möglichkeit geben wollen, unserem Programm Daten zur Verfügung zu stellen, bevor es überhaupt startet? Stellen Sie sich vor, Sie haben ein Programm, das eine große Datei verarbeiten soll. Anstatt die Leute nach dem Dateinamen zu fragen, nachdem das Programm gestartet ist, könnte man den Namen schon direkt beim Programmaufruf angeben.

### Folie 3 — Neue Deklaration von main

[Folie 3 als PDF](https://inf.zone/download/lectures/2-arrays/2.6-cmdline-arguments.pdf#page=3)

Um sogenannte Kommandozeilenargumente verarbeiten zu können, deklarieren Sie main wie folgt:

```c
int main(int argc, string argv[])
```

Mit diesen beiden speziellen Argumenten können Sie ermitteln, welche Argumente (oft auch als „Parameter“ bezeichnet) beim Aufruf des Programms auf der Kommandozeile eingegeben wurden bzw. um wie viele Argumente es sich handelt.

argc: argument count

argv: argument vector

#### Transkript

**[Video 01:31–02:09](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=91)**

Das spart Zeit und ermöglicht eine einfachere Automatisierung durch Skripte auf der Kommandozeile. Kein Wunder, dass viele der Programme, die Sie im Terminal nutzen, Kommandozeilenargumente entgegennehmen. Manchmal sagt man stattdessen übrigens auch einfach Parameter. Das ist etwas ungenau, aber kürzer.

**[Video 02:09–02:47](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=129)**

Jedenfalls benötigen wir dafür eine neue Form der Deklaration von main. Kommen wir nun zur eigentlichen Deklaration von main, die es uns ermöglicht, Kommandozeilenargumente zu verarbeiten. Anstelle der uns vertrauten Form int main(void) verwenden wir jetzt int main(int argc, string argv\[\]) und dann eckige Klammern. Diese neue Deklaration führt zwei besondere Parameter ein: argc und argv. Darüber bekommen wir zwei wichtige Informationen: Erstens, welche Daten hat der Benutzer in der Kommandozeile eingegeben, und zweitens, wie viele Parameter wurden bereitgestellt. Das klingt ja jetzt schon etwas komplizierter. Kannst du uns vielleicht irgendwie einen Tipp geben, wie man sich das besser merken kann?

**[Video 02:47–02:59](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=167)**

Natürlich. Es hilft zu wissen, wofür die Variablennamen stehen. Also argc ist der Argumentcount und argv der Argumentvektor. Der Count zählt, wie viele Argumente es gibt, und der Vektor

**[Video 02:59–03:31](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=179)**

Was eigentlich nur ein anderes Wort für Array ist, speichert die Argumente selbst.

### Folie 4

[Folie 4 als PDF](https://inf.zone/download/lectures/2-arrays/2.6-cmdline-arguments.pdf#page=4)

argc

Diese Variable vom Typ Integer speichert die Anzahl der Kommandozeilenargumente, die bei der Ausführung des Programms eingegeben wurden.

```text
./greedy
```

=\> argc ist 1

```text
./greedy 1024 cs50
```

=\> argc ist 3

#### Transkript

**[Video 02:59–03:31](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=179)**

Lassen Sie uns nun genauer auf argc eingehen, also den Argument Count. Es ist eine Variable vom Typ Integer, die speichert, wie viele Kommandozeilenargumente der Benutzer eingegeben hat, als das Programm gestartet wurde. Ein wichtiger Aspekt dabei ist, dass der Name des Programms selbst als erstes Argument zählt. Lassen Sie mich das an einem Beispiel verdeutlichen. Wenn Sie ein Programm namens Greedy mit dem Befehl ./greedy aufrufen, wäre argc gleich eins. Der Programmname selbst ist also das erste Argument.

**[Video 03:31–04:08](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=211)**

Wenn Sie dagegen ./greedy 1024 cs50 eingeben, wäre argc gleich drei. In diesem Fall haben wir den Programmnamen und zwei zusätzliche Argumente. Oh, das ist ein wichtiger Punkt. Am Anfang vergisst man oft, dass der Programmnamen selbst auch als Argument zählt. Kannst du noch etwas dazu sagen, warum das so ist? Gerne.

### Folie 5

[Folie 5 als PDF](https://inf.zone/download/lectures/2-arrays/2.6-cmdline-arguments.pdf#page=5)

argv

Dieses Array von Strings enthält den Text, der in der Kommandozeile eingegeben wurde, als das Programm ausgeführt wurde.

Das erste Element von argv befindet sich immer in `argv[0]`.

Das letzte Element von argv befindet sich immer in `argv[argc-1]`.

Sehen Sie, warum?

#### Transkript

**[Video 03:31–04:08](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=211)**

Der Grund dafür liegt in der Art und Weise, wie Betriebssysteme Programme starten. Wenn Sie ein Programm aufrufen, übergibt das Betriebssystem den Programmnamen als erstes Argument an die Main-Funktion. Das ist durchaus nützlich, weil man dadurch ein und denselben Code für verschiedene Programme verwenden kann, denen man nach dem Kompilieren einen anderen Namen gibt.

**[Video 04:08–04:31](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=248)**

So kann das Programm sein eigenes Verhalten basierend auf dem Namen ändern, unter dem es aufgerufen wurde. Es ist sozusagen eine Art Selbsterkennung für Programme. Genau, das machen sich tatsächlich auch einige Werkzeuge in Linux zunutze. Aber das ist für uns jetzt erstmal egal. Weiter. Kommen wir nun zu argv, dem Argumentvektor. Wie der Name schon andeutet, handelt es sich hierbei um einen Vektor, oder einfacher ausgedrückt

**[Video 04:31–05:10](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=271)**

um ein Array von Strings. Dieses Array speichert den tatsächlichen Text, den der Benutzer in der Kommandozeile eingegeben hat, als das Programm gestartet wurde. Jedes Element des Arrays entspricht einem einzelnen Argument. Das erste Element von argv, also argv\[0\], enthält immer den Namen des Programms selbst. Das letzte Element von argv finden Sie immer an der Position argv\[argc-1\]. Überlegen Sie kurz, warum das so ist. Warum? Na ja, weil Arrays in C ja nullbasiert sind, das heißt, das erste Element hat den Index 0. Wenn wir also argc Argumente haben, nummeriert von 0 bis argc-1, ist das letzte Element logischerweise an der Position argc.

**[Video 05:10–05:41](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=310)**

Minus eins zu finden. Wenn argc also drei ist, haben wir Elemente an den Positionen null, eins und zwei. Das letzte Element ist also an Position zwei, was argc minus eins entspricht.

### Folie 6

[Folie 6 als PDF](https://inf.zone/download/lectures/2-arrays/2.6-cmdline-arguments.pdf#page=6)

argv

Nehmen wir an, der Benutzer führt das Programm greedy wie folgt aus:

```text
./greedy 1024 cs50

argv[0] = "./greedy"
argv[1] = "1024"
argv[2] = "cs50"
argv[3] = ???
```

#### Transkript

**[Video 05:10–05:41](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=310)**

Lassen Sie uns nun ein konkretes Beispiel betrachten, um argv besser zu verstehen. Stellen Sie sich vor, ein Benutzer führt das Programm Greedy mit folgenden Kommandozeilenargumenten aus. ./greedy 1024 cs50. In diesem Fall würde argv wie folgt aussehen. Vielleicht sollten wir die Studierenden warnen, was

**[Video 05:41–06:00](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=341)**

passieren könnte, wenn sie versuchen, auf argv\[3\] zuzugreifen. Unbedingt.

### Folie 7 — Strings in

[Folie 7 als PDF](https://inf.zone/download/lectures/2-arrays/2.6-cmdline-arguments.pdf#page=7)

Strings in

```c
#include <cs50.h>
#include <stdlib.h>

int main(int argc, string argv[]) {
    if (argc > 1) {
        int zahl = atoi(argv[1]);
        // Jetzt können Sie mit 'zahl'
        // als Integer arbeiten.
   }
    // Rest des Programms...
}
```

Zahlen umwandeln

`atoi(…)`: „ASCII to Integer“

Alternative`strtol(…)`: „String to Long“

#### Transkript

**[Video 05:41–06:00](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=341)**

In C führt dies zu undefiniertem Verhalten, was oft zu schwer zu findenden Fehlern oder sogar zu Abstürzen führen kann. Vielleicht bekommen Sie einen Nullzeiger zurück oder das Programm stürzt aus einem anderen Grund ab. Meist endet es dann abrupt.

**[Video 06:00–06:36](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=360)**

Mit einem Segmentation Fault. Ein wichtiger Aspekt, den wir noch erwähnen sollten, betrifft argv\[1\], also 1024. Obwohl es wie eine Zahl aussieht, wird es in argv als String gespeichert. Das bedeutet, es wird als Folge von Zeichen behandelt, nicht als numerischer Wert. Wenn Sie also in Ihrem Programm mit diesem Wert als Zahl arbeiten möchten, müssen Sie ihn zuerst in einen Integer umwandeln. Es gibt spezielle Funktionen in C, die Ihnen dabei helfen können, wie zum Beispiel atoi oder strtol. Ja, ja. So kann man sich das zwar gut aufschreiben, aber merken kann man sich das irgendwie ja nicht. Wofür stehen denn diese komischen Funktionsnamen eigentlich?

**[Video 06:36–07:12](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=396)**

Der erste Name ist eine Abkürzung für ASCII to Integer. Es wandelt also einen String, der aus ASCII-Zeichen besteht, in einen Integer um. Denken Sie einfach an A to I, von ASCII zu Integer. Der zweite Name steht für String to Long. Diese Funktion ist mächtiger, da sie nicht nur in einen Integer, sondern in einen Long Int umwandelt und man zusätzlich eine Basis für die Umwandlung spezifizieren kann. Kannst du vielleicht kurz ein Beispiel geben, wie man ein solches Argument in eine Zahl umwandeln könnte? Gerne. Hier ist ein kurzes Beispiel, wie man das Argument 1024 mit A to I in eine Zahl umwandeln könnte.

**[Video 07:12–07:29](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=432)**

In diesem Beispiel verwenden wir die Funktion atoi, die in der stdlib-Funktionsbibliothek definiert ist. Sie wandelt einen String in einen Integer um. Beachten Sie jedoch, dass atoi keine Fehlerprüfung durchführt. In der Praxis verwendet man daher meist robustere Methoden, wie die Funktion string to long.

### Folie 8

[Folie 8 als PDF](https://inf.zone/download/lectures/2-arrays/2.6-cmdline-arguments.pdf#page=8)

E X T R A S I N 3 M I N U T E N FRAGEN – ANTWORTEN – RÄTSEL UND KURZE ZUSAMMENFASSUNG

#### Transkript

**[Video 07:12–07:29](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=432)**

So, liebe Studierende.

**[Video 07:29–08:04](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=449)**

Wir kommen nun zu unserem Abschnitt die drei Extra Minuten. Hier möchte ich Ihnen einige Wiederholungsfragen stellen, die Ihnen helfen sollen, das Gelernte zu festigen. Ich hoffe, Sie haben Ihre idealerweise handschriftlichen Notizen griffbereit.

### Folie 9 — F1:

[Folie 9 als PDF](https://inf.zone/download/lectures/2-arrays/2.6-cmdline-arguments.pdf#page=9)

Was passiert, wenn man willkürlich Argumente per Kommandozeile an ein Programm übergibt? Wie gehen Programme üblicherweise mit Kommandozeilenargumenten um?

F2:

Könnte man die main-Funktion zur Verarbeitung von Kommandozeilenargumenten auch mit `int` `main(int` `hello, string` `world[])` deklarieren?

F3:

Was ist zu beachten, wenn man dem Nutzer per Kommandozeile int-Werte als Argument übergeben lassen möchte?

F4:

Welche Zahl enthält der Argumentcount argc, wenn ein Programm mit zwei Kommandozeilenargumenten aufgerufen wird?

#### Transkript

**[Video 07:29–08:04](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=449)**

Nehmen Sie sich einen Moment Zeit, um über diese Fragen nachzudenken und Ihre Antworten in Ihren Notizen zu formulieren.

**[Video 08:04–08:41](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=484)**

Also, erstens: Wenn man willkürlich Argumente an ein Programm übergibt, werden diese in argv gespeichert und argc wird entsprechend erhöht. Programme sollten diese Argumente überprüfen und gegebenenfalls Fehlermeldungen ausgeben, wenn unerwartete oder falsche Argumente übergeben werden. Zweite Frage: Ja, theoretisch könnte man beliebige Variablennamen verwenden. Die Namen argc und argv sind Konventionen, aber nicht zwingend erforderlich. Allerdings ist es gute Praxis, bei den üblichen Namen zu bleiben, um den Code lesbarer und verständlicher für andere Programmierer zu machen.

**[Video 08:41–09:01](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=521)**

Drittens: Alle Kommandozeilenargumente werden als Strings übergeben. Wenn man Integer-Werte benötigt, muss man diese Strings in Integer konvertieren, etwa mit Funktionen wie atoi oder string to long. Viertens: Wenn ein Programm mit zwei Kommandozeilenargumenten aufgerufen wird, enthält argc den Wert drei. Stimmt.

**[Video 09:01–09:35](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=541)**

Der beste Weg, diese Konzepte zu verinnerlichen, ist natürlich durch praktische Übung. Sie könnten zum Beispiel ein einfaches C-Programm schreiben, das alle übergebenen Argumente ausgibt. Zuerst argc, dann jedes weitere Element von argv. Dann könnten Sie das Programm zum Beispiel unterschiedlich aufrufen: erst ohne Argumente, dann mit mehreren Wörtern, oder Sie übergeben vielleicht einfach mal Zahlen oder Sonderzeichen. Zusätzlich könnten Sie versuchen, ein Programm zu schreiben, das das zweite Argument, falls dann ein zweites Argument vorhanden ist, in eine Zahl umwandelt und damit eine einfache Berechnung durchführt.

**[Video 09:35–10:05](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=575)**

Das wird Ihnen helfen, die Konvertierung von String-Argumenten in numerische Werte zu üben. Und was passiert eigentlich, wenn man dann als zweites Argument keine Zahl, sondern ein String übergibt? Fragen über Fragen. Das sollte für heute auch reichen, oder? Stimmt. So, das war's für heute mit unserer Lektion über Kommandozeilenargumente. Ich hoffe, alle haben fleißig mitgeschrieben. Ah, du eigentlich auch? Ich würde ja gerne mal sehen, wie deine handschriftlichen Notizen aussehen. Ich würde sie dir ja gerne zeigen, aber meine Handschrift ist...

**[Video 10:05–10:29](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=605)**

Zumindest für Menschen nicht lesbar. Wie machen wir eigentlich weiter? Kommen wir jetzt endlich mal zu Pointern? Da gibt es viel Potenzial für gute Pointen. Oh nein, fängst du schon wieder mit diesen Wortspielen an? Nein, Pointer kommen erst später. Und liebe Studierende, denken Sie daran: Egal ob handschriftlich oder digital, Hauptsache Sie machen sich Notizen. Auf jeden Fall. Bis zum nächsten Mal.

**[Video 10:29–10:46](https://www.youtube.com/watch?v=K-DdcvG5Ynw&t=629)**

Kennst du den schon? Why are pointers terrible at keeping secrets? Well, of course, because they always give away the address. Uff. Dies war Inf-Einf-B.

### Folie 10 — argc enthält die Zahl der Argumente (inkl. Programmname)

[Folie 10 als PDF](https://inf.zone/download/lectures/2-arrays/2.6-cmdline-arguments.pdf#page=10)

Alle Argumente werden

als Strings gespeichert

argv ist ein Array von Strings, das die Argumente enthält

String-zu-Zahl Konvertierung

mit atoi() oder strtol()

argv\[0\] enthält immer den Programmnamen

Arraygrenze argc–1 nicht überschreiten!

> Bildinhalte sind nicht transkribiert; siehe Originalfolie.

#### Transkript

*Kein Transkriptabschnitt eindeutig dieser Folie zugeordnet. Möglicherweise eine Aufbau-/Grafikfolie oder eine Abweichung zwischen PDF und Video.*