Frage Kannst du das Programm "Hallo Welt" erklären?


Ich habe gerade angefangen, C zu lernen, aber ich verstehe diesen Teil des Codes nicht. Kann jemand jede Zeile Code und was es tut erklären. Vielen Dank! Bitte antworte einfach auf das, was ich gesagt habe, anstatt zu sagen (es sollte im Buch stehen) Danke. Ich hoffe, ihr könnt mir helfen.

#include <stdio.h>

void SayHello( void );

int main (int argc, const char * argv[]) {
    SayHello();

    return 0;
}


void SayHello( void ) {
    printf( "Hello, world!\n" );
}

6
2018-06-27 17:30


Ursprung


Antworten:


Ich würde vorschlagen, ein anderes Buch zu bekommen, weil es Ihnen wahrscheinlich schon gesagt haben sollte. Lass uns aber dazu kommen!

#include <stdio.h>

Dieser Teil teilt dem "preproccesor" (Teil des Compilers, der durchgeht und Dinge für die Kompilierung vorbereitet) den Inhalt der Datei "stdio.h" in einem speziellen Teil Ihres Computers und legt ihn auf Ihren Quellcode. Auf diese Weise kann der Compiler die Funktion kennenlernen printf unten, was es für Argumente braucht und welchen Wert es zurückgibt (gibt zurück, nachdem es beendet ist).

void SayHello( void );

Dieser Teil deklariert eine Funktion. Indem Sie die Definition dort aufstellen, können Sie die Funktion aufrufen, bevor Sie ihre Implementierung schreiben. Diese Funktion "header" teilt dem Compiler mit, dass es eine Funktion gibt, die void zurückgibt (d. H. Nichts. Nach dem Ende wird kein Wert zurückgegeben. Zum Beispiel Sie konnte nicht schreiben int a = SayHello();, weil nichts zurückgegeben wird SayHello()). Es braucht auch keine Argumente. Du kannst also nicht schreiben SayHello(34), weil es leere Argumente braucht, also keine.

int main (int argc, const char * argv[]) { 

Dieser Teil ist der Anfang der "Haupt" -Funktion. Das main Funktion ist, wo Ihr Computer aussieht, um das Programm zu starten. Dies ist der Ausgangspunkt. Es braucht zwei Argumente; die Anzahl der Argumente (int argc) auf der Kommandozeile (für jetzt) ​​und ein "Array" von "Strings (char *) ". Ein Array enthält eine Liste der gleichen Art von Daten. So können Sie ein" Array "von char *. Wenn Sie Ihr Programm so starten: ./myProgram fish, argv[1] würde das Array von Zeichen halten (char *) "Fisch". Mach dir keine Sorgen über diesen Teil zu viel, dein Buch wird es später erklären.

SayHello();

Dieser Teil ruft die Funktion auf SayHello(). SayHelloDer Header ist oben, aber das Programm ruft die eigentliche Implementierung der Funktion unten auf. SayHello nimmt keine Argumente und gibt keinen Wert zurück (void). Der Computer springt vorübergehend auf die SayHello Funktion. Wenn es fertig ist, kehrt es zum main Funktion, wo es aufgehört hat. Wir kommen zum eigentlichen SayHello Definition später.

return 0;

Das main Funktion gibt eine ganze Zahl zurück. Wenn alles in Ordnung war, return 0; Das Programm wurde also elegant beendet.

} // end of the function

void SayHello( void ) { // We already covered this part above
      printf( "Hello, world!\n" ); 
}

