Übertragung von Argumenten der Haupt-C-Funktion. Haupt- () Funktionsargumente. Numerische Argumente bearbeiten.

Es passiert, dass die Daten im Programm von der Befehlszeile übertragen werden, wenn er aufgerufen wird. Solche Daten werden als Befehlszeilenargumente bezeichnet. Es sieht so aus, wie zum Beispiel:

./a.out test.txt ls / home / peter /

Hier sind die Programme a.out (aus dem aktuellen Verzeichnis) und ls (von einem in der Pfadumgebungsvariablen angegebenen Verzeichnis). Das erste Programm von der Befehlszeile empfängt ein Wort - test.txt, der zweite ist zwei: -lt und / home / peter /.

Wenn das Programm in c geschrieben wird, wird die Steuerung, wenn sie startet, sofort an die Hauptfunktion der Haupt () übermittelt, daher wird daher die Befehlszeilenargumente, die ihren Variablen zugeordnet sind.

Zuvor haben wir die Funktion der Haupt () definiert, als ob er keine Parameter akzeptiert und nichts zurückgibt. In der Tat gibt es in der Sprache C eine beliebige Standardfunktion (wenn nichts anderes definiert ist) eine ganze Zahl zurück. Sie können sicherstellen, dass Sie sicherstellen können. Wenn Sie den Code auf diese Weise schreiben:

main () (druckf ("hi \\ n "); Rückgabe 0; )

Dass keine Warnung oder Fehler beim Kompilieren auftreten. Dasselbe wird sein, wenn Sie int int () aufnehmen. Dies beweist, dass die Standardfunktion eine Ganzzahl zurückgibt, und nicht nur nichts (leer). Obwohl die Funktion die Funktion wiedergibt, kann man immer "Überschreiben", beispielsweise Voidmain () oder Float-Main ().

Beim Anrufen eines Programms aus der Befehlszeile wird immer ein Datenpaar übertragen:

  1. ganze ZahlBezeichnung der Anzahl der Wörter (Elemente, die durch Leerzeichen getrennt sind) auf der Befehlszeile, wenn Sie anrufen,
  2. wegweiser auf einem Array von SaitenWo jede Zeile ein separates Wort von der Befehlszeile ist.

Es sollte berücksichtigt werden, dass der Programmname selbst auch berücksichtigt wird. Wenn der Anruf beispielsweise so aussieht:

./a.out 12 Thema 2

Das erste Argument des Programms ist 4, und das String-Array ist definiert als ("./a.out", "12", "Thema", "2").

Achten Sie auf die Terminologie, es gibt nur zwei Programmargumente (Nummer und Array), jedoch alle Argumente der Befehlszeile. Die Befehlszeilenargumente sind in die Programmargumente "konvertiert" (in den wichtigsten () -Funktionsargumenten).
Diese Daten (Nummer und Zeiger) werden an das Programm übermittelt, auch wenn er einfach nach Namen angerufen wird, ohne etwas zu übertragen: ./ a.out. In diesem Fall hat das erste Argument einen Wert von 1, und der zweite zeigt ein Array an, das nur aus einer Linie besteht ("./a.out").

Die Tatsache, dass das Programm an das Programm übertragen wird, bedeutet nicht, dass die Haupt- () -Funktion sie empfangen muss. Wenn die Haupt- () -Funktion ohne Parameter definiert ist, ist es unmöglich, auf die Befehlszeilenargumente zuzugreifen. Obwohl nichts dabei stört, sie zu übertragen. Fehler treten nicht auf.

Um auf die auf das Programm übertragenen Daten zuzugreifen, müssen sie Variablen zugewiesen werden. Da die Argumente sofort an Main () übertragen werden, sollte der Titel aussehen:
Main (int n, char * arr)

Die erste Variable (n) enthält die Anzahl der Wörter und in dem zweiten Zeiger auf das Zeilenarray. Oft wird der zweite Parameter als ** ARR geschrieben. Dies ist jedoch das gleiche. Erinnern Sie sich, dass das Array selbst Zeilen, Zeiger auf Linien als Elemente enthält. In der Funktion senden wir einen Zeiger auf das erste Element des Arrays. Es stellt sich heraus, dass wir einen Zeiger auf den Zeiger übertragen, d. H. ** ARR.

