Home > Articles > Programming > C/C++

Polymorphism in C++

Programming expert Bartosz Milewski explains the use of polymorphism in a simple example of building an arithmetic tree using various kinds of nodes. This example will be used in a later article in the development of a symbolic calculator.
This article is excerpted from Milewski's book, C++ In Action: Industrial-Strength Programming Techniques (Addison-Wesley, ISBN 0-201-69948-6), a book that teaches professional programming in C++.

Parse Tree

This article demonstrates the use of polymorphism in an example of a very useful data structure—an arithmetic tree. (This example will be used in a later article in the development of a symbolic calculator.) An arithmetic expression can be converted into a tree structure whose nodes are arithmetic operators and leaf nodes are numbers. Figure 1 shows a tree that corresponds to the expression 2 * (3 + 4) + 5. Analyzing it from the root toward the leaves, we first encounter the plus node, whose children are the two terms that are to be added. The left child is a product of two factors. The left factor is the number 2 and the right factor is the sum of 3 and 4. The right child of the top-level plus node is the number 5. Notice that the tree representation doesn't require any parentheses or the knowledge of operator precedence. It uniquely describes the calculation to be performed.

Figure 1 The arithmetic tree corresponding to the expression 2 * (3 + 4) + 5.

We will represent all nodes of the arithmetic tree as objects inheriting from the class Node. The direct descendants of Node are NumNode, which represents a number, and BinNode, which represents a binary operator. For simplicity, let's restrict ourselves to only two classes derived from BinNode: AddNode and MultNode. Figure 2 shows the class hierarchy I have just described. Abstract classes are classes that cannot be instantiated; they only serve as parents for other classes. I'll explain this term in more detail in a moment.

Figure 2 The class hierarchy of nodes.

What are the operations we would like to perform on a node? We want to be able to calculate its value and, at some point, destroy it. The Calc method returns a double as the result of calculating the node's value. Of course, for some nodes the calculation may involve the recursive calculations of its children. This method is const because it doesn't change the node itself. Since each type of node has to provide its own implementation of the Calc method, we make this function virtual. However, there is no "default" implementation of Calc for an arbitrary Node. A function that has no implementation (inherited or otherwise) is called a pure virtual function. That's the meaning of = 0 in the declaration of Calc:

class Node
  virtual ~Node () {}
  virtual double Calc () const = 0;

A class that has one or more pure virtual functions is called an abstract class, and it cannot be instantiated (no object of this class can be created). Only classes that are derived from it, and that provide their own implementations of all the pure virtual functions, can be instantiated. Notice that our sample arithmetic tree has instances of AddNodes, MultNodes, and NumNodes, but no instances of Nodes or BinNodes.

A common rule is that if a class has a virtual function, it probably needs a virtual destructor as well—and once we decide to pay the overhead of a vtable pointer, subsequent virtual functions will not increase the size of the object. So, in such a case, adding a virtual destructor doesn't add any significant overhead.

In our case, we can anticipate that some of the descendant nodes will have to destroy their children in their destructors, so we really need a virtual destructor. A destructor can be made into a pure virtual function, but we would have to override it in every derived class, whether it needs it or not. That's why I gave it an empty body. (Even though I made it inline, the compiler will create a function body for it, because it needs to stick a pointer for it into the virtual table.)

NumNode stores a double value that is initialized in its constructor (see Listing 1). NumNode also overrides the Calc virtual function. In this case, Calc simply returns the value stored in the node.

Listing 1 Class NumNode (Numeric Node)

class NumNode: public Node
  NumNode (double num) : _num (num ) {}
  double Calc () const;
  const double _num;

double NumNode::Calc () const
  std::cout << "Numeric node " << _num << std::endl;
  return _num;

BinNode has two children that are pointers to (abstract) Nodes. They are initialized in the constructor and deleted in the destructor—this is why I could make them const pointers (see Listing 2). The Calc method is still a pure virtual function, inherited from Node; only the descendants of BinNode will know how to implement it.

Listing 2 Class BinNode (Binary Node)

class BinNode: public Node
  BinNode (Node * pLeft, Node * pRight)
   : _pLeft (pLeft), _pRight (pRight) {}
  ~BinNode ();
  Node * const _pLeft;
  Node * const _pRight;

BinNode::~BinNode ()
  delete _pLeft;
  delete _pRight;

This is where you first see the advantage of polymorphism. A binary node can have children that are arbitrary nodes. Each of them can be a number node, an addition node, or a multiplication node. There are nine possible combinations of children—it would be silly to make separate classes for each of them—consider this, for instance:


We have no choice but to accept and store pointers to children as more general pointers to Nodes. Yet, when we call destructors through them, we need to call different functions to destroy different Nodes. For instance, AddNode has a different destructor than NumNode (which has an empty one), and so on. This is why we have to make the destructors of Nodes virtual.

