Static type checking, sometimes known as static typing, is when the compiler checks the type correctness of operations at compile time. For example, the compiler checks the parameter types of function arguments and checks that a member function invocation is guaranteed to work at runtime, then it flags improper matches as errors at compile time. In object-oriented programs, the most common symptom of a type mismatch is the attempt to invoke a member function via a reference to an object, where the reference's type and/or the object's type does not support the member function. For example, if class X has member function f() but not member function g() and x is an instance of class X, then x.f() is legal and x.g() is illegal. class X { public: void f() throw(); }; void X::f() throw() { } int main() { X x; x.f(); //OK #ifdef GENERATE_ERROR //The following error is caught at compile time //There is no need for runtime checks x.g(); #endif } Fortunately, C++ catches errors like this at compile time. |