Die Aufgabe
Schreiben Sie ein solches Programm:

#Einschließen. Int main (int argc, char ** argv) (int i; printf ("% d \\ n ", argc); für (i \u003d 0; ich< argc; i++ ) puts (argv[ i] ) ; }

Es zeigt die Anzahl der Wörter auf der Befehlszeile an, wenn er aufgerufen wird und jedes Wort von einer neuen Zeile aufgerufen wird. Nennen Sie es ohne Befehlszeilenargumente und mit Argumenten.

Im Programm haben wir die Argc- und Argv-Variablen verwendet. Es ist üblich, solche Namen zu verwenden, aber tatsächlich können sie trotzdem sein. Es ist besser, an diesem Standard einzuhalten, damit Ihre Programme nicht nur für Sie, sondern auch an andere Programmierer verständlicher sind.

Der praktische Wert der Datenübertragung an das Programm

Wenn Sie Erfahrung in der Eingabeaufforderung GNU / Linux haben, wissen Sie, dass die meisten Teams Schlüssel und Argumente haben. Wenn Sie beispielsweise den Inhalt der Verzeichnisse anzeigen, kopieren, verschieben als Argumente, werden die Dateisystemobjekte festgelegt, über die der Befehl ausgeführt wird. Die Funktionen seiner Ausführung werden mit den Tasten ermittelt. Zum Beispiel im Team

CP -R ../les_1 ../les_101

cP ist der Name des Befehls, -r - den Schlüssel und ../ les_1 und ../ les_101 - Befehlsargumente.

Im Allgemeinen werden die Adressen von Dateien und "Modifikatoren" (diese Tasten) des Programmprozesses des Programms übertragen.

Wir schreiben ein Programm, das die von dem Benutzer angegebenen Dateien auf der Befehlszeile eröffnet, um auf ein und denselben Informationen aufzunehmen oder hinzuzufügen und zu schreien (Adds), die der Benutzer während des Programmausführungsvorgangs von der Tastatur eingibt:

#Einschließen. #Einschließen. Main (int argc, char ** argv) (int i, ch; file * f [5]; if (argc< 3 || argc > 7) (Puts ( "Ungültige Anzahl von Parametern"); Rückgabe 1; ) if (strcmp (argv [1], "-w")! \u003d 0 && strcmp (argv [1], "-a")! \u003d 0) (Puts ( "Der erste Parameter kann entweder -w oder -a sein"); Rückgabe 2; ) für (i \u003d 0; ich< argc- 2 ; i++ ) { f[ i] = fopen (argv[ i+ 2 ] , argv[ 1 ] + 1 ) ; if (f[ i] == NULL) { printf ("Datei% s kann nicht geöffnet werden \\ n", argv [i + 2]); Rückgabe 3; )) Während ((CH \u003d Getchar ())! \u003d EOF) für (i \u003d 0; i< argc- 2 ; i++ ) putc (ch, f[ i] ) ; for (i= 0 ; i < argc- 2 ; i++ ) fclose (f[ i] ) ; return 0 ; }

