Hello World explained line by line

//
// main.cpp
// HelloWorldExplained
//
// This code walks you through a simple application line-by-line
// and explains exactly what everything does. This file is a source
// code file. It contains code written in the C++ programming language.
// The file will need to be compiled first by a C++ compiler which will
// use the instructions in this file to create a running application.
// C++ source code files usually have the extension .cpp to remind you
// that they contain C++ source code.
//
// These are C++ style line comments.
// They don't have to start at the beginning of a line. But everything
// after the double slashes is a comment intended just for you. Comments
// are not part of your running application. They just help you to better
// understand the code. This code uses comments on almost every line.
// A typical source code file will have far fewer comments.

// The #include preprocessor directive lets you bring other code into
// your program. These are called header files.
// Use <> angle brackets around the name for system header files.
// Most modern C++ header file names have no file extension. Header files
// are also source code. But they're different from .cpp files because
// header files must be included like this in .cpp files to be used.
// You can also include header files inside other header files. But they
// still need to eventually be included by a .cpp file to be used.
// If you write your own header files, then use the .h file extension.
// Then, to include your own header files, use "" double quotation marks
// instead of angle brackets around the file name.
#include <iostream>  // Include iostream to use cout and cin.
#include <string>    // Include string to work with strings.

// Methods allow you to wrap up many programming instructions into a single
// bundle so they all get executed together. Each method can have a return
// value and optionally, a set of parameters. The return value has no name
// but does have a type. An int type is an integer and represents a whole
// number. Parameters allow a method to accept information that can be used
// to do different things. Each parameter has a name and a type.
//
// The main method can have different forms. This one lets you refer to
// command line arguments. It's commented out with another type of
// preprocessor directive because an application can only have a single
// main method and we don't need this one now. This version returns an int
// and has two parameters, argc and argv:
// * The argc parameter is an int that tells you how many command line
//   arguments were used to run the application.
// * The argv parameter is an array of pointers to constant char. In other
//   words, it's a collection of C style strings. The [] square brackets
//   mean the type is an array. An array just means that there can be more
//   than one. The * asterisk is used to define a pointer. In the older C
//   language, strings were just pointers to the first character in the
//   string. The C++ language inherits some things from the C language.
//   And const is used to specify that the strings pointed to by argv
//   cannot be changed. They're constant.
#if 0
int main (int argc, const char * argv[])
{
    // The value returned from main is the exit code of the app. This
    // is normally only used by scripts to tell if an app succeeded or not.
    return 0; // The value 0 traditionally means that everything went okay.
}
#endif // This matches the #if directive and ends the section. The entire
       // section will not be compiled because 0 is false.

// This is the simpler version of main. It returns an int and has no
// parameters inside the () parenthesis. The {} curly braces define the
// beginning and ending of the method body. The main method is where your
// application begins. And your app is done when main returns. The main
// method is a method like any other. The only things special about main
// are that there can be only one and the name must be exactly main. If you
// instead try to call this method Main, then you'll get an error when
// building your application because the main method could not be found.
// The C++ language is case sensitive, so main and Main are different names.
int main ()
{
    // Namespaces let you define code that's isolated from code in
    // different namespaces. The main method was not declared to be in any
    // namespace. So to use code in other namespaces, then the other
    // namespaces must be specified. Or you can do this to declare that
    // you intend to use a namespace. This means that you can use code
    // defined in that namespace without always needing to specify the
    // namespace name every time. For example, this lets you use just
    // cout instead of std::cout. Putting the using statement here inside
    // the main method means that it applies only inside the main method.
    // The std namespace is where you'll find all the classes and code that
    // make up the C++ Standard Library.
    using namespace std;
    
    // Send the string literal "Hello, world!" to the console window.
    // Use cout whenever you want to print text on the computer screen.
    // The \n at the end is an escape sequence that represents a new line.
    // A new line means that any text output or typed next will appear
    // on a new line in the console window. You can use escape sequences
    // for things that don't have visible letters.
    cout << "Hello, world!\n";
    
    // Declare a local string variable called prompt of type std::string.
    // You don't have to specify std:: because of the using statement.
    // Initialize the string with the contents of the string literal in
    // double quotes. Literals like this one and the previous are not
    // variables. They're values typed directly into your program that
    // cannot change while the app is running. A variable like prompt
    // can change its value during runtime. Notice there is no new line
    // this time. That's because you're being prompted to enter something
    // and it looks better for the text to appear next to the prompt.
    string prompt = "Type something: ";
    cout << prompt; // You can send variables to cout too.
    
    // Declare another variable of type string called input. This string
    // has no text yet and is empty. The code will fill it with the first
    // word of text you type on the keyboard and will wait for you to press
    // the enter key before returning.
    string input;
    cin >> input; // This is the line that reads from the keyboard. Notice
                  // how the arrows face the other direction than cout.
                  // You can think of them as pointing in the direction
                  // that information is flowing.
    
    // Now that the app has read what you typed and stored the first word in
    // the variable called input, it's time to send it back to the console.
    // Notice how you can send multiple things at once to the console cout.
    // You can also put escape sequences anywhere in your strings. This
    // example starts off with a new line, then prints a message. Then the
    // first word that was read just now will be sent to the console. And
    // finally, the endl expression is another way to send a new line to the
    // output. The endl expression has a side effect of causing the text sent
    // so far to immediately appear on the console. Send two new lines at the
    // end to give some space between the application output and any text
    // displayed by your system once the app exits.
    cout << "\nThe first word you typed was: " << input << endl << endl;
    
    return 0;
}