To answer this question, you need to understand the reason why virtual functions exist in the first place.

A virtual function is a mechanism used for polymorphism in the C++ language. The standard is example is the drawing method of a shape class.

class Shape { public virtual void draw(); }
class Rectangle : public Shape {
  public virtual void draw();
}

What is happening here is that the draw method varies between Shape and Rectangle. Therefore, it doesn’t make sense to have only one implementation. You need to have one version of draw for each of the classes Shape and Rectangle.

Whenever you have a situation where classes in the same hierarchy need different implementations, then virtual is the keyword you need to use. With virtual we are free to redefine a member function on a derived class.

On the other hand, member functions that were not defined with the virtual keyword cannot be redefined by derived classes. The reason for that is that, since “virtual” is not used, the compiler doesn’t know about different versions of the member function on the derived classes. Therefore, the compiler will call the wrong version of the member function.

General Techniques

Programmers diverge on the general technique used to say if a method will be virtual or not. Some people believe that you should make all, or at least most of your methods virtual. The idea is that you never know what might be useful to override later, so it is better to leave the options open.

The other group of developers believe that it is better to define only a few member functions as virtual. The reason is that then you will have more control on what the derived classes can do.

The arguments on both sides are good, and as most things in programming, it comes to choosing a side and sticking to it.

Conclusion

Virtual functions are the main mechanism that allows different behavior for classes in the same hierarchy. In this way, we should be careful in defining what virtual functions are virtual and what are not. Understanding the virtual keyword you have better ways to defining correct behavior in your classes.

A work that has taken many years, the new standard that is by now only known as C++0x (where x will be probably 9) will add many features that will change the way we develop software in C++.

Improved Templates

Templates are the feature in C++ that was used to create reusable containers for any object. Thanks to templates we have now a powerful standard library, with  containers (such as vectors, lists, trees, and strings), and algorithms that operate on these containers.

On the new standard, templates will be improved by providing information on the types that can be used to specialize a template. This is a form of type inference that will make templates much more useful (and with better error codes).

Another nice feature is the addition of auto detection of variable types. Since the type system of C++ is very sophisticated, it makes sense to have a feature in the language to allow types to be automatically detected. The language will use the keyword auto to determine that a variable has the same type as the right hand side on an assignment. So, something as

auto a = new MyObject(); 

is sufficient to create a variable of the type MyObject. Notice that we just need to write MyObject once (while nowadays we needed to repeat the type name before the variable name).

Other Features

The new standard has also several provisions that will improve programming in many ways. Examples include new types of constants, improved initialization of objects, among others. I plan to write about some of these features in the future — stay tuned.

Related Articles

• Check my review of a book on the development of large-scale systems in C++.
• A discussion of issues in large scale C++ development.

In large scale C++, John Lakos provides a very thorough discussion of techniques to avoid dependencie problems in large projects. The author skips simple concepts that are commonly treated in other books, such as naming variables and other style issues. Instead, he concentrates in problems that happen only on large-scale systems.

Large-scale C++ was the first book to bring into discussion the issue of header files as a major source of dependencies between C++ modules. Due to the compilation model used in C++, where each file can potentially include hundreds of header files, changing one of these headers can have a large impact on other parts of your program. In fact, in C++ is not uncommon that a single change in a header files requires the recompilation of thousands of files, or even the whole project.

The book also discusses how to create modules that have as few dependencies as possible. This practice increases reuse of the resulting software, since a programmer doesn’t need to include hundreds of header files just to have access to a single functionality.

Large-scale C++ has hundreds of examples, and every concept is accompanied by sample code illustrating the concept. It is a very thorough book, and even though it is long, every page has some interesting idea.

You can check other reviews and information about Large-scale C++ software design in its main web page.