Erläuterung zum Code:

  1. Es wird ein Array von fünf Dateizeigers erstellt. Daher können Sie gleichzeitig nicht mehr als fünf Dateien öffnen. Der Dateizeiger der ersten Datei wird in dem Element des F, dem zweiten - in f usw. gespeichert.
  2. Die Anzahl der Befehlszeilenargumente wird geprüft. Sie sollten mindestens drei sein, weil Der erste ist der Name des Programms, der zweite - der Öffnungsmodus der Datei, der dritte oder die einzige Datei, in der der Datensatz erstellt wird. Da das Programm mit Ihnen nur fünf Dateien öffnet, kann die Gesamtzahl der Befehlszeilenargumente nicht mehr sieben betragen. Wenn daher die Anzahl der Argumente weniger als 3 oder mehr als 7 beträgt, ist das Programm abgeschlossen, da Der Rendite-Bediener führt zu der Ausgabe von der Funktion, auch wenn danach noch Code vorhanden ist. Der von der Funktion zurückgegebene Wert ist ungleich 0, kann vom übergeordneten Prozess als Meldung interpretiert werden, dass das Programm mit einem Fehler ausgefüllt ist.
  3. Überprüfte die Richtigkeit des zweiten Befehlszeilenarguments. Wenn es nicht von jedem "-W" ist, noch "-a", ist der bedingte Ausdruck in der zweiten, wenn Retouren 1 (TRUE). Mit der Funktion STRCMP () können Sie Saiten vergleichen und 0, wenn sie gleich sind.
  4. Die Forcycle-Loop öffnet die Dateien an den angegebenen Adressen, die mit dem dritten Element des Argv-Arrays beginnen. Deshalb wird 2 zu I hinzugefügt, um die Elemente des Argv-Arrays zu empfangen, beginnend mit dem dritten. Der Ausdruck ARGC-2 gibt an, dass die Anzahl der übergebenen Dateinamen angezeigt wird; weil Der ARGC speichert die Gesamtzahl der Befehlszeilenargumente, deren ersten beiden sind keine Dateinamen.
  5. Ausdruck argv + 1 Ermöglicht das "Schnitt" von der "-W" -Screme (oder "-a") -Substring "W" (oder "A"), da Argv ist im Wesentlichen ein Zeiger auf das erste Element der Zeichenfolge. Hinzufügen der Zeigereinheit, wechseln wir es auf das nächste Element des Arrays.
  6. Wenn die Datei fehlschlägt, kehrt die FOPEN () -Funktion NULL zurück. In diesem Fall ist das Programm abgeschlossen.
  7. Jedes vom Benutzer von der Tastatur eingegebene Zeichen wird in alle geöffneten Dateien geschrieben.
  8. Am Ende sind die Dateien geschlossen.

Beim Erstellen einer Konsolenanwendung in der Programmiersprache C ++ wird automatisch eine Zeichenfolge sehr ähnlich erstellt:

Int Main (Int Argc, char * argv) // Haupt () Funktionsparameter

Diese Linie ist der Header der Hauptfunktion Main (), die Parameter der Args und des Argvs werden in Klammern deklariert. Wenn Sie das Programm über die Befehlszeile ausführen, ist es möglich, Informationen an dieses Programm, dafür zu übertragen und ARGC- und ARGV-Parameter vorhanden sind. Der Parameter ARGC hat einen INT-Datentyp und enthält die Anzahl der in der Hauptfunktion übertragenen Parameter. Darüber hinaus ist Argc immer mindestens 1, auch wenn wir keine Informationen übertragen, da der erste Parameter der Name der Funktion ist. Argv-Parameter ist ein Array von Zeigern an Saiten. Durch die Befehlszeile kann nur ein Stringtyp übertragen werden. Zeiger und Zeilen sind zwei große Themen, die separate Abschnitte erstellt werden. Es ist also über den Argv-Parameter und alle Informationen werden übertragen. Wir entwickeln ein Programm, das über die Windows-Befehlszeile ausgeführt wird und einige Informationen darüber übertragen.

// argc_argv.cpp: Bestimmt den Eingabepunkt für die Konsolenanwendung. #Include "stdafx.h" #include Verwenden von Namespace STD; Int main (int argc, char * argv) (wenn (argc\u003e<< argv<

// Codecode :: Blöcke

// dev-c ++ code

// argc_argv.cpp: Bestimmt den Eingabepunkt für die Konsolenanwendung. #Einschließen. Verwenden von Namespace STD; Int main (int argc, char * argv) (if (ARGC\u003e 1) // Wenn wir Argumente übertragen, ist der ARGC größer als 1 (abhängig von der Anzahl der Argumente) (Cout<< argv<

Nachdem Sie das Programm einschweifelt haben, öffnen Sie die Befehlszeile von Windows und ziehen Sie sie in das Befehlszeilenfenster unseres Programms im Befehlszeilenfenster, der vollständige Pfad zum Programm wird auf der Befehlszeile angezeigt (aber Sie können den Pfad verschreiben das manuelle Programm), dann können Sie klicken EINGEBEN Und das Programm startet (siehe Abbildung 1).