Notice that the two data members of BinNode are not private—they are protected. This qualification is slightly weaker than private. A private data member or method cannot be accessed from any code outside the implementation of the given class (or its friends)—not even from the code of the derived class. If we made _pLeft and _pRight private, we'd have to provide public methods to set and get them. That would be tantamount to exposing them to everybody. By making them protected, we let classes derived from BinNode manipulate them, but, at the same time, bar anybody else from doing so. Table 1 presents a short description of all three access specifiers. Incidentally, the same access specifiers are used in declaring inheritance. By far the most useful type of inheritance is public, and that's what we've been using so far, but if you'd like to restrict the access to the base class, you're free to use the other two types of inheritance

Table 1 The Meaning of the Three Access Specifiers

Access Specifier

Who Can Access the Members?




The class itself, its friends, and derived classes


Only the class itself and its friends

The class AddNode is derived from BinNode:

class AddNode: public BinNode
  AddNode (Node * pLeft, Node * pRight)
   : BinNode (pLeft, pRight) {}
  double Calc () const;

AddNode provides its own implementation of Calc. This is where you see the advantages of polymorphism again. We let the child nodes calculate themselves. Since the Calc method is virtual, they will do the right thing based on their actual class, and not on the class of the pointer (Node *). The two results of calling Calc are added and the sum returned.

double AddNode::Calc () const
  std::cout << "Adding\n";
  return _pLeft->Calc () + _pRight->Calc ();

Notice how the method of AddNode directly accesses its parent's protected data members _pLeft and _pRight. Again, were they declared private, such access would be flagged as an error by the compiler.

For completeness, Listing 3 shows the implementation of MultNode and a simple test program.

Listing 3 Class MultNode (Multiplication Node) and a Simple Test Program

class MultNode: public BinNode
  MultNode (Node * pLeft, Node * pRight)
   : BinNode (pLeft, pRight) {}
  double Calc () const;

double MultNode::Calc () const
  std::cout << "Multiplying\n";
  return _pLeft->Calc () * _pRight->Calc ();

int main ()
  // ( 20.0 + (-10.0) ) * 0.1
  Node * pNode1 = new NumNode (20.0);
  Node * pNode2 = new NumNode (-10.0);
  Node * pNode3 = new AddNode (pNode1, pNode2);
  Node * pNode4 = new NumNode (0.1);
  Node * pNode5 = new MultNode (pNode3, pNode4);
  std::cout << "Calculating the tree\n";
  // tell the root to calculate itself
  double x = pNode5->Calc ();
  std::cout << "Result: " << x << std::endl;
  delete pNode5; // and all children

Do you think you can write more efficient code by not using polymorphism? Think twice! If you're still not convinced, go on a little side trip into the alternative universe of C.

InformIT Promotional Mailings & Special Offers

I would like to receive exclusive offers and hear about products from InformIT and its family of brands. I can unsubscribe at any time.


Pearson Education, Inc., 221 River Street, Hoboken, New Jersey 07030, (Pearson) presents this site to provide information about products and services that can be purchased through this site.

This privacy notice provides an overview of our commitment to privacy and describes how we collect, protect, use and share personal information collected through this site. Please note that other Pearson websites and online products and services have their own separate privacy policies.

Collection and Use of Information

To conduct business and deliver products and services, Pearson collects and uses personal information in several ways in connection with this site, including:

Questions and Inquiries

For inquiries and questions, we collect the inquiry or question, together with name, contact details (email address, phone number and mailing address) and any other additional information voluntarily submitted to us through a Contact Us form or an email. We use this information to address the inquiry and respond to the question.

Online Store

For orders and purchases placed through our online store on this site, we collect order details, name, institution name and address (if applicable), email address, phone number, shipping and billing addresses, credit/debit card information, shipping options and any instructions. We use this information to complete transactions, fulfill orders, communicate with individuals placing orders or visiting the online store, and for related purposes.


Pearson may offer opportunities to provide feedback or participate in surveys, including surveys evaluating Pearson products, services or sites. Participation is voluntary. Pearson collects information requested in the survey questions and uses the information to evaluate, support, maintain and improve products, services or sites, develop new products and services, conduct educational research and for other purposes specified in the survey.

Contests and Drawings

Occasionally, we may sponsor a contest or drawing. Participation is optional. Pearson collects name, contact information and other information specified on the entry form for the contest or drawing to conduct the contest or drawing. Pearson may collect additional personal information from the winners of a contest or drawing in order to award the prize and for tax reporting purposes, as required by law.


If you have elected to receive email newsletters or promotional mailings and special offers but want to unsubscribe, simply email information@informit.com.

Service Announcements

On rare occasions it is necessary to send out a strictly service related announcement. For instance, if our service is temporarily suspended for maintenance we might send users an email. Generally, users may not opt-out of these communications, though they can deactivate their account information. However, these communications are not promotional in nature.

Customer Service

We communicate with users on a regular basis to provide requested services and in regard to issues relating to their account we reply via email or phone in accordance with the users' wishes when a user submits their information through our Contact Us form.

