- argc, eine Ganzzahl, ist die Anzahl der an die Hauptfunktion gesendeten Befehlszeilenargumente, - argv ist ein Array von Zeigern auf Zeichenfolgen (char *).

Ich behandle C-Funktionen immer so, als ob sie die Anzahl der Argumente unabhängig vom Kontext festlegen würden, es sei denn, sie verwenden va_args. Das heißt, ich glaube, dass sie IMMER einen Prototyp haben:

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

Auch wenn keine Argumente übergeben werden, hat die Funktion diese Argumente auf dem Stapel, da die Hauptfunktion keine Funktionsüberladung aufweist.

C hat die Fähigkeit, eine primitive Überladung durchzuführen, indem es einfach so tut, als ob das Argument fehlt. In diesem Fall wird das Argument weiterhin übergeben und befindet sich auf dem Stapel, Sie greifen jedoch nie darauf zu, wodurch sich lediglich die Größe des Quellcodes verringert.

Int main() zu sagen bedeutet einfach, dass ich weiß, dass die Funktion Parameter haben kann, ich sie aber nicht verwende, also schreibe ich int main().

Die Anweisung int main (void) besagt, dass main SCENELY keine Argumente hat und impliziert, dass es zwei verschiedene Funktionsprototypen gibt:

Int main(void); int main(int argc, char **argv);

Da C keine Überladungsfunktion hat, ist dies für mich etwas irreführend und ich vertraue Code mit einer Lücke darin nicht. Ich würde es nicht tun, es sei denn, main akzeptiert NIEMALS irgendwelche Parameter. In diesem Fall wäre main(void) völlig in Ordnung.

NOTIZ. Einige Implementierungen haben in der Hauptsache mehr Parameter als argc und argv wie env, aber das stört mich nicht, weil ich weiß, dass ich nicht direkt sage, dass dies nur zwei Parameter sind, sondern dass dies die Mindestparameter sind und alles in Ordnung ist mehr, aber nicht weniger. Dies widerspricht der direkten Aussage von int main(void), die mich anschreit, als ob DIESE FUNKTION KEINE PARAMETER HAT, was nicht wahr ist, da sie einfach weggelassen werden.

Hier ist mein Basiscode:

/* sample.c – in Beispiel einbauen. */ #enthalten int main(void) ( int _argc = *((int *)2686800); char ***_pargv = (char ***)2686804; int i; for (i = 1; i< _argc; ++i) { printf("%s ", (*_pargv)[i]); } return 0; }

./sample Ich habe eindeutig Argumente

Der Funktion werden eindeutig Argumente übergeben, auch wenn nicht explizit angegeben wird, dass sie nicht „void“ in den Funktionsprototyp eingibt.

Wie oben erwähnt:

(6.7.6.3p10) Ein Sonderfall eines unbenannten Parameters vom Typ void, sobald ein Element in der Liste angibt, dass die Funktion keine Parameter hat.

Zu sagen, dass eine Funktion void als Argument hat, tatsächlich aber Argumente auf dem Stapel hat, ist ein Widerspruch.

Mein Punkt ist, dass die Argumente immer noch existieren. Daher ist es unehrlich, explizit zu sagen, dass „main“ keine Argumente enthält. Ein fairer Weg wäre, int main() zu sagen, das nichts darüber aussagt, wie viele Parameter es hat, sondern nur, wie viele Parameter Sie benötigen.

HINWEIS2: _argc, _pargv sind systemabhängig. Um Ihre Werte zu finden, sollten Sie dieses Programm ausführen:

/* findargs.c */ #include int main(int argc, char **argv) ( printf("Adresse von argc ist %u.\n", &argc); printf("Adresse von argv ist %u.\n", &argv); return 0; )

Diese Werte sollten für Ihr spezifisches System korrekt bleiben.

Borland C++ unterstützt drei Argumente für main(). Die ersten beiden sind das traditionelle argc und argv. Dies sind die einzigen im ANSI-C-Standard definierten Argumente für main(). Sie ermöglichen die Übergabe von Befehlszeilenargumenten an das Programm. Befehlszeilenargumente sind die Informationen, die dem Programmnamen in der Befehlszeile des Betriebssystems folgen. Wenn ein Programm beispielsweise mit dem Borland-Zeilencompiler kompiliert wird, wird es normalerweise als bcc eingegeben Programmname

Wo Programmname ist ein Programm, das kompiliert werden muss. Der Programmname wird als Argument an den Compiler übergeben.

Der Parameter argc enthält die Anzahl der Befehlszeilenargumente und ist eine Ganzzahl. Es ist immer mindestens 1, da der Programmname als erstes Argument gilt. Der argv-Parameter 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 das interne Format umgewandelt. Das folgende Programm gibt „Hallo“ gefolgt vom Benutzernamen aus, wenn es direkt nach dem Programmnamen eingegeben wird:

