#1: "#include <file.h>" does exactly the same thing as opening file.h
and copy-pasting it where the "#include <file.h>" statement is located. No more, no less.
#2: preprocessor directives are the things that start with a "#" hash sign. It can be used for preprocessor macros (you generally want to stay away from those), pragmas to control compiler-specific behavour, the classic #ifdef/#endif, and perhaps the most important, #include.
#3: you use loops when you need a loop?
#4: cin,cout are C++ iostreams, which are a lot more flexible than C-style scanf/printf (they let you write your own output formatters, and a lot more). They also have the potential to be buffer-overflow safe, which scanf/printf don't.
#5: type checking is done all the time by the compiler, to ensure you don't shoot of your leg doing something stupid. C has pretty weak strong type checking, C++ has relatively strong but not over-insane type checking (contrast that to Pascal which has 'char' and 'byte' types that need typecasting >_<). You use typecasting when you need to convert one "unrelated" type to another - this doesn't happen often with decently designed C++ code, but happens a lot if you need to interface with legacy C code. Prime example is using the PlatformSDK for Windows.
#6: dynamic binding/polymorphism... let's say you have a whole class of output streams you can support (to file, to console, to network, to memory...). You design an interface class for this, with all virtual functions. You can't instantiate this interface class directly, but you can instantiate the concrete derived classes (ie, FileStream, NetworkStream, ...), but all code that uses the streams can use the GenericStream class interface. Using dynamic binding, the "generic" calls are bound to the "concrete" calls of the class you're using.
That explanation was probably a bit confusing, but it's pretty simple in practice.
#7: a reference variable is similar to a pointer variable, but they're not equal. One thing is the syntactic sugar: with a pointer, you need to do "*ptr = value" or "ptr->field = value". With a reference, you can simply do "ref = value" or "ref.field = value". Also, references can't be reassigned, and they don't take up any additional memory - the are
the variables they refer to. Think of them as aliases.
#8: namespaces are wonderful
basically, they were created to avoid polluting the global namespace, and having variable/function/class name clashes in large projects, or when using libraries. If two people wrote functions called SuperFormatter(), you'd usually be in trouble, but if they were put in separate namespaces, you aren't.
PS: is this a homework assignment?