Abbildung 1 - Hauptfunktionseinstellungen

Da wir das Programm gerade gestartet und keine Argumente übergeben haben, erschien die Meldung keine Argumente. Abbildung 2 zeigt den Start des gleichen Programms über die Befehlszeile, jedoch bereits mit der Übertragung des offenen Arguments.

Abbildung 2 - Hauptfunktionsparameter

Das Argument ist das Wort offen, wie aus der Figur ersichtlich ist, dieses Wort auf dem Bildschirm erschien. Sie können mehrere Parameter sofort übertragen, um sie miteinander zu trennen. Wenn Sie den Parameter bestehen müssen, der aus mehreren Wörtern bestehen, müssen sie in doppelte Zitate eingenommen werden, und diese Wörter werden dann als ein Parameter betrachtet. Zum Beispiel zeigt die Abbildung den Start des Programms mit der Übertragung des Arguments, bestehend aus zwei Wörtern - sie funktioniert.

Abbildung 3 - Hauptfunktionsparameter

Und wenn Sie Zitate entfernen. Ich werde nur das Wort sehen. Wenn Sie nicht planen, Informationen, um Informationen zu übertragen, wenn Sie das Programm starten, können Sie Argumente in der Haupt- () -Funktion löschen, können Sie auch die Namen der Argumente ändern. Manchmal gibt es eine Änderung von ARGC- und ARGV-Parametern, aber alles hängt von der Art der erstellten Anwendung oder aus der Entwicklungsumgebung ab.

Stichworte: Befehlszeileneinstellungen

Befehlszeileneinstellungen

C und - kompilierte Sprache. Nach der Montage ist das Programm eine ausführbare Datei (wir berücksichtigen nicht die Erstellung dynamischer Bibliotheken, Treiber usw.). Unsere Programme sind sehr einfach und enthalten keine Laufzeitbibliotheken (Laufzeitbibliotheken), sodass sie mit demselben Betriebssystem (und ähnlicher Architektur) an einen Computer übertragen werden können und dort laufen.

Das Programm während des Startups kann Parameter annehmen. Sie sind die Argumente der Hauptfunktion. Allgemeine Ansicht der Hauptfunktion als nächstes

Void main (int argc, char ** argv) (...)

Das erste ARGC-Argument ist die Anzahl der übertragenen Parameterfunktionen. Das zweite Argument ist ein Array von Saiten - die Parameter selbst sind eigentlich. Da die Parameter der Funktion beliebig sein können, werden sie als Saiten übertragen, und das Programm selbst muss sie zerlegen und zum gewünschten Typ führen.

Das erste Argument (ARGV) ist immer der Name des Programms. In diesem Fall wird der Name angezeigt, je nachdem, wo das Programm ausgeführt wurde.

#Einschließen. #Einschließen. Void main (int argc, char ** argv) (druckf ("% s", argv);)

Lernen Sie jetzt ein wenig mit der Befehlszeile. Es wird benötigt, um die Argumente an unser Programm zu übertragen. Die Kombination der Win + R-Tasten ruft das Fenster "Run" auf. Geben Sie CMD darin ein und Sie öffnen die Befehlszeile. Sie können auch Cmd.exe-Suche im Startmenü finden. In unix-ähnlichen Betriebssystemen können Sie das Programm "Terminal" anrufen.

Wir werden keine vielen Teams studieren. Nur diejenigen, die in der Arbeit benötigt werden.

Standard für alle Betriebssysteme, der CD-Befehl übergibt den gewünschten Ordner. Es gibt zwei reservierte Name -. (Punkt) und .. (zwei Punkte). Der Punkt ist der Name des aktuellen Ordners.

Geht nirgendwo hin

Berufung an den Elternordner

Übergang zum Elternordner

Für den Übergang zur gewünschten CD-Adresse wird geschrieben. Sie müssen zum Beispiel zu Windows zum Ordner C: \\ Windows \\ System32 gehen

CD C: \\ windows \\ system32

In Linux, wenn Sie zum Ordner / var / mySQL gehen müssen

Cd / var / mySQL

