Befehlszeilenargument

Ein Programm in C mit der Befehlszeilenargument auszuführen ist ein sehr wichtiges Konzept in der C -Sprache.

Möglichkeiten, unser Programm auszuführen:

Zunächst müssen wir die verschiedenen Prozesse kennen, die vorhanden sind, um eine Software auszuführen:

1. von ide
2. durch Doppelklick
3. nach Befehlszeile.

Welche IDE auch immer Sie verwenden (wie Turbo CPP 3.0, Code Block), lassen Sie das Programm, das der Einrichtung gibt, unser Programm ausführen.

Welches Programm, das wir unsere Quelldatei auch schreiben, heißt, .C -Datei… C -Datei muss sie in die EXE -Datei oder die Erstellung erstellen, die die EXE -Datei erstellt, die unsere Software ist. Wenn wir auf eine Datei doppelklicken, fordern wir unser Betriebssystem auf, die Datei zu öffnen.

Durch Doppelklick führt das Betriebssystem unsere EXE -Datei aus. Aber es zeigt etwas Blinzeln oder bleibt nicht in der Ausgabedatei. Wenn wir also unsere EXE -Datei über Doppelklick öffnen, müssen wir Getch () schreiben, um unser Ergebnis anzuzeigen.

Verwenden der Befehlszeile: Durch die Verwendung der Befehlszeile, um unser Programm auszuführen, müssen wir die Eingabeaufforderung öffnen. Eingabeaufforderung ist der Simulator von DOS.

Argumente in main ():

• Nimmt etwas Natur der Funktion
• Tatsächliche und formelle Argumente
• Main () kann Argumente einnehmen
• Wer nennt Main ()?

Betriebssystem ruft die Main () auf.

Wenn OS den Main () aufruft, gibt es keinen Wert als Argument in der Main ().

Wenn wir den Wert als Argument übergeben wollen, tun wir dies über die Befehlszeile.

In der Eingabeaufforderung,

Wann immer, wie das OS die Main () mit Argument nennt, müssen wir das formale Argument in Main () Klammern aufbauen. Hier haben wir drei Argumente verabschiedet (Test 1, 3, 5.) Sie sind einzelne Saiten.

Programmierbeispiel 1:

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

int i;
für (i = 0; i < argc; i++)
printf ("\ n %s", argv [i]);

Ausgang:

Erläuterung:

Blockdiagramm von argc und argv []:

In der Befehlszeile vergeben wir drei Argumente, Test 1, 3, 5. Die Gesamtargumente sind also 3. Dieser Wert wird durch das formale Argument empfangen argc in main ().

*argv [] ist eine Reihe von Zeiger. Es bedeutet, dass es sich um ein Array handelt, das Zeigervariable des Zeichenentyps enthält. Dafür deklarieren wir es als Charakter.

As, wir haben 3 Argumente bestanden, die Anzahl der Blöcke in Argv [] vorhanden 3.

Argv [0] -> “Test.exe ”
Argv [1] -> '3'
Argv [2] -> '5'

Sie sind formelle Argumente, die in Main () vorbeikommen ().

Wenn wir dieses Programm über die Befehlszeile ausführen, werden die drei Zeichenfolgen test1 angezeigt.exe, 3, 5.

Sie können Argumente an main () nur dann übergeben, wenn Sie Ihr Programm über die Befehlszeile anrufen.

Programmierbeispiel 2:

Hier sehen wir ein weiteres Beispiel für das Argument der Befehlszeilen.

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

printf ("\ n Der Name des Programms ist = %s \ t", argv [0]);
if (argc == 2)

printf ("\ n des vom Benutzer angegebenen Werts ist = %s \ t", argv [1]);

sonst wenn (argc> 2)

printf ("\ n Manny -Werte bereitgestellt.\N");

anders

printf ("\ n mindestens einen von dem Benutzer erwarteten Wert, der erwartet wird !.\N");

Ausgang:

Erläuterung:

In diesem Programm -Beispiel werden wir drei Werte innerhalb der Klammern der Main () -Funktion übergeben. Die Werte sind 1, 3, 4. Unser Betriebssystem ruft die Haupt- () -Funktion auf. Zu diesem Zeitpunkt werden wir die Werte übergeben. Dann erhalten wir eine Bedingung, um die Werte zu drucken.

Programmierbeispiel 3:

Hier sehen wir eine weitere Implementierung der Befehlszeilenargumente:

#enthalten
#enthalten
int main (int argc, char *argv []) // einige Werte innerhalb der Funktion main () übergeben.

Int x, y, Ergebnis;
Char Op;
if (argc!= 4)

printf ("falsche Wahl !! Versuchen Sie es erneut \ n ");
Return -1;

// Werte vom Benutzer abrufen
x = atoi (argv [1]);
y = atoi (argv [3]);
// Bediener vom Benutzer holen
op = argv [2] [0];
// Berechnen Sie nach Operator
Schalter (OP)

Fall '+':
Ergebnis = x+y;
brechen;
Fall '-':
Ergebnis = x - y;
brechen;
Fall '*':
Ergebnis = x*y;
brechen;
Standard:
Ergebnis = 0;
brechen;

If (op == '+' || op == '-' || op == '*')
printf ("Ergebnis: %d %c %d = %d \ n", x, op, y, Ergebnis);
anders
printf ("Operand existiert nicht !! \N");
Rückkehr 0;

Ausgang:

Erläuterung:

In diesem Programm -Beispiel werden wir einige Werte innerhalb der Klammern der Main () -Funktion übergeben. Die Werte werden betrieben, um das Ergebnis abhängig vom Wert des Benutzers zu erhalten, der in der Funktion main () übergeben wird. Unser Betriebssystem ruft die Haupt- () -Funktion auf. Zu diesem Zeitpunkt werden wir die Werte übergeben. Dann erhalten wir eine Bedingung, um die Werte zu drucken.

Programmierbeispiel 4:

Hier ist die letzte Implementierung von Befehlszeilenargumenten:

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

int x, y;
int sum;
if (argc!= 3)

printf ("Bitte verwenden Sie 2 Werte nur \ n");
Return -1;

x = atoi (argv [1]);
y = atoi (argv [2]);
sum = x+y;
printf ("Summe von %d, %d ist: %d \ n", x, y, sum);
Rückkehr 0;

Ausgang:

Erläuterung:

In diesem Programm -Beispiel werden wir drei Werte innerhalb der Klammern der Main () -Funktion übergeben. Die Werte werden vom Switch -Fall betrieben, um Addition oder Subtraktion oder Multiplikationsergebnis abhängig von der Wahl des Benutzers zu erhalten. Unser Betriebssystem ruft die Haupt- () -Funktion auf. Zu diesem Zeitpunkt werden wir die Werte übergeben. Dann erhalten wir eine Bedingung, um die Werte zu drucken.

Abschluss:

Dieser Artikel ist eine Diskussion über das Konzept des Kommandozeilenarguments. Wir sind zu dem Schluss gekommen, dass es ein sehr wichtiger Aspekt der technischen Sicht ist, ein Softwareprodukt auszuführen. Wir müssen jeden Prozess kennen, um eine Software insbesondere mit dem Befehlszeilenargument auszuführen.