Optionale und benannte Argumente
Optionale Argumente
C# 4.0 führt ein neues Feature ein, das die bequemere Angabe von Argumenten beim Aufrufen einer Methode verbessert. Dieses Werkzeug heißt optionale Argumente und ermöglicht es Ihnen, einen Standardwert für einen Methodenparameter zu definieren. Dieser Wert wird standardmäßig verwendet, wenn beim Aufruf der Methode kein entsprechendes Argument für den Parameter angegeben wird. Daher ist es nicht erforderlich, für einen solchen Parameter ein Argument anzugeben. Optionale Argumente erleichtern das Aufrufen von Methoden, bei denen Standardargumente auf einige Parameter angewendet werden. Sie können auch als "kurze" Form der Methodenüberladung verwendet werden.
Der Hauptgrund für das Hinzufügen optionaler Argumente war die Notwendigkeit, die Interaktion mit COM-Objekten zu vereinfachen. In mehreren Microsoft-Objektmodellen (z. B. Microsoft Office)-Funktionalität wird durch COM-Objekte bereitgestellt, von denen viele vor langer Zeit geschrieben und für die Verwendung optionaler Parameter entwickelt wurden.
Ein Beispiel für die Verwendung optionaler Argumente ist unten dargestellt:
Verwenden des Systems; mit System.Collections.Generic; mit System.Linq; mit System.Text; namespace ConsoleApplication1 ( class Program ( // Argumente b und c sind optional beim Aufruf von static int mySum(int a, int b = 5, int c = 10) ( return a + b + c; ) static void Main() ( int sum1 = meineSumme(3); int sum2 = meineSumme(3,12); Console.WriteLine("Summe1 = "+sum1); Console.WriteLine("Sum2 = "+sum2); Console.ReadLine(); ) ) )
Es ist zu beachten, dass alle optionalen Argumente unbedingt rechts von den erforderlichen angegeben werden müssen. Zusätzlich zu Methoden können optionale Argumente in Konstruktoren, Indexern und Delegaten verwendet werden.
Ein Vorteil optionaler Argumente besteht darin, dass sie dem Programmierer den Umgang mit komplexen Methoden- und Konstruktoraufrufen erleichtern. Schließlich müssen oft mehr Parameter in einer Methode eingestellt werden, als normalerweise erforderlich ist. Und in solchen Fällen können einige dieser Parameter durch sorgfältige Verwendung der optionalen Argumente optional gemacht werden. Das bedeutet, dass Sie nur die Argumente übergeben müssen, die im gegebenen wichtig sind konkreten Fall, nicht alle Argumente, die sonst erforderlich sein sollten. Dieser Ansatz ermöglicht es uns, das Verfahren zu rationalisieren und die Handhabung durch den Programmierer zu vereinfachen.
Benannte Argumente
Einer noch Funktionalität, das mit der Veröffentlichung von .NET 4.0 zu C# hinzugefügt wurde, unterstützt die sog benannte Argumente. Wie Sie wissen, muss bei der Übergabe von Argumenten an eine Methode die Reihenfolge, in der sie erscheinen, in der Regel mit der Reihenfolge übereinstimmen, in der die Parameter in der Methode selbst definiert sind. Mit anderen Worten, der Argumentwert wird dem Parameter durch seine Position in der Argumentliste zugewiesen.
Benannte Argumente sollen diese Einschränkung überwinden. Mit einem benannten Argument können Sie den Namen des Parameters angeben, dem sein Wert zugewiesen wird. Und in diesem Fall spielt die Reihenfolge der Argumente keine Rolle mehr. Daher ähneln benannte Argumente den zuvor erwähnten Objektinitialisierern, obwohl sie sich in ihrer Syntax von ihnen unterscheiden. Um ein Argument nach Namen anzugeben, verwenden Sie die folgende Form der Syntax:
Parametername: Wert
Hier Parametername bezeichnet den Namen des Parameters, an den der Wert übergeben wird. Parametername muss natürlich der Name eines gültigen Parameters für die aufgerufene Methode sein.
Es kommt vor, dass Daten beim Aufruf von der Kommandozeile an das Programm übertragen werden. Solche Daten werden Befehlszeilenargumente genannt. Das sieht zum Beispiel so aus:
./a.out test.txt ls -lt /home/peter/
Dadurch werden die Programme a.out (aus dem aktuellen Verzeichnis) und ls (aus demselben Verzeichnis, das in der Umgebungsvariablen PATH angegeben ist) aufgerufen. Das erste Programm von der Befehlszeile erhält ein Wort - test.txt, das zweite - zwei: -lt und /home/peter/.
Wenn das Programm in C geschrieben ist, wird die Kontrolle beim Start sofort an die Funktion main() übergeben, daher erhält sie die Befehlszeilenargumente, die ihren variablen Parametern zugewiesen werden.
Bisher haben wir die Funktion main() so definiert, als ob sie keine Parameter annehmen und nichts zurückgeben würde. Tatsächlich gibt jede Funktion in C standardmäßig (wenn nichts anderes definiert ist) eine ganze Zahl zurück. Dies kann überprüft werden. Wenn Sie den Code so schreiben:
main() ( printf("Hallo \N") ; 0 zurückgeben ; )
Dann treten beim Kompilieren keine Warnungen oder Fehler auf. Dasselbe passiert, wenn wir int main() schreiben. Dies beweist, dass die Standardfunktion eine Ganzzahl und nicht nichts (void) zurückgibt. Obwohl das, was die Funktion zurückgibt, immer "überschrieben" werden kann, zum Beispiel voidmain() oder float main() .
Wenn ein Programm von der Kommandozeile aus aufgerufen wird, wird ihm immer ein Datenpaar übergeben:
- ganze Zahl, die die Anzahl der Wörter (durch Leerzeichen getrennte Elemente) in der Befehlszeile beim Aufruf angibt,
- Zeiger auf Array von Strings, wobei jede Zeile ein einzelnes Wort aus der Befehlszeile ist.
Beachten Sie, dass auch der Programmname selbst berücksichtigt wird. Wenn der Aufruf beispielsweise so aussieht:
./a.out 12 Thema 2
Dann ist das erste Argument des Programms 4, und das String-Array ist definiert als ("./a.out", "12", "theme", "2").
Achten Sie auf die Terminologie, es gibt nur zwei Programmargumente (eine Zahl und ein Array), aber beliebig viele Kommandozeilenargumente. Befehlszeilenargumente werden in Programmargumente "übersetzt" (in Argumente für die Funktion main()).
Diese Daten (Zahl und Zeiger) werden dem Programm auch dann übergeben, wenn es nur mit Namen aufgerufen wird, ohne ihm etwas zu übergeben: ./a.out. In diesem Fall ist das erste Argument 1 und das zweite Argument zeigt auf ein Array mit nur einer Zeichenfolge ("./a.out").
Die Tatsache, dass Daten an das Programm übergeben werden, bedeutet nicht, dass die main()-Funktion sie empfangen sollte. Wenn die main()-Funktion ohne Parameter definiert wird, kann nicht auf die Befehlszeilenargumente zugegriffen werden. Obwohl nichts Sie daran hindert, sie zu senden. Es wird kein Fehler auftreten.
Um Zugriff auf die an das Programm übergebenen Daten zu erhalten, müssen diese Variablen zugewiesen werden. Da die Argumente sofort an main() übergeben werden, sollte der Header so aussehen:
main (int n, char *arr)
Die erste Variable (n) enthält die Anzahl der Wörter, und die zweite Variable enthält einen Zeiger auf ein Array von Zeichenfolgen. Oft wird der zweite Parameter als **arr geschrieben. Es ist jedoch dasselbe. Erinnern Sie sich daran, dass das String-Array selbst Zeiger auf Strings als seine Elemente enthält. Und in der Funktion übergeben wir einen Zeiger auf das erste Element des Arrays. Es stellt sich heraus, dass wir einen Zeiger auf einen Zeiger übergeben, d.h. **arr.
Übung
Schreiben Sie ein Programm wie dieses:
#enthalten
Es gibt die Anzahl der Wörter auf der Befehlszeile aus, wenn es aufgerufen wird, und jedes Wort mit Neue Zeile. Rufen Sie es ohne Befehlszeilenargumente und mit Argumenten auf.
Im Programm haben wir die variablen Parameter argc und argv verwendet. Es ist üblich, nur solche Namen zu verwenden, aber tatsächlich können sie alles sein. Es ist besser, sich an diesen Standard zu halten, damit Ihre Programme nicht nur für Sie, sondern auch für andere Programmierer verständlicher sind.
Die praktische Bedeutung der Datenübergabe an ein Programm
Wenn Sie Erfahrung mit der GNU/Linux-Befehlszeile haben, wissen Sie, dass die meisten Befehle Schalter und Argumente haben. Beispielsweise werden beim Anzeigen des Inhalts von Verzeichnissen, Kopieren, Verschieben, Objekte als Argumente angegeben Dateisystem auf dem der Befehl ausgeführt wird. Merkmale seiner Implementierung werden anhand von Schlüsseln bestimmt. Zum Beispiel im Befehl
Cp -r ../les_1 ../les_101
cp ist der Name des Befehls, -r ist der Schalter und ../les_1 und ../les_101 sind die Befehlsargumente.
Im Allgemeinen werden beim Starten von Programmen meistens Dateiadressen und "Modifikatoren" (dies sind Schlüssel) des Programmausführungsprozesses übertragen.
Schreiben wir ein Programm, das die vom Benutzer angegebenen Dateien auf der Befehlszeile zum Schreiben oder Anhängen öffnet und dort dieselben Informationen schreibt (hinzufügt), die der Benutzer während der Programmausführung über die Tastatur eingibt:
#enthalten
Erläuterungen zum Code:
- Ein Array aus fünf Dateizeigern wird erstellt. Daher können nicht mehr als fünf Dateien gleichzeitig geöffnet werden. Der Dateizeiger der ersten Datei wird im Array-Element f gespeichert, der zweite - in f und so weiter.
- Die Anzahl der Kommandozeilenargumente wird überprüft. Es müssen mindestens drei sein, denn. der erste ist der Name des Programms, der zweite ist der Dateiöffnungsmodus, der dritte ist die erste oder einzige Datei, in die geschrieben werden soll. Da Sie mit dem Programm nur fünf Dateien öffnen können, darf die Gesamtzahl der Befehlszeilenargumente sieben nicht überschreiten. Wenn also die Anzahl der Argumente kleiner als 3 oder größer als 7 ist, endet das Programm, weil Die return-Anweisung bewirkt, dass die Funktion beendet wird, auch wenn danach noch mehr Code folgt. Ein Funktionsrückgabewert ungleich 0 kann vom übergeordneten Prozess als Meldung interpretiert werden, dass das Programm mit einem Fehler beendet wurde.
- Die Korrektheit des zweiten Kommandozeilenarguments wird überprüft. Wenn es weder "-w" noch "-a" ist, gibt der bedingte Ausdruck im zweiten if 1 (wahr) zurück. Mit der Funktion strcmp() können Sie Zeichenfolgen vergleichen und 0 zurückgeben, wenn sie gleich sind.
- IN für Schleife Dateien werden an den angegebenen Adressen geöffnet, die mit dem dritten Element des argv-Arrays beginnen. Aus diesem Grund wird 2 zu i hinzugefügt, um die Elemente des argv-Arrays zu erhalten, beginnend mit dem dritten. Der Ausdruck argc-2 gibt die Anzahl der übergebenen Dateinamen an; Weil argc speichert die Gesamtzahl der Befehlszeilenargumente, von denen die ersten beiden keine Dateinamen sind.
- Der Ausdruck argv+1 ermöglicht es Ihnen, den Teilstring „w“ (oder „a“) aus dem String „-w“ (oder „-a“) zu „schneiden“, weil argv ist im Wesentlichen ein Zeiger auf das erste Element der Zeichenfolge. Indem wir dem Zeiger eins hinzufügen, verschieben wir ihn zum nächsten Element im Array.
- Wenn die Datei nicht geöffnet werden kann, gibt die Funktion fopen() NULL zurück. In diesem Fall endet das Programm.
- Jedes vom Benutzer über die Tastatur eingegebene Zeichen wird in alle geöffneten Dateien geschrieben.
- Am Ende werden die Dateien geschlossen.
Beim automatischen Erstellen einer Konsolenanwendung in der Programmiersprache C++ wird automatisch eine Hauptfunktion erstellt, die dieser sehr ähnlich ist:
int main(int argc, char * argv)
{…}
Der Funktionskopf enthält die Signatur Hauptfunktion main() mit den Argumenten argc und argv .
Wenn das Programm über die Kommandozeile ausgeführt wird, ist es möglich, beliebige Informationen an dieses Programm zu übertragen. Dafür gibt es die Kommandozeilenargumente argc und argv.
Der Parameter argc ist vom Typ int und enthält die Anzahl der an die Hauptfunktion übergebenen Parameter. Außerdem ist argc immer mindestens 1, auch wenn keine Informationen an die Hauptfunktion übergeben werden, da der Name der Anwendung als erster Parameter betrachtet wird.
Der argv-Parameter ist ein Array von Zeigern auf Strings. Über die Befehlszeile können nur Daten vom Typ Zeichenfolge übergeben werden.
Beim Starten des Programms per Befehl Windows-Linie Sie können ihm einige Informationen senden. In diesem Fall sieht die Befehlszeile wie folgt aus:
Laufwerk:\Pfad\Name.exe Argument1 Argument2 ...
Befehlszeilenargumente werden durch ein oder mehrere Leerzeichen getrennt.
Das Argument argv enthält den vollständig qualifizierten Anwendungsnamen:
#enthalten
mit Namensraum std;
cout<< argv << endl;
0 zurückgeben;
}
Ausführungsergebnis
Beispiel: Berechnung des Produkts zweier ganzer Zahlen
Das Programm verwendet ab hier die String-zu-Integer-Konvertierungsfunktion StrToInt() .
#enthalten
mit Namensraum std;
int StrToInt(char*s) (…)
int main(int argc, char * argv) (
Int a = 0, b = 0;
Wenn (argc > 1)
a = StrToInt(argv);
Wenn (arg > 2)
b = StrToInt(argv);
cout<< a <<«*» << b << «= « << a*b << endl;
0 zurückgeben;
}
Das Programm wird gestartet als
Ausführungsergebnis
Debuggen eines Programms mit Befehlszeilenargumenten
Um beim Debuggen eines Programms Befehlszeilenargumente zu übergeben, müssen Sie auf das Menü zugreifen Eigenschaften Projekt. 
Auf der Registerkarte Konfigurationseigenschaften -> Debuggen wählen Befehlsargumente und ihre Werte festlegen. 
Wenn Sie das Programm im Debug-Modus ausführen, werden die eingegebenen Argumente vom Programm als Befehlszeilenargumente behandelt.
Manchmal ist es beim Starten eines Programms nützlich, ihm einige Informationen zu übergeben. Normalerweise werden diese Informationen über Befehlszeilenargumente an die Funktion main() übergeben. Befehlszeilenargument sind Informationen, die in der Befehlszeile des Betriebssystems nach dem Programmnamen eingegeben werden. Um beispielsweise mit dem Kompilieren eines Programms zu beginnen, müssen Sie nach der Eingabeaufforderung Folgendes in die Befehlszeile eingeben:
cc Programmname
Programmname ist ein Befehlszeilenargument, das den Namen des Programms angibt, das Sie kompilieren möchten.
Um Befehlszeilenargumente zu akzeptieren, werden zwei spezielle eingebaute Argumente verwendet: argc und argv . Der Parameter argc enthält die Anzahl der Argumente in der Befehlszeile und ist eine ganze Zahl, und er ist immer mindestens 1, weil das erste Argument der Name des Programms ist. Und der Parameter argv ist ein Zeiger auf ein Array von Zeigern auf Strings. In diesem Array zeigt jedes Element auf ein Befehlszeilenargument. Alle Befehlszeilenargumente sind Zeichenfolgen, daher muss das Konvertieren beliebiger Zahlen in das gewünschte Binärformat im Programm bereitgestellt werden, wenn es entwickelt wird.
Hier ist ein einfaches Beispiel für die Verwendung des Befehlszeilenarguments. Auf dem Bildschirm werden das Wort „Hello“ und Ihr Name angezeigt, die als Befehlszeilenargument angegeben werden müssen.
#enthalten
Wenn Sie diesem Programm den Namen (Name) gegeben haben und Ihr Name Tom ist, geben Sie zum Ausführen des Programms den Namen Tom in der Befehlszeile ein. Als Ergebnis der Ausführung des Programms erscheint die Nachricht Hallo, Tom auf dem Bildschirm.
In vielen Umgebungen müssen alle Befehlszeilenargumente durch ein Leerzeichen oder einen Tabulator voneinander getrennt werden. Kommas, Semikolons und ähnliche Zeichen gelten nicht als Trennzeichen. Zum Beispiel,
Lauf Spot, lauf
besteht aus drei Zeichenketten, während
Eric, Rick, Fred
ist eine einzelne Zeichenfolge - Kommas gelten im Allgemeinen nicht als Trennzeichen.
Wenn die Zeichenfolge Leerzeichen enthält, kann die Zeichenfolge in einigen Umgebungen in doppelte Anführungszeichen eingeschlossen werden, um zu verhindern, dass mehrere Argumente angegeben werden. Als Ergebnis wird die gesamte Zeichenfolge als ein Argument betrachtet. Um mehr darüber zu erfahren, wie Befehlszeilenoptionen auf Ihrem Betriebssystem festgelegt werden, lesen Sie die Dokumentation für dieses System.
Es ist sehr wichtig, argv korrekt zu deklarieren. So machen sie es am häufigsten:
Char *argv;
Leere eckige Klammern zeigen an, dass das Array eine unbestimmte Länge hat. Sie können jetzt auf einzelne Argumente zugreifen, indem Sie das argv-Array indizieren. Beispielsweise zeigt argv auf die erste Zeichenfolge, die immer der Programmname ist; argv zeigt auf das erste Argument und so weiter.
Ein weiteres kleines Beispiel für die Verwendung von Befehlszeilenargumenten ist das Countdown-Programm unten. Dieses Programm zählt von einem (in der Befehlszeile angegebenen) Wert herunter und gibt einen Piepton aus, wenn es 0 erreicht. Beachten Sie, dass das erste Argument, das den Anfangswert enthält, mithilfe der Standardfunktion atoi () in einen ganzzahligen Wert umgewandelt wird. Wenn das zweite Argument der Befehlszeile (und wenn wir den Namen des Programms als drittes Argument nehmen) der String "display" (Ausgabe auf dem Bildschirm) ist, wird das Ergebnis des Countdowns (in umgekehrter Reihenfolge) angezeigt auf dem Bildschirm.
/* Programm zum Rückwärtszählen. */ #enthalten
Beachten Sie, dass eine Fehlermeldung angezeigt wird, wenn keine Befehlszeilenargumente angegeben werden. Programme mit Befehlszeilenargumenten tun häufig Folgendes: Wenn der Benutzer diese Programme ausführt, ohne die erforderlichen Informationen einzugeben, werden Anweisungen zur korrekten Angabe der Argumente angezeigt.
Um auf ein einzelnes Zeichen in einem der Befehlszeilenargumente zuzugreifen, geben Sie den zweiten Index in argv ein. Das folgende Programm gibt beispielsweise zeichenweise alle Argumente aus, mit denen es aufgerufen wurde:
#enthalten Denken Sie daran, dass der erste Index von argv Zugriff auf die Zeichenfolge bietet und der zweite Index Zugriff auf die einzelnen Zeichen. Normalerweise werden argc und argv verwendet, um die Anfangsbefehle an das Programm zu übergeben, die es beim Start benötigt. Beispielsweise geben Befehlszeilenargumente häufig Informationen wie einen Dateinamen, eine Option oder ein alternatives Verhalten an. Die Verwendung von Befehlszeilenargumenten verleiht Ihrem Programm ein "professionelles Aussehen" und erleichtert die Verwendung in Batchdateien. Die Namen argc und argv sind traditionell, aber nicht erforderlich. Sie können diese beiden Parameter in der Funktion main() beliebig benennen. Einige Compiler unterstützen möglicherweise -zusätzliche Argumente für main(), also überprüfen Sie unbedingt die Dokumentation Ihres Compilers. Wenn ein Programm keine Befehlszeilenparameter benötigt, ist es am häufigsten, die main()-Funktion ausdrücklich so zu deklarieren, dass sie keine Parameter hat. In diesem Fall wird das Schlüsselwort void in der Parameterliste dieser Funktion verwendet. Borland C++ unterstützt drei main()-Argumente. Die ersten beiden sind traditionelles argc und argv. Dies sind die einzigen Argumente für die main()-Funktion, die durch den ANSI-C-Standard definiert sind, und ermöglichen die Übergabe von Befehlszeilenargumenten an das Programm. Befehlszeilenargumente sind die Informationen, die dem Programmnamen in der Befehlszeile des Betriebssystems folgen. Wenn beispielsweise ein Programm mit dem Borland-Inline-Compiler kompiliert wird, wird normalerweise bcc eingegeben Programmname Wo Programmname ist das zu kompilierende Programm. Der Programmname wird als Argument an den Compiler übergeben. Der Parameter argc enthält die Anzahl der Befehlszeilenargumente und ist eine ganze Zahl. Es ist immer mindestens 1, weil der Programmname als erstes Argument qualifiziert wird. Der Parameter argv ist ein Zeiger auf ein Array von Zeichenzeigern. Jedes Element dieses Arrays zeigt auf ein Befehlszeilenargument. Alle Befehlszeilenargumente sind Zeichenfolgen. Alle Zahlen werden vom Programm in ein internes Format umgewandelt. Das folgende Programm gibt "Hallo" gefolgt vom Benutzernamen aus, wenn es direkt nach dem Programmnamen eingegeben wird: #enthalten Wenn Sie diesen Programmnamen aufrufen und der Benutzername Sergey ist, sollten Sie Folgendes eingeben, um das Programm auszuführen: Befehlszeilenargumente müssen durch Leerzeichen oder Tabulatoren getrennt werden. Kommas, Semikolons und ähnliche Zeichen gelten nicht als Trennzeichen. Zum Beispiel: Besteht aus drei Zeilen, während Kraut, Rick, Fred Dies ist eine Zeile - Kommas sind keine Trennzeichen. Wenn Sie eine Zeichenfolge mit Leerzeichen oder Tabulatoren als einzelnes Argument übergeben möchten, schließen Sie sie in doppelte Anführungszeichen ein. Dies ist beispielsweise ein Argument: "das ist ein Test" Es ist wichtig, argv korrekt zu deklarieren. Die typischste Methode ist: Die leeren Klammern zeigen an, dass das Array keine feste Länge hat. Sie können auf einzelne Elemente zugreifen, indem Sie die argv-Indizierung verwenden. Beispielsweise zeigt argv auf die erste Zeile, die immer den Namen des Programms enthält. argv zeigt auf die nächste Zeile und so weiter. Nachfolgend finden Sie ein kleines Beispiel für die Verwendung von Befehlszeilenargumenten. Es zählt ab dem auf der Kommandozeile angegebenen Wert herunter und gibt ein Signal aus, wenn Null erreicht ist. Beachten Sie, dass das erste Argument eine Zahl enthält, die mithilfe der Standardfunktion atoi() in eine Ganzzahl umgewandelt wurde. Wenn als zweites Argument die Zeichenfolge „display“ vorhanden ist, wird der Zähler selbst auf dem Bildschirm angezeigt. /* Zählprogramm */ #enthalten Beachten Sie, dass eine Fehlermeldung angezeigt wird, wenn keine Argumente angegeben werden. Dies ist am typischsten für Programme, die Befehlszeilenargumente verwenden, um Anweisungen auszugeben, wenn versucht wurde, das Programm ohne die richtigen Informationen auszuführen. Um auf einzelne Befehlszeilenzeichen zuzugreifen, fügen Sie argv einen zweiten Index hinzu. Das folgende Programm gibt beispielsweise alle Argumente aus, mit denen es aufgerufen wurde, Zeichen für Zeichen: #enthalten Es muss daran erinnert werden, dass der erste Index für den Zugriff auf die Zeichenfolge und der zweite für den Zugriff auf das Zeichen der Zeichenfolge dient. Typischerweise werden argc und argv verwendet, um Quellbefehle zu erhalten. Theoretisch können Sie bis zu 32767 Argumente haben, aber die meisten Betriebssysteme erlauben es Ihnen nicht einmal, sich dem zu nähern. Normalerweise werden diese Argumente verwendet, um einen Dateinamen oder Optionen anzugeben. Die Verwendung von Befehlszeilenargumenten verleiht dem Programm ein professionelles Aussehen und ermöglicht die Verwendung des Programms in Batchdateien. Wenn Sie die mit Borland C++ gelieferte Datei WILDARGS.OBJ einschließen, können Sie Platzhalter in Argumenten des Typs *.EXE verwenden. (Borland C++ behandelt Muster automatisch und erhöht argc entsprechend.) Wenn Sie beispielsweise WILDARGS.OBJ mit dem folgenden Programm verbinden, wird es ausgeben, wie viele Dateien mit dem Namen der in der Befehlszeile angegebenen Datei übereinstimmen: /* Dieses Programm mit WILDARGS.OBJ verknüpfen */ #enthalten Wenn wir dieses Programm WA nennen und es wie folgt ausführen, erhalten wir die Anzahl der Dateien mit der Erweiterung EXE und eine Liste der Namen dieser Dateien: Zusätzlich zu argc und argv bietet Borland C++ noch ein drittes Kommandozeilenargument -env. Der Parameter env ermöglicht dem Programm den Zugriff auf Informationen über die Betriebssystemumgebung. Der Parameter env muss auf argc und argv folgen und wird wie folgt deklariert: Wie Sie sehen, wird env genauso deklariert wie argv. Genau wie argv ist dies ein Zeiger auf ein Array von Strings. Jede Zeile ist eine vom Betriebssystem definierte Umgebungszeichenfolge. Der env-Parameter hat kein Gegenstück zum argc-Parameter, der angibt, wie viele Umgebungszeilen es gibt. Stattdessen ist die letzte Zeile der Umgebung null. Das folgende Programm gibt alle derzeit im Betriebssystem definierten Umgebungszeichenfolgen aus: /* dieses Programm gibt alle Umgebungszeilen aus */ #enthalten Beachten Sie, dass argc und argv zwar nicht vom Programm verwendet werden, aber in der Parameterliste vorhanden sein müssen. C kennt die Parameternamen nicht. Stattdessen wird ihre Verwendung durch die Reihenfolge bestimmt, in der die Parameter deklariert werden. Tatsächlich können Sie den Parameter beliebig nennen. Da argc, argv und env traditionelle Namen sind, ist es am besten, sie weiterhin zu verwenden, damit jeder, der das Programm liest, sofort erkennen kann, dass dies Argumente für die Funktion main() sind. Bei Programmen besteht eine typische Aufgabe darin, den in der Umgebungszeichenfolge definierten Wert zu finden. Beispielsweise ermöglicht der Inhalt der PATH-Zeichenfolge Programmen, Suchpfade zu verwenden. Das folgende Programm demonstriert, wie Zeichenfolgen gefunden werden, die Standardsuchpfade deklarieren. Es verwendet die Standardbibliotheksfunktion strstr(), die den folgenden Prototyp hat: Char *strstr(const char *str1, const char *str2); Die Funktion strstr() sucht in der Zeichenfolge, auf die str2 zeigt, nach der Zeichenfolge, auf die str1 zeigt. Wenn eine solche Zeichenfolge gefunden wird, wird ein Zeiger auf die erste Position zurückgegeben. Wenn keine Übereinstimmung gefunden wird, gibt die Funktion NULL zurück. /* Das Programm durchsucht die Umgebungsstrings nach einem String, der PATH enthält */ #enthalten
{
if(argc!=2)
{
printf("Sie haben vergessen, Ihren Namen einzugeben\n");
Rückgabe 1;
}
printf("Hallo %s", argv);
0 zurückgeben;
}
Namen Sergej.
Als Ergebnis des Programms erscheint:
Hallo Sergei.
#enthalten
#enthalten
int main(int argc, char *argv)
{
int disp, zählen;
wenn (Arg<2)
{
printf("Sie müssen die Länge der Zählung eingeben\n");
printf("auf der Befehlszeile. Versuchen Sie es erneut.\n");
Rückgabe 1;
}
if (argc==3 && !strcmp(argv,"display")) disp = 1;
sonst disp = 0;
for(count=atoi(argv); count; -count)
if (disp) printf("%d", count);
printf("%c", "\a"); /* Auf den meisten Computern ist dies ein Anruf */
0 zurückgeben;
}
int main(int argc, char *argv)
{
int t, i;
für(t=0; t
ich = 0;
während (argv[t][i])
{
printf("%c", argv[t][i]);
}
printf(");
}
0 zurückgeben;
}
int main(int argc, char *argv)
{
registriere int i;
printf("%d Dateien passen zum angegebenen Namen\n", argc-1);
printf("Sie sind: ");
für(i=1; ich
0 zurückgeben;
}
int main(int argc, char *argv, char *env)
{
int t;
for(t=0; env[t]/ t++)
printf("%s\n", env[t]);
0 zurückgeben;
}
#enthalten
int main (int argc, char *argv, char *env)
{
int t;
for(t=0; env[t]; t++)
{
if(strstr(env[t], "PFAD"))
printf("%s\n", env[t]);
}
0 zurückgeben;
}
Wird geladen...