Wenn der Pfad Leerzeichen enthält, wird es in doppelten Zitaten geschrieben

CD "D: \\ Docunts und Einstellungen \\ Prolog"

Das Terminal verfügt über folgende nützliche Funktionen: Wenn Sie den Aufwärtspfeil drücken, wird der vorherige ausgeführte Befehl angezeigt. Wenn Sie die Registerkarte drücken, versucht das Terminal, dem mit ihm bekannten Befehl eine Zeichenfolge hinzuzufügen, oder den Pfad hinzufügen, um alle Ordner und Dateien im aktuellen Ordner auszuschalten.
Wählen Sie CD C: \\
Drücken Sie die Registerkarte und sehen Sie, was passiert.

Ein weiterer wichtiger DIR-Befehl unter Windows und LS auf Linux zeigt den Inhalt des aktuellen Ordners an der Konsole (der Ordner, in dem Sie derzeit sind)

Ihr Programm hat Ihren vollständigen Namen zurückgegeben. Gehen Sie in den Ordner, in dem sich Ihr Programm befindet und seinen Inhalt anzeigt.


Nun, nachdem wir in unserem Ordner umgestellt haben, können Sie unser Programm durchführen. Geben Sie dazu ihren Namen ein.


Hinweis - Der Name hat sich geändert. Da das Programm aus seinem Ordner aufgerufen wird, wird es relativ zum Namen angezeigt. Jetzt ändern Sie das Programm und machen es alle Argumente. die auf sie übertragen werden.

#Einschließen. #Einschließen. Hauptsächlich hauptsächlich (int argc, char ** argv) (int i; für (i \u003d 0; ich< argc; i++) { printf("%s\n", argv[i]); } }

Sammeln Sie das Projekt. Stellen Sie vor der Montage sicher, dass das Programm geschlossen ist. Rufen Sie nun das Programm an, indem Sie es verschiedene Argumente angeben. Um dies zu tun, schreiben Sie den Namen des Programms und durch den Argumentraum


Sagen wir nun ein Programm, das zwei Argumente der Nummer empfängt, und zeigt ihre Summe an

#Einschließen. #Einschließen. #Einschließen. Void main (int argc, char ** argv) (int a, b; if (argc! \u003d 3) (Printf ("Error: fundierte% d-Argumente. Benötigt genau 2", Argc-1); Austritt (1); ) a \u003d atoi (argv); b \u003d atoi (argv); druckf ("% d", a + b);)

Wir sammeln und rufen an


Somit funktionieren die meisten Programme. Klicken Sie auf ein Etikett, Sie rufen das Programm an, an dem er sich bezieht. Die meisten Programme nehmen auch verschiedene Argumente ein. Sie können beispielsweise den Firefox-Browser von der Befehlszeile anrufen und die Argumente übertragen
Firefox.exe "www.mozilla.org" Site "und öffnet die Websites sofort in zwei Registerkarten an den angegebenen Adressen.

Viele Standardbefehle haben auch Parameter. Es wird in Fenstern akzeptiert, dass sie mit einem geraden Look in Unix mit minus oder zwei Minus beginnen. beispielsweise

Zeigt nur Ordner und im Linux-Terminal an

LS -L zeigt alle Dateien und Ordner mit Attributen an

Um zusätzliche Windows-Befehle anzuzeigen, geben Sie die Hilfe-Befehlszeile ein oder sehen Sie das Handbuch (im Internet ist leicht zu finden). Für Linux-Teams und ihre Optionen sind viel mehr, und einige von ihnen sind unabhängige Programmiersprachen, daher lohnt es sich, mindestens ein Minimum und ihre Optionen zu erlernen.

Borland C ++ unterstützt drei Haupt- ()-Argumente. Die ersten beiden sind traditionelle argz und argv. Dies sind die einzigen Argumente der Hauptfunktion (), die vom ANSI C. Standard definiert ist. Sie ermöglichen es Ihnen, Befehlszeilenargumente an das Programm übertragen zu können. Befehlszeilenargumente sind Informationen nach dem Programmnamen in der Befehlszeile des Betriebssystems. Wenn das Programm beispielsweise mit dem Borland-Spitzencompiler zusammengestellt wird, wird in der Regel in der Regel typisiert, BCC programmname