#enthalten

{
if(argc!=2)
{
printf("Sie haben vergessen, Ihren Namen einzugeben\n");
Rückgabe 1;
}
printf("Hallo %s", argv);
0 zurückgeben;
}

Wenn Sie diesen Programmnamen nennen und der Benutzername Sergey ist, müssen Sie zum Starten des Programms Folgendes eingeben:
Name Sergey.
Als Ergebnis des Programms erscheint Folgendes:
„Hallo Sergey.“

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

Herb, Rick, Fred

Dies ist eine Zeile – Kommas sind keine Trennzeichen.

Wenn Sie eine Zeichenfolge mit Leerzeichen oder Tabulatoren als einzelnes Argument übergeben müssen, müssen Sie diese in doppelte Anführungszeichen setzen. Dies ist zum Beispiel ein Argument:

„Das ist ein Test“

Es ist wichtig, argv korrekt zu deklarieren. Die typischste Methode ist:

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

Nachfolgend finden Sie ein kleines Beispiel für die Verwendung von Befehlszeilenargumenten. Er zählt von dem in der Befehlszeile angegebenen Wert herunter und gibt ein Signal aus, wenn er Null erreicht. 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
#enthalten
#enthalten
int main(int argc, char *argv)
{
int disp, count;
if(argc<2)
{
printf("Sie müssen die Länge der Zählung eingeben\n");
printf("in 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;
}

Bitte beachten Sie, dass eine Fehlermeldung erscheint, 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, mit denen es aufgerufen wurde, zeichenweise aus:

#enthalten
int main(int argc, char *argv)
{
int t, i;
for(t=0; t {
ich = 0;
while(argv[t][i])
{
printf("%c", argv[t][i]);
}
printf(" ");
}
0 zurückgeben;
}

Wir müssen bedenken, dass der erste Index für den Zugriff auf eine Zeichenfolge und der zweite für den Zugriff auf ein Zeichen in einer Zeichenfolge dient.

Normalerweise werden argc und argv verwendet, um Quellbefehle abzurufen. Theoretisch ist es möglich, bis zu 32767 Argumente zu haben, aber die meisten Betriebssysteme erlauben nicht einmal annähernd diese Zahl. 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 einbinden, können Sie Vorlagen in Argumenten vom Typ *.EXE verwenden. (Borland C++ verarbeitet Platzhalter automatisch und erhöht argc entsprechend.) Wenn Sie beispielsweise WILDARGS.OBJ mit dem folgenden Programm verbinden, erfahren Sie, wie viele Dateien mit dem in der Befehlszeile angegebenen Dateinamen übereinstimmen:

/* Dieses Programm mit WILDARGS.OBJ verknüpfen */

#enthalten
int main(int argc, char *argv)
{
registrieren int i;
printf("%d Dateien stimmen mit dem angegebenen Namen überein\n", argc-1);
printf("Sie sind: ");
for(i=1; i printf("%s", argv[i]);
0 zurückgeben;
}

Wenn wir dieses Programm WA nennen und es dann 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++ auch ein drittes Befehlszeilenargument –env. Der env-Parameter ermöglicht einem 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 auf die gleiche Weise wie argv deklariert. Genau wie argv ist es ein Zeiger auf ein Array von Strings. Jede Zeile ist eine vom Betriebssystem definierte Umgebungszeichenfolge. Der env-Parameter hat keinen entsprechenden argc-Parameter, der angibt, wie viele Umgebungszeilen vorhanden sind. Stattdessen ist die letzte Zeile der Umgebung null. Das folgende Programm druckt alle derzeit im Betriebssystem definierten Umgebungszeichenfolgen:

/* Dieses Programm zeigt alle Umgebungszeilen an */

#enthalten
int main(int argc, char *argv, char *env)
{
int;
for(t=0; env[t]/ t++)
printf("%s\n", env[t]);
0 zurückgeben;
}

Bitte 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 verstehen kann, dass es sich um Argumente für die Funktion main() handelt.

Eine typische Aufgabe für Programme besteht darin, einen in einer Umgebungszeichenfolge definierten Wert nachzuschlagen. Beispielsweise ermöglicht der Inhalt der PATH-Zeile Programmen die Verwendung von Suchpfaden. Das folgende Programm zeigt, wie Sie Zeichenfolgen finden, 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. Wird ein solcher String gefunden, wird ein Zeiger auf die erste Position zurückgegeben. Wenn keine Übereinstimmungen gefunden werden, gibt die Funktion NULL zurück.

/* Das Programm sucht in den Umgebungszeichenfolgen nach einer Zeile mit PATH */

#enthalten
#enthalten
int main (int argc, char *argv, char *env)
{
int;
for(t=0; env[t]; t++)
{
if(strstr(env[t], "PATH"))
printf("%s\n", env[t]);
}
0 zurückgeben;
}