// C++'s iostream declares stream objects cin, cout, etc.,

// but within the 'std' namespace.  Note that you don't

// need the .h when you're #including headers from the

// C++ standard library, but you do need them when including

// a local header (e.g.: #include "ll.h")

#include <iostream>



// We want to include C's header file stdlib.h to use the EXIT_SUCCESS

// preprocessor symbol.  To include a C standard library header foo.h

// in a C++ program, you use #include <cfoo>

#include <cstdlib>



int main(int argc, char **argv) {

  // "std::cout" means "the symbol 'cout' scoped to the 'std'

  // namespace.  'cout' happens to be an object instance of type

  // 'ostream' whose job is to write to the console.

  //

  // "<<" is an operator.  Objects of type 'ostream' have overloaded

  // this operator, meaning they have defined methods that are invoked

  // whenever an 'ostream' is on the left-hand-side of the "<<"

  // operator.  'ostream' uses C++'s static polymorphism to define

  // multiple methods that handle the "<<" operator; each method

  // takes one argument of a specific type.  So, there is a method

  // that handles the "<<" operator that accepts a C-style string

  // (i.e., a const char *).

  //

  // "Hello, World!" is a C-style string.

  //

  // The expression (std::cout << "Hello, World!") is evaluated

  // first; it invokes the method in the 'std::cout' object of

  // class 'ostream' that overloads the '<<' operator, passing it

  // a pointer to the memory location that contains the C-style

  // string "Hello, World!".  This method writes the string to

  // console, then returns a reference to the "std::cout" argument

  // as its return value.

  //

  // So, that return value will be the left-hand-side of the

  // next expression evaluated, namely (return-val-from-"<<" << endl).

  //

  // "endl" is a 'manipulator' function defined in "std".  This

  // function operates on an ostream to flush the stream and

  // write a newline character.  'std::cout' has a method

  // that is invoked when the '<<' operator is invoked on an ostream

  // and the right-hand-side is a manipulator function pointer.

  std::cout << "Hello, World!" << std::endl;

  return EXIT_SUCCESS;

}