Wo nAME_PROGRAM. - Dies ist ein Programm, das kompilieren muss. Der Programmname wird als Argument an den Compiler übermittelt.

Der Parameter ARGC enthält die Anzahl der Befehlszeilenargumente und ist eine ganze Zahl. Es ist immer gleich mindestens 1, da der Name des Programms als das erste Argument qualifiziert ist. Argv-Parameter ist ein Zeiger auf ein Array von Zeichenzeigern. Jedes Element dieses Arrays gibt das Befehlszeilenargument an. Alle Befehlszeilenargumente sind Linien. Alle Nummern werden vom Programm im internen Format konvertiert. Das folgende Programm zeigt "Hallo" an, und dann den Benutzernamen, wenn Sie ihn direkt hinter dem Programmnamen wählen:

#Einschließen.

{
if (argc! \u003d 2)
{
Druckf ("Sie haben vergessen, Ihren Namen \\ n eingeben");
Rückgabe 1;
}
Printf ("Hallo% s", Argv);
Rückgabe 0;
}

Wenn Sie dieses Namensprogramm anrufen, und Sergeys Benutzername, um das Programm zu starten, sollten Sie das Programm wählen:
NAME Sergey.
Als Ergebnis des Programms wird das Programm angezeigt:
"Hallo Sergey".

Befehlszeilenargumente müssen durch Leerzeichen oder Registerkarten getrennt werden. Kommas, Punkte mit Kommas und ihre ähnlichen Charaktere werden nicht als Teiler betrachtet. Beispielsweise:

Besteht aus drei Zeilen während

Herb, Rick, Fred

Dies ist eine Linie - Kommas sind keine Trennzeichen.

Wenn Sie eine Zeichenfolge mit Leerzeichen oder Registerkarten in Form eines Arguments übertragen müssen, sollte er in doppelten Zitaten abgeschlossen werden. Dies ist beispielsweise ein Argument:

"Das ist ein Test"

Es ist wichtig, Argv richtig zu platzieren. Die typischste Methode ist:

Leere Klammern zeigen an, dass das Array keine feste Länge hat. Sie können mit der Argv-Indizierung auf einzelne Elemente zugreifen. ARGV zeigt beispielsweise die erste Zeichenfolge an, die immer den Programmnamen enthält. Argv zeigt die nächste Zeile an und so weiter.

Nachfolgend finden Sie ein kleines Beispiel mit Befehlszeilenargumenten. Sie zählt in umgekehrter Reihenfolge von dem in der Befehlszeile angegebenen Wert, und wenn die Null erreicht ist, gibt das Signal an. Wir beachten, dass das erste Argument eine Zahl enthält, die mit der Standard-AtOI () -Funktion in eine Ganzzahl umgewandelt wird. Wenn die Zeichenfolge "Display" als zweites Argument vorhanden ist, wird der Zähler selbst auf dem Bildschirm angezeigt.

/ * Referenzprogramm * /