Other Collection and Use of Information

Application and System Logs

Pearson automatically collects log data to help ensure the delivery, availability and security of this site. Log data may include technical information about how a user or visitor connected to this site, such as browser type, type of computer/device, operating system, internet service provider and IP address. We use this information for support purposes and to monitor the health of the site, identify problems, improve service, detect unauthorized access and fraudulent activity, prevent and respond to security incidents and appropriately scale computing resources.

Web Analytics

Pearson may use third party web trend analytical services, including Google Analytics, to collect visitor information, such as IP addresses, browser types, referring pages, pages visited and time spent on a particular site. While these analytical services collect and report information on an anonymous basis, they may use cookies to gather web trend information. The information gathered may enable Pearson (but not the third party web trend services) to link information with application and system log data. Pearson uses this information for system administration and to identify problems, improve service, detect unauthorized access and fraudulent activity, prevent and respond to security incidents, appropriately scale computing resources and otherwise support and deliver this site and its services.

Cookies and Related Technologies

This site uses cookies and similar technologies to personalize content, measure traffic patterns, control security, track use and access of information on this site, and provide interest-based messages and advertising. Users can manage and block the use of cookies through their browser. Disabling or blocking certain cookies may limit the functionality of this site.

Do Not Track

This site currently does not respond to Do Not Track signals.


Pearson uses appropriate physical, administrative and technical security measures to protect personal information from unauthorized access, use and disclosure.


This site is not directed to children under the age of 13.


Pearson may send or direct marketing communications to users, provided that

  • Pearson will not use personal information collected or processed as a K-12 school service provider for the purpose of directed or targeted advertising.
  • Such marketing is consistent with applicable law and Pearson's legal obligations.
  • Pearson will not knowingly direct or send marketing communications to an individual who has expressed a preference not to receive marketing.
  • Where required by applicable law, express or implied consent to marketing exists and has not been withdrawn.

Pearson may provide personal information to a third party service provider on a restricted basis to provide marketing solely on behalf of Pearson or an affiliate or customer for whom Pearson is a service provider. Marketing preferences may be changed at any time.

Correcting/Updating Personal Information

If a user's personally identifiable information changes (such as your postal address or email address), we provide a way to correct or update that user's personal data provided to us. This can be done on the Account page. If a user no longer desires our service and desires to delete his or her account, please contact us at customer-service@informit.com and we will process the deletion of a user's account.


Users can always make an informed choice as to whether they should proceed with certain services offered by InformIT. If you choose to remove yourself from our mailing list(s) simply visit the following page and uncheck any communication you no longer want to receive: www.informit.com/u.aspx.

Sale of Personal Information

Pearson does not rent or sell personal information in exchange for any payment of money.

While Pearson does not sell personal information, as defined in Nevada law, Nevada residents may email a request for no sale of their personal information to NevadaDesignatedRequest@pearson.com.

Supplemental Privacy Statement for California Residents

California residents should read our Supplemental privacy statement for California residents in conjunction with this Privacy Notice. The Supplemental privacy statement for California residents explains Pearson's commitment to comply with California law and applies to personal information of California residents collected in connection with this site and the Services.

Sharing and Disclosure

Pearson may disclose personal information, as follows:

  • As required by law.
  • With the consent of the individual (or their parent, if the individual is a minor)
  • In response to a subpoena, court order or legal process, to the extent permitted or required by law
  • To protect the security and safety of individuals, data, assets and systems, consistent with applicable law
  • In connection the sale, joint venture or other transfer of some or all of its company or assets, subject to the provisions of this Privacy Notice
  • To investigate or address actual or suspected fraud or other illegal activities
  • To exercise its legal rights, including enforcement of the Terms of Use for this site or another contract
  • To affiliated Pearson companies and other companies and organizations who perform work for Pearson and are obligated to protect the privacy of personal information consistent with this Privacy Notice
  • To a school, organization, company or government agency, where Pearson collects or processes the personal information in a school setting or on behalf of such organization, company or government agency.


This web site contains links to other sites. Please be aware that we are not responsible for the privacy practices of such other sites. We encourage our users to be aware when they leave our site and to read the privacy statements of each and every web site that collects Personal Information. This privacy statement applies solely to information collected by this web site.

Requests and Contact

Please contact us about this Privacy Notice or if you have any requests or questions relating to the privacy of your personal information.

Changes to this Privacy Notice

We may revise this Privacy Notice through an updated posting. We will identify the effective date of the revision in the posting. Often, updates are made to provide greater clarity or to comply with changes in regulatory requirements. If the updates involve material changes to the collection, protection, use or disclosure of Personal Information, Pearson will provide notice of the change through a conspicuous notice on this site or other appropriate way. Continued use of the site after the effective date of a posted revision evidences acceptance. Please contact us if you have questions or concerns about the Privacy Notice or any objection to any revisions.

Last Update: November 17, 2020