trivia.mpb trivia.mpc trivia.mwc, contain the build information for any of the multi module programs.
map_bad_access.cpp illustrates what happens when you call the [] on a map, when it doesn't have a value at that key
Anon.cpp This program demonstrates how to "hijack" a member of the anonymous namespace.
AnonData.cpp AnonObj.cpp together make a program which demonstrates that an anonymous member in one object module, is invisible to other modules.
CallVirtual.cpp This program deomstrates that virtual functions can be called from a constructor. I am not sure if this is behavior is defined by the standard.
CommuteIndex.cpp This program demonstrates that I[A] = *(I+A) = A[I], where I is an integer type, and A has a [] operator.
Constructor.cpp This program demonstrates that constructors for objects with complicated inheritance, are called left to right, depth first.
CovariantReturn.cpp This program demonstrates that virtual functions can be overriden with a function of the same signature and a covariant return type. A type is covariant with another type, if it is the same, or is derived from the previous type.
Enum.cpp This program demonstrates that it is possible to have an array of enum's.
Extern.cpp This program demonstrates that you can use the extern qualifier, and define a variable at the same time.
MemberPointer.cpp This function demonstates the syntax for declaring, initializing, and dereferencing a class member pointer. It demonstrates that class member pointers, can point at member functions and member data. It also shows that member pointers, can't point at static members.
NameSpaceRes.cpp This function demonstrates that an ambiguity from an overloaded function in different namespaces causes a compiler error.
NameConflict.cpp This function shows that it is possible to define a variable, inside of the () of an if statement, which is in scope inside the {} of the if statement, and which overrides any variable declaration of the same name.
Order.cpp This program demonstrates that variables inside of a class, are created and initialized in the order in which they are declared in the function class. This order is independent of the order in the constructor initialization list.
VirtualOrder.cpp This program demonstrates that if there are multiple ways of initializing an inherited virtual base, the path from the most derived class, to the virtual base is used.
OrderOfCalls.cpp This program demonstrates that classes are constructed from the inside out, and destroyed from the outside inward.
OrderVtable.cpp This program demonstrates that a class with multiple inheritance is initialized from left to right, depth first. It also demonstrats that if you call a virtual function for an objects which hasn't been initialized, that undefined (bad!) things happen.
OverRide.cpp This program demonstrates that when you override a virtual function, the signature must be the same. It also demonstrates that int and long, create different signatures, even if they map to the same integer type at the machine level.
FpointerTemplate.cpp a template which takes a function pointer as a parameter.
Functor.cpp a program which illustrates the idea of "functors" which are functions which include a "state".
FunctorTemplate.cpp a template which takes a functor as a parameter.
pointer to function template -- check Stroustrup for this
pointer to overloaded function
pointer to const definition
pointer to function return type
pointer to function argument
PrivInherit.cpp This demonstrates that in private inheritance, non of the members are public. It also demonstrates that it is illegal to upcast to a private base, unless you "force it" with an explicit C style conversion or a call to reinterpret_cast. All of the other cast operatores fail to compile.
ProtInherit.cpp This demonstrates that upcasting will work with protected inheritance.
RefTemp.cpp This demonstrates a const reference to a temporary object. It also shows how a closely related syntax won't compile.
RefQuestion.cpp This demonstrates that a reference can be inialized using the ? operator.
Scope.cpp This demonstrates that a local variable in a member function can conflict and block a member variable.
Singleton.cpp This shows how a class can be limited to a single instance by making the creator non-public (private or protected). The access to the class is granted by a static function, which in this case returns a pointer.
StrangeAcess.cpp This shows that it is possible for a variable to be "volatile const" or "const volatile". It also shows that a const_cast, can ignore these attributes. Typically this sort of variable would be used to represent a data item, which can't be changed by the program, but which can be changed externally by the hardware.
StrangePrintf.cpp This shows how to change the fill and the width of integer types.
SwitchContinue.cpp This shows that it is legal to include a continue statement inside of a switch statement.
Undefined.cpp This shows that you should not ever treat arrays polymorphicaly because the parent class my have a different size than the child class, and this confuses operator placement delete.
add.cpp This shows decimal, hex and octal notation used in a single math statement.
canonical.txt This is a description of the "canonical class". This class contains a copy constructor, an assignment operator and a virtual destructor.
cppnotes.txt These are random musings about c++.
strange4.cpp These two functions are identical in their behavior. They demonstrate that without brackets, an else statement is associated with the previous closest if statement.