#Einschließen.
#Einschließen.
# Inkl
Int Main (int argc, char * argv)
{
Int disk, zählen;
if (argc.<2)
{
Printf ("Sie müssen die Länge des Count \\ n eingeben);
Printf ("auf der Befehlszeile. Versuchen Sie es erneut. \\ N");
Rückgabe 1;
}
If (argc \u003d\u003d 3 &&! strcmp (argv, "display")) dis \u003d 1;
Sonst disk \u003d 0;
Für (count \u003d atoi (argv); zählen; -Count)
if (disk) printf ("% d", count);
Printf ("% C", "\\ A"); / * Bei den meisten Computern ist es ein Anruf * /
Rückgabe 0;
}

Beachten Sie, dass, wenn die Argumente nicht angegeben sind, eine Fehlermeldung angezeigt wird. Dies ist der typischste für Programme, die die Befehlszeilenargumente verwenden, um Anweisungen auszugeben, wenn ein Versuch, das Programm ohne korrekte Informationen zu starten.

Um auf separate Symbole der Befehlszeile zuzugreifen, fügen Sie den zweiten Index für Argv hinzu. Das nächste Programm zeigt beispielsweise alle Argumente an, mit denen er aufgerufen wurde, ein Zeichen zu einem Zeitpunkt:

#Einschließen.
Int Main (int argc, char * argv)
{
Int t, ich;
für (t \u003d 0; t {
i \u003d 0;
Während (argv [t] [i])
{
Printf ("% C", Argv [T] [I]);
}
Printf ("");
}
Rückgabe 0;
}

Es ist notwendig, sich daran zu erinnern, dass der erste Index für den Zugriff auf die Zeichenfolge konzipiert ist, und der zweite soll auf das Zeichenfolgesymbol zugreifen.

Normalerweise werden Argc und Argv verwendet, um Quellbefehle zu erhalten. Theoretisch können Sie bis zu 32767 Argumente haben, aber die meisten Betriebssysteme ermöglichen es nicht einmal, sich darüber anzusprechen. In der Regel werden die Argumente verwendet, um den Dateinamen oder die Optionen anzugeben. Die Verwendung der Befehlszeilenargumente ergibt dem Programm ein professionelles Look und ermöglicht es uns, das Programm in Befehlsdateien zu verwenden.

Wenn Sie die mit Borland C ++ gelieferte Wildargs.OBJ-Datei anschließen, können Sie Vorlagen in den Argumenten * .exe-Typ verwenden. (Borland C ++ verarbeitet die Vorlagen automatisch und erhöht ARGC.) Wenn Sie beispielsweise eine Verbindung zum nächsten Wildargs.Obj-Programm herstellen, gibt es heraus, wie viele Dateien mit dem Namen der in der Befehlszeile angegebenen Datei übereinstimmen:

/ * Registrieren Sie dieses Programm von Wildargs.obj * /

#Einschließen.
Int Main (int argc, char * argv)
{
Registrieren int i;
Printf ("% d-Dateien übereinstimmen mit dem angegebenen Namen \\ N", ARGC-1);
Printf ("Sie sind:");
für (i \u003d 1; ich Printf ("% s", argv [i]);
Rückgabe 0;
}

Wenn Sie dieses WA-Programm nennen, starten Sie ihn, wie unten angegeben, die Anzahl der Dateien mit Extension Ex erhalten, und die Liste der Namen dieser Dateien:

Zusätzlich zu ARGC und ARGV Borland C ++ bietet auch das dritte Argument der -NV-Befehlszeile. Der Parameter ENV ermöglicht das Programm, auf Informationen über die Betriebssystemumgebung zuzugreifen. Der Parameter ENV muss Argc und Argv folgen und wird wie folgt deklariert:

Wie Sie sehen, ist ENV als auch Argv deklariert. Genau wie Argv ist es ein Zeiger auf ein Array an Reihen. Jede Zeichenfolge ist eine Zeichenfolge einer vom Betriebssystem definierten Umgebung. Der Parameter ENV hat kein Analogon eines Argc-Parameters, der berichten würde, wie sehr die Reihen des Mediums. Stattdessen die letzte Reihe der Null-Umgebung. Das folgende Programm zeigt alle in dem Betriebssystem definierten Reihen der Umgebung an:

/ * Dieses Programm zeigt alle Reihen der Umwelt an * /

#Einschließen.
Int Main (int argc, char * argv, char * env)
{
int t;
Für (t \u003d 0; env [t] / t ++)
Printf ("% s \\ n", env [t]);
Rückgabe 0;
}

Wir stellen fest, dass obwohl argc und argv nicht vom Programm verwendet werden, sie müssen in der Liste der Parameter anwesend sein. C kennt nicht die Namen der Parameter. Stattdessen ist ihre Verwendung in der Auftragserklärung der Parameter definiert. In der Tat können Sie den Parameter so anrufen, wie Sie möchten. Da ARGC, ARGV und ENV traditionellen Namen sind, ist es besser, sie weiter zu verwenden, dass jede Person, die das Programm liest, sofort verstehen kann, dass dies die Argumente der Hauptfunktion () sind.

Für die Programme einer typischen Aufgabe ist es, den in der Zeile des Mediums definierten Wert zu durchsuchen. Beispielsweise können der Inhalt der Pfadzeichenfolge Programme die Suchpfade verwenden. Das folgende Programm zeigt, wie Zeilen gefunden werden, die die Standard-Suchpfade ankündigen. Es verwendet die Standardbibliotheksfunktion STSTRSTR () mit dem folgenden Prototyp:

Char * ststr (const char * str1, const char * str2);

Die STSTRR () -Funktion sucht nach einem Zeichenfolgen, an dem STR1 in der Zeichenfolge zeigt, an der STR2 angibt. Wenn eine solche Zeichenfolge gefunden wird, wird der Zeiger in die erste Position zurückgegeben. Wenn keine Korrespondenzen gefunden werden, kehrt die Funktion NULL zurück.

/ * Das Programm sucht nach einer Zeichenfolge mit Pfad * /

#Einschließen.
#Einschließen.
Int Main (int argc, char * argv, char * env)
{
int t;
Für (t \u003d 0; env [t]; t ++)
{
Wenn (strstrstr (env [t], "path"))
Printf ("% s \\ n", env [t]);
}
Rückgabe 0;
}

Mit der automatisierten Erstellung einer Konsolenanwendung in der Programmiersprache C ++ wird die Hauptfunktion automatisch sehr ähnlich erstellt:

int Main (int argc, char * argv)
{…}

Der Funktionsheader enthält die Unterschrift der Hauptfunktion Main () mit Argumenten Args und Argv.
Wenn Sie das Programm über die Befehlszeile ausführen, können alle Informationen an dieses Programm übertragen werden. Dazu gibt es Argumente der ARGC- und ARGV-Befehlszeile.
Der Parameter argc hat einen int-Typ und enthält die Anzahl der in der Hauptfunktion übertragenen Parameter. Darüber hinaus ist ARGC immer mindestens 1, auch wenn die Hauptfunktionen nicht von Informationen übertragen werden, da der Name der Anwendung der erste Parameter betrachtet wird.
Der Argv-Parameter ist ein Array von Zeigern an Saiten. Durch die Befehlszeile kann nur ein Stringtyp übertragen werden.

Wenn Sie das Programm über die Windows-Befehlszeile starten, können Sie einige Informationen darüber übertragen. In diesem Fall wird die Befehlszeile ansehen:
Disk: \\ path \\ name.exe argument1 argument2 ...

Befehlszeilenargumente werden durch einen oder mehrere Leerzeichen getrennt.

Argv-Argument enthält den vollständigen Namen der Anwendung:

#Einschließen.
verwenden von Namespace STD;

kehre<< argv << endl;

Rückgabe 0;
}

Ergebnis der Durchführung.

Beispiel: Berechnen der Arbeit von zwei Ganzzahlen
Das Programm verwendet eine Zeichenfolge-Konvertierungsfunktion einer Ganzzahl Strtoint () von hier.

#Einschließen.
verwenden von Namespace STD;
int strtoint (char * s) (...)
int main (int argc, char * argv) (

INT A \u003d 0, B \u003d 0;

If (argc\u003e 1)

a \u003d strtoint (argv);

If (argc\u003e 2)

b \u003d Strtoint (Argv);

kehre<< a <<«*» << b << «= « << a*b << endl;

Rückgabe 0;
}

Das Programm starten wird als

Ergebnis der Durchführung.

Debugging des Programms mit Befehlszeilenargumenten

Um die Argumente der Befehlszeile beim Debuggen des Programms zu übertragen, müssen Sie sich mit dem Menü wenden Eigenschaften Projekt.


Auf der Registerkarte Konfigurationseigenschaften -\u003e Debugging wählen Argumente Team. Und fragen Sie ihre Werte.

Wenn Sie das Programm im Debug-Modus starten, werden die eingegebenen Argumente vom Programm als Befehlszeilenargumente wahrgenommen.

Fortsetzung des Themas:
Netzwerk

EINLEITUNG Es ist passiert, dass, als die Zeit des nächsten Upgrades aufkam, fast alle Komponenten neuer. Und die alte, freundliche, gute ...