Dieser Teil ist die eigentliche Funktion, die wir gemacht haben. Sein einziges Ziel ist es zu drucken Hello, world! zur Konsole. Wir erreichen dies, indem wir anrufen Ein weiterer Funktion definiert in der stdio.h Datei, die wir aufgenommen haben. Sein Name ist printf. Es benötigt eine variierende Anzahl von Strings (dies wird viel später in Ihrem Buch behandelt) und druckt auf der Konsole. Ihr Buch wird wahrscheinlich sehr sehr bald printf vollständig abdecken. Für den Moment druckt es nur eine einzelne Zeichenkette (Sie können es mit einem Format wie diesem drucken lassen: printf("My Num is: %d",34); welches ersetzt %d mit 34. Denken Sie jedoch vorerst daran, dass eine Zeichenfolge gedruckt wird. So druckt es "Hallo Welt!" gefolgt von einer Newline (\n). printf gibt ein zurück int; aber es ist nur für Fehlerbehebungszwecke. Nach printf beendet, es kehrt zum zurück SayHello Funktion, die dann endet und zurückkehrt main, die beendet und zurückgibt 0.

Ich hoffe das erklärt alles schön!


39
2018-06-27 17:54



Ich hoffe, der folgende kommentierte Code wird dir helfen:

#include <stdio.h>  // Include the header file named `stdio.h`

void SayHello( void );  // Function named `SayHello` has been declared. It takes no (void) parametres.

int main (int argc, const char * argv[]) {  // `main()` function is part of all C/C++ programs. It accepts command line arguments and returns an exit code. In this case, it returns an integer exit code.
    SayHello();  // Call the function named `SayHello`

    return 0;  // Return from the `main()` function with the code 0 (success).
}

void SayHello( void ) {  // Definition of function `SayHello`.
    printf( "Hello, world!\n" );  // Use the `printf()` function in `stdio.h` header file to print the message.
}

10
2018-06-27 17:42



Was bedeutet jede Zeile?

// Include the Standard Input/Output Header to use its declared functions, ...
#include <stdio.h>

// Declare a function that takes no parameters and doesn't return a value.
void SayHello(void);

// Declare the main function which takes the program's character string
// arguments and returns an integer error code.
int main (int argc, const char * argv[]) {
    // Call the above declared function with no parameters.
    SayHello();

    // Return the error code for OK to tell the OS everything went fine.
    return 0;
}

// Define a function that takes no parameters and doesn't return a value.
void SayHello( void ) {
    // Print a (constant) character string to the console that says Hello, world!
    // and places the cursor on the next line.
    printf( "Hello, world!\n" );
}

Verweise

Wie wird der Code ausgeführt?

  • Jemand startet die Anwendung entweder über die Befehlszeile oder über eine Verknüpfung.
  • Die Hauptfunktion wird aufgerufen und die Parameter der Befehlszeile oder Verknüpfung gegeben.
  • Die Hauptfunktion ruft die SayHello-Prozedur auf.
  • Das SayHello-Verfahren druckt die Zeile Hello, world! und geht zur nächsten Zeile.
  • Zurück in der Hauptprozedur beenden wir die Anwendung, indem wir zurückgeben, dass alles in Ordnung ist.

Wie funktioniert das unter der Haube?

Sie sollten wahrscheinlich an dieser Stelle nicht in dieses Detail schauen, wenn Sie das Gefühl haben, dass Sie bereit sind, ein noch tieferes Verständnis davon zu bekommen, was unter dem Thema geschieht, können Sie den Abschnitt "Der Stapel in Aktion" lesen LearnCPP: Der Stapel und der Haufen.


7
2018-06-27 18:06



#include <stdio.h>

Diese Zeile sagt dem Compiler, dass er die Header-Datei  stdio.h dem Programm Vorwärtsdeklarationen für die Standard - Input / Output - Routinen in der C Standardbibliothek.

void SayHello(void);

Das ist ein Vorwärtsdeklaration oder Funktionsprototyp für eine Funktion. Eine Forward-Deklaration ist eine Möglichkeit, dem Compiler mitzuteilen, dass später eine Funktion definiert wird, aber Sie möchten, dass sie jetzt darüber informiert wird, damit Sie sie verwenden können. Diese spezielle Funktion wird benannt SayHelloakzeptiert keine Parameter und gibt keinen Wert zurück.

int main(int argc, const char *argv[]) {

Diese Zeile zeigt an, dass die Definition einer Funktion namens main. Die Funktion main Hier beginnt die Programmausführung. Diese Funktion akzeptiert zwei Parameter: argc ist vom Typ int und argv ist ein const Anordnung von char *. Die Parameter argc und argv vertreten Kommandozeilenargumente. Der Parameter argc repräsentiert die Anzahl der Befehlszeilenargumente und argv repräsentiert die eigentlichen Befehlszeilenargumente. Der Anfang der Linie, int, gibt diese Funktion an main Gibt einen Wert vom Typ zurück int. Was diese Zeile von der vorherigen unterscheidet, ist, dass sie nicht in einem Semikolon endet (;) und es folgt eine öffnende Klammer ({).

    SayHello();

Diese Codezeile ruft eine Funktion mit dem Namen auf SayHello. Diese Funktion wurde zuvor deklariert, aber nicht definiert.

    return 0;

Diese Codezeile verursacht die main Funktion zum Zurückgeben der int Wert 0. Jeder Anrufer von main wird einen Rückgabewert von erhalten 0.

}

Diese Codezeile teilt dem Compiler mit, dass wir uns am Ende der Definition von. Befinden main.

void SayHello(void) {

Mit dieser Codezeile sagen Sie dem Compiler nun, dass die Definition der Funktion folgt SayHello das wurde früher in der zweiten Zeile versprochen.

    printf("Hello, world!\n");

Diese Codezeile ruft die Standard-Eingabe / Ausgabe-Funktion auf printf das ist ein Teil der C Standardbibliothek. Die Funktion printf bewirkt, dass die Ausgabe auf dem Terminal angezeigt wird; Es ist ein ziemlich flexibles Routing zum Formatieren und Anzeigen von Text auf dem Terminal. Hier übergeben Sie einen Parameter, die Zeichenfolge "Hello, world!\n". Diese Zeichenfolge endet mit einem Escape-Zeichen (\n) das ist übersetzt in a Neue Zeile. Berufung printf mit dem Parameter "Hello, world!\n" wird verursachen

Hello, world!

auf dem Terminal angezeigt werden.

}

Diese Codezeile teilt dem Compiler mit, dass wir uns am Ende der Definition von. Befinden SayHello.

Kurz gesagt, die Codezeilen weisen den Compiler an, die Deklarationen der Methoden in die Standard - Input / Output - Routinen der C - Standardbibliothek aufzunehmen (die Definitionen werden später von der Linker), deklariert eine Funktion namens SayHello, definiert die Funktion main das heißt, wenn das Programm ausgeführt wird und definiert eine Funktion namens SayHello. Die Funktion main ruft die Funktion auf SayHello und gibt das zurück int Wert 0. Die Funktion SayHello verursacht die Linie

Hello, world!

auf dem Terminal angezeigt werden.

Wenn das Programm ausgeführt wird, beginnt die Ausführung in der Funktion main welche die Funktion aufruft SayHello welches auf dem Terminal die Zeichenfolge druckt "Hello, world!" gefolgt von einem Newline und kehrt dann zu main was die zurückgibt int Wert 0 für den Aufrufer.


6
2018-06-27 18:00



Erklärung ...

void SayHello( void );

Diese Linie ist ein Funktionsprototyp. Der Mangel an Code ist beabsichtigt. Es ist eine Möglichkeit für die C-Sprache zu sagen, dass irgendwann später eine Funktion zur Verfügung steht, die dieser Signatur entspricht. C ist ein Top-Down-Compiler, der die Struktur einer Funktion kennen muss, bevor sie sie verwenden kann.

int main (int argc, const char * argv[]) {

Dies ist die Deklaration der Hauptfunktion. Die Befehlszeilenargumente für das Programm sind im Parameter argv enthalten. Der Parameter argc notiert die Anzahl der Argumente, die im Parameter argv enthalten sein werden.

SayHello();

Ruft die Funktion SayHello auf und gibt keine Parameter weiter

return 0;

Beendet das Programm, indem es 0 zurückgibt, was ein Anzeichen dafür ist, dass das Programm erfolgreich war.

void SayHello( void ) {

Dies ist eine Funktionsdefinitionssignatur. Es stellt den Anfang einer benutzerdefinierten Funktion dar.

printf( "Hello, world!\n" );

Dies wird den Text "Hallo, Welt!" gefolgt von einer neuen Zeile auf der Konsole.


3
2018-06-27 17:43



#include <stdio.h>

Fügen Sie die Standard-Input / Output-Bibliothek hinzu.

void SayHello( void );

Definieren Sie eine Funktion mit dem Namen SayHello ohne Rückgabewert und ohne Argumente. Kein Körper ist hier definiert - er wird später definiert.

int main (int argc, const char * argv[]) {

Definieren Sie eine andere Funktion namens main. Es ist der Einstieg in Ihr Programm. Es benötigt 2 Argumente - eine Ganzzahl mit dem Namen argc (die Anzahl der Befehlszeilenargumente) und ein const char * -Array namens argv (die Befehlszeilenargumente). Starte den Körper.

SayHello();

Rufen Sie die zuvor definierte SayHello-Methode auf (führen Sie die Anweisungen aus).

return 0;

Rückgabe 0 (Erfolg) zurück an das Betriebssystem.

}

Beenden Sie den main () -Body.

void SayHello( void ) {

Starten Sie den Body der zuvor definierten SayHello-Funktion.

printf( "Hello, world!\n" );

"Hallo, Welt!" auf den Bildschirm. Die printf-Funktion stammt aus der Standard-Input / Output-Bibliothek, die wir zuvor aufgenommen haben.

}

Beende den SayHello () -Körper.

Die Ausgabe dieses Programms wäre:

Hello, World!

3
2018-06-27 17:48



#include "stdio.h" <- Fügt eine weitere C ++ - Datei aus einem unbekannten Ordner in diese Datei ein. Erfordert, dass das Programm mit einer stdio.lib-Bibliothek verknüpft wird, die normalerweise zur Programmverknüpfung hinzugefügt wird.

MyType SayHello (void); <- Deklaration der Funktion, die MyType-Klasseninstanz zurückgibt und keine Argumente hat

MyType SayHello (); <- das Gleiche

MyType SayHello (0); <- creation MyType-Klasseninstanz mit Integer 0, die an den Klassenkonstruktor übergeben wird.

void SayHello (); <- Deklaration der Funktion, die nichts zurückgibt (ohne Rückgabeanweisungen)

argc / argv <- dumme Abkürzungen für "argument count" und "argument vector"

void SayHello () {...} <- Code kompiliert in Programm-Binärdatei, die von jedem aufgerufen werden kann, der die Deklaration dieser Funktion kennt.

printf ("Hallo, Welt! \ n"); <- Sprung zur Speicheradresse der printf-Funktion mit einem String-Argument.


2
2018-06-27 18:02



Füller, damit die nächste Zeile als Codeblock erkannt wird

#include <stdio.h>

Dies bedeutet, "suchen Sie im Compiler-Suchpfad nach Include-Dateien für die Datei 'stdio.h' und fügen Sie den Inhalt der Dateien hier ein. Beachten Sie, dass dies geschieht, bevor der Compiler es überhaupt sieht.

void SayHello( void );

Dies ist ein Funktionsprototyp. Es heißt im Wesentlichen "es wird eine Funktion definiert, die dieser Signatur entspricht.

int main (int argc, const char * argv[]) {
    SayHello();

Dies ruft die oben erwähnte Funktion auf. Wenn dies erreicht ist, geht die Ausführung in den Körper der Funktion und kehrt zurück, wenn die Funktion endet.

    return 0;

Der Wert 0 wird an das System zurückgegeben (was per Konvention keinen Fehler bedeutet), und das Programm wird beendet.     }

void SayHello( void ) {
    printf( "Hello, world!\n" );

Dies ruft die C-Standardbibliotheksfunktion printf auf und druckt die angegebene Zeichenfolge auf stdout.

}

1
2018-06-27 17:45