Inheritance.

Inheritance

Chapter Goals To understand the concepts of inheritance and polymorphism To learn how to inherit and override member functions To be able to implement constructors for derived classes To be able to design and use virtual functions

Inheritance Hierarchies

Shovels, rakes, and clippers all perform gardening tasks. They can be considered as specialized versions of the general ‘gardening tool’ type.

In object-oriented design, inheritance is a relationship between a more general class (called the base class) and a more specialized class (called the derived class). The derived class inherits data and behavior from the base class.

Inheritance IS-A

Inheritance: The IS-A Relationship
All cars are vehicles. (This is correct and good English.)

All cars IS-A vehicles. (Correct and … um … English?)

You may recall the UML notation HAS-A for containment. IS-A denotes inheritance.

All cars IS-A vehicles. (Correct… …when speaking object ively)

Vehicles is the base class. Car is a derived class. Truck derives from Vehicle.

SUV derives from Car, which derives from Vehicle.

Truck IS-A Vehicle. SUV IS-A Car.

Everything about being a Vehicle is inherited by Cars and Trucks and SUVs.

Those things specific to Cars are only inherited by Sedans and SUVs.

I inherited my ROYALNESS from my parents who inherited it from their parents.

I’m a special version of my base class. I’m very special.

The Substitution Principle
Suppose we have an algorithm that manipulates a Vehicle object. Since a car IS-A vehicle, we can supply a Car object to such an algorithm, and it will work correctly. C++ for Everyone by Cay Horstmann Copyright © 2012 by John Wiley & Sons. All rights reserved

The substitution principle states that you can always use a derived-class object when a base-class object is expected.

Did you know you have already been working with class hierarchies? (No! Really?)

Remember your friends cin and cout? (Yes.) Their types are in an inheritance chain. (Chains? Like prisoners?)

No, silly. That’s just another phrase for inheritance hierarchy.

Look: void process_input(istream& in); You can call this function with an ifstream object or with an istream object. Why?

Because istream is more general than ifstream. void process_input(istream& in); This works by inheritance:

The C++ Stream Hierarchy
istream is the base class of ifstream. ifstream inherits from istream.

Quiz Time OK. QUIZ TIME!

Everyone likes taking quizzes.
Quiz Time OK. QUIZ TIME! Everyone likes taking quizzes. So let’s take one. (Oh no!)

You don’t like taking quizzes?
Quiz Time You don’t like taking quizzes? (Not really …) OK Let’s create a Quiz Question hierarchy. (Whew!)

Design Phase of Question Program
We will try to make this as general as we can because often quizzes consist of different kinds of questions: (We like multiple guess questions.) Fill-in-the-blank Choice (single or multiple) Numeric (we’ll allow approximate answers to be OK) Free response

Design Phase of Question Program
Here is the UML diagram that resulted from our analysis:

The Base Class: Question
At the root of this hierarchy is the Question type.

We want a object of Question type to work like this: First, the programmer sets the question text and the correct answer in the Question object. C++ for Everyone by Cay Horstmann opyright © 2012 by John Wiley & Sons. All rights reserved

Then, when it’s time to run the testing program with a user taking the test, the programmer asks the Question to display the text of the question: Who was the inventor of C++? The Question object displays this

That programmer then gets the use’s response and passes it to the Question object for evaluation: Who was the inventor of C++? Your answer: Bjarne Stroustrup true The Question object displays this

The Base Class: Question – Member Variables
To work as shown, a Question object would contain: The question’s text string text; The correct answer string answer;

The Base Class: Question – Constructor
string text; string answer; What initial values should these have? What could possibly be a reasonable initial value? And – we’ll write mutators to allow setting them later. So a default Question constructor that does nothing is fine. The string class constructor gives us empty strings.

The Base Class: Question – Accessors
A Question object should be able to: Display its text void display() const; Check whether a given response is a correct answer bool check_answer(string response) const;

The Base Class: Question – Mutators
And have these mutators: Set the question’s text void set_text(string question_text); Set the correct answer void set_answer(string correct_response);

The Base Class: Question –
{ public: Question(); void set_text(string question_text); void set_answer(string correct_response); bool check_answer(string response) const; void display() const; private: string text; string answer; };

Question Class Test Program
Here’s a complete program to test our Question class. #include <iostream> #include <sstream> #include <string> using namespace std; class Question { public: /** Constructs a question with empty text and answer. */ Question();

/** @param question_text the text of this question */ void set_text(string question_text); @param correct_response the answer to this question void set_answer(string correct_response); @param response the response to check @return true if the response was correct,false otherwise bool check_answer(string response) const;

/** Displays this question. */ void display() const; private: string text; string answer; }; Question::Question() { }: void Question::set_text(string question_text) text = question_text; }

void Question::set_answer(string correct_response) { answer = correct_response; } bool Question::check_answer(string response) const return response == answer; void Question::display() const cout << text << endl;

int main() { string response; // Show Boolean values as true, false cout << boolalpha; Question q1; q1.set_text("Who was the inventor of C++?"); q1.set_answer("Bjarne Stroustrup"); q1.display(); cout << "Your answer: "; getline(cin, response); cout << q1.check_answer(response) << endl; return 0; }

boolalpha Did you notice this in the code?
// Show Boolean values as true, false cout << boolalpha; The boolalpha manipulator causes Boolean values to be displayed as the output strings: "true" for true and "false" for false – otherwise, numbers would be displayed.

Implementing Derived Classes
Now for those different kinds of questions. All of the different kinds IS-A Question so we code by starting with the base class (Question) and then we write code for what makes them special versions of more general Question type.

I know about being special.

Through inheritance, each of these types will have the data members and member functions set up in class Question. – plus “specialness-es” (We don’t rewrite the member functions) (code reuse in action – all right!)

That’s me!

We will start with the “choice question” kind of question: class ChoiceQuestion : public Question { public: // New and changed member // functions will go here private: // Additional data members // will go here };

I’m his parent: the base class Implementing Derived Classes The : symbol denotes inheritance. I’m a derived class class ChoiceQuestion : public Question { public: // New and changed member // functions will go here private: // Additional data members // will go here };

The keyword public makes sure this is an IS-A relationship. class ChoiceQuestion : public Question { public: // New and changed member // functions will go here private: // Additional data members // will go here }; ChoiceQuestion IS-A Question

We are telling the compiler to start with the Question class and add these things to it. class ChoiceQuestion : public Question { public: // New and changed member // functions will go here private: // Additional data members // will go here };

Implementing Derived Classes – Analysis of the Problem
So what are these new things? How does a ChoiceQuestion differ from its base class? It’s use in the interaction with a user will be different:

After a programmer has set the question text and the several multiple choice answers the ChoiceQuestion object is asked to display: In which country was the inventor of C++ born? 1: Australia 2: Denmark 3: Korea 4: United States The Question object displays all this

The programmer then gets the user’s input, and sends it to the ChoiceQuestion object to see if it is correct. In which country was the inventor of C++ born? 1: Australia 2: Denmark 3: Korea 4: United States Your answer: 2 true The Question object displays this

Implementing Derived Classes – Coding
The code will have to make ChoiceQuestion be a specialized form of a Question object.

ChoiceQuestion must have: Storage for the various choices for the answer Question has the text and correct answer, not these A member function for adding another choice A display function The designer of the Question class could not have known how to display this sort of multiple choice question. It only has the question itself, not the choices. In the ChoiceQuestion class you will have to rewrite the display function display. This is called overriding a member function.

After specifying the class you are inheriting from, you only write the differences: class ChoiceQuestion : public Question { public: ChoiceQuestion(); void add_choice(string choice, bool correct); void display() const; private: vector<string> choices; };

Where is the set_text member function? Where is the string text; data member? Right there class ChoiceQuestion : public Question { public: ChoiceQuestion(); void add_choice(string choice, bool correct); void display() const; private: vector<string> choices; };

ChoiceQuestion is one type,
Derived Classes class Question { public: Question(); void set_text(string question_text); void set_answer(string correct_response); bool check_answer(string response) const; void display() const; private: string text; string answer; }; ChoiceQuestion is one type, made of two subtypes. class ChoiceQuestion : public Question { public: ChoiceQuestion(); void add_choice(string choice, bool correct); void display() const; private: vector<string> choices; };

It is based on the Question type so it has those parts.
Derived Classes members from class Question class Question { public: Question(); void set_text(string question_text); void set_answer(string correct_response); bool check_answer(string response) const; void display() const; private: string text; string answer; }; It is based on the Question type so it has those parts. class ChoiceQuestion : public Question { public: ChoiceQuestion(); void add_choice(string choice, bool correct); void display() const; private: vector<string> choices; };

And, added to those parts from the Question type,
Derived Classes specializations class Question { public: Question(); void set_text(string question_text); void set_answer(string correct_response); bool check_answer(string response) const; void display() const; private: string text; string answer; }; And, added to those parts from the Question type, it has its own specializations (its specialness-es). class ChoiceQuestion : public Question { public: ChoiceQuestion(); void add_choice(string choice, bool correct); void display() const; private: vector<string> choices; };

Derived Classes to make one type: ChoiceQuestion v class Question {
public: Question(); void set_text(string question_text); void set_answer(string correct_response); bool check_answer(string response) const; void display() const; private: string text; string answer; }; to make one type: ChoiceQuestion class ChoiceQuestion : public Question { public: ChoiceQuestion(); void add_choice(string choice, bool correct); void display() const; private: vector<string> choices; };

Derived Classes – Syntax

The derived class inherits all data members and all functions that it does not override.

But… private means private.

Consider: Choice_question choice_question; choice_question.set_answer("2"); (OK, a public method in a derived part.)

How about: Choice_question choice_question; choice_question.answer = "2"; (Well, it did inherit that data member …)

No, private means private! Choice_question choice_question; choice_question.answer = "2"; // will not compile - private (OK – private means private even if inherited.)

This means that when you are writing the ChoiceQuestion member functions, you cannot directly access any private data members in Question. (Oh, dear. What to do?)

A good design would be for this function to take a choice and somehow an indication that this choice is the correct answer. (bool! bool! bool!)

Very good: ...but void ChoiceQuestion::add_choice(string choice, bool correct) { choices.push_back(choice); if (correct) // Convert choices.size() to string ostringstream stream; stream << choices.size(); string num_str = stream.str(); // Set num_str as the answer ... }

Oh dear answer is private! void ChoiceQuestion::add_choice(string choice, bool correct) { choices.push_back(choice); if (correct) // Convert choices.size() to string ostringstream stream; stream << choices.size(); string num_str = stream.str(); // Set num_str as the answer ... }

Happily, the designer of Question provided accessors! void ChoiceQuestion::add_choice(string choice, bool correct) { choices.push_back(choice); if (correct) // Convert choices.size() to string ostringstream stream; stream << choices.size(); string num_str = stream.str(); // Set num_str as the answer set_answer(num_str); } implicit parameter.set_answer(num_str);

Here is the class definition for ChoiceQuestion again.
Common Error Here is the class definition for ChoiceQuestion again. It’s wrong Can you find it? – we made a small mistake. class ChoiceQuestion : Question { public: ChoiceQuestion(); void add_choice(string choice, bool correct); void display() const; private: vector<string> choices; };

Common Error: Private Inheritance
Aha! class ChoiceQuestion : Question { public: ChoiceQuestion(); void add_choice(string choice, bool correct); void display() const; private: vector<string> choices; };

If you do not specify public inheritance, you get private inheritance and everything is a mess. class ChoiceQuestion : private Question { public: ChoiceQuestion(); void add_choice(string choice, bool correct); void display() const; private: vector<string> choices; };

If you do not specify public inheritance, you get private inheritance and everything is a mess. (Be careful, son!)

Common Error: Replicating Base Class Members
You know all about private access: A derived class has no access to the private data members of the base class.

But when some programmers encounter a compiler error, They just start hacking. they (not you, of course) don’t stop and THINK. ChoiceQuestion::ChoiceQuestion(string quest_txt) { text = quest_txt; } COMPILER ERROR: accessing private data member text

And an “easy” fix seems to be to add the data member that the compiler is complaining about. ChoiceQuestion::ChoiceQuestion(string quest_txt) { text = quest_txt; } COMPILER ERROR: accessing private data member text

And an “easy” fix seems to be to add the data member that the compiler is complaining about. class ChoiceQuestion : public Question { ... private: vector<string> choices; string text; }

Oh dear! TWO test data members!

One set by the constructor and the other displayed! Oh dear! Oh Dear! OH DEAR!!!

Inheritance Is For Behaviors, Not Values
As you start working with inheritance, don’t overdo it! Consider a fleet of taxis, some are blue and some are those regular New York yellow cabs, but they all IS_A taxi.

Consider doing this: class Taxi { ... }; class BlueTaxi : public Taxi { ... }; class NYCYellowTaxi : public Taxi { ... };

What’s the only difference between a BlueTaxi and an NYCYellowTaxi? The color. That’s is not a behavior, it’s a value. Don’t create classes based on values. Make the value be a data member.

The solution to the BlueTaxi, NYCYellowTaxi confusion: class Taxi { ... private: String color; };

Create classes based on behaviors: like livery and metered cabs. class Cab { ... }; class MeteredCab : public Cab { ... }; class LiveryCab : public Cab { ... };

Calling the Base-Class Constructor
Consider constructing a derived-class. Like all constructors, they don’t construct: they initialize. But a derived-class constructor can’t initialize data members in the base-class. That’s the job of the base-class’ constructor. Oh dear.

If the base-class has a default constructor, we are in luck: that can be used. If not… We have to somehow “call” the base-class constructor from the derived-class’ constructor. Oh dear!

The initialization list to the rescue! We put the base-class’ constructor “call” in the initialization list. The initialization list code happens before the { } of the constructor so the base-class will be completely set up before any specializations take place.

Suppose, for the Question class, a constructor taking a String for the text had been written: then the ChoiceQuestion class constructor would have to take a String parameter to use to set Question’s text and call its constructor in the initialization list... …passing the data for it’s text data member. class Question { public: Question(String question_text); ... ChoiceQuestion::ChoiceQuestion(string question_text) : Question(question_text) }

Overriding Member Functions
Recall that our design requires that the display member function be rewritten in the ChoiceQuestion class. This is called overriding a member function.

ChoiceQuestion’s display method needs to: Display the question text. Display the answer choices.

The second part is easy – just a data member int ChoiceQuestion::display() const { // Display the question text ... // Display the answer choices for (int i = 0; i < choices.size(); i++) cout << i + 1 << ": " << choices[i] << endl; }

The first part seems easy too – call the display in Question: int ChoiceQuestion::display() const { // Display the question text display(); // Display the answer choices ...

Oh no! this points to me – and I have a display member function! int ChoiceQuestion::display() const { // Display the question text display(); // Display the answer choices ... implicit parameter.display();

I’m talking to myself!!! int ChoiceQuestion::display() const { // Display the question text display(); // Display the answer choices ... } implicit parameter.display();

The solution is to do what you said in the first place: Call Question’s display: int ChoiceQuestion::display() const { // Display the question text display(); // Display the answer choices ... }

The solution is to do what you said in the first place: Call Question’s display: int ChoiceQuestion::display() const { // Display the question text Question::display(); // Display the answer choices ... }

When you override a function, you usually want to extend the functionality of the base-class version. Therefore, you often need to invoke the base-class version before extending it.

Use the BaseClass::function notation.

However, you have no obligation to call the base-class function. Occasionally, a derived class overrides a base-class function and specifies an entirely different functionality.

A Program With ChoiceQuestion
In the following program, the definition of the Question class, which you have already seen, is placed into question.h, and the implementation is in question.cpp.

#include <iostream> #include <sstream> #include <vector> #include "question.h" class ChoiceQuestion : public Question { public: /** Constructs a choice question with no choices. */ ChoiceQuestion(); ch10/quiz2/test.cpp

/** Adds an answer choice to this question. @param choice the choice to add @param correct true if this is the correct choice, false otherwise */ void add_choice(string choice, bool correct); void display() const; private: vector<string> choices; }; ChoiceQuestion::ChoiceQuestion() { } ch10/quiz2/test.cpp

void ChoiceQuestion::add_choice(string choice, bool correct) { choices.push_back(choice); if (correct) // Convert choices.size() to string ostringstream stream; stream << choices.size(); string num_str = stream.str(); set_answer(num_str); } ch10/quiz2/test.cpp

void ChoiceQuestion::display() const { // Display the question text Question::display(); // Display the answer choices for (int i = 0; i < choices.size(); i++) cout << i + 1 << ": " << choices[i] << endl; } ch10/quiz2/test.cpp

int main() { string response; cout << boolalpha; // Ask a basic question Question q1; q1.set_text("Who was the inventor of C++?"); q1.set_answer("Bjarne Stroustrup"); q1.display(); cout << "Your answer: "; getline(cin, response); cout << q1.check_answer(response) << endl; ch10/quiz2/test.cpp

// Ask a choice question ChoiceQuestion q2; q2.set_text("In which country was the inventor of C++ born?"); q2.add_choice("Australia", false); q2.add_choice("Denmark", true); q2.add_choice("Korea", false); q2.add_choice("United States", false); q2.display(); cout << "Your answer: "; getline(cin, response); cout << q2.check_answer(response) << endl; return 0; } ch10/quiz2/test.cpp

Common Error: Forgetting the Base-Class Name
Don’t forget to use the BaseClass::memberFunction notation when you want to call a member function in your base class – especially when you are writing: DerivedClass::memberFunction (Yes, Mom.)

Common Error: Forgetting the Base-Class Name
Manager derives from Employee which has a method named get_salary. Careful: double Manager::get_salary() const { double base_salary = get_salary(); // Error—should be Employee::get_salary() return base_salary + bonus; }

The Slicing Problem Did someone say slice?

It would be nicer if all questions were collected in an array.
The Slicing Problem In the main function of that last program, there was some repetitive code to display each question and check the responses. It would be nicer if all questions were collected in an array. You could then loop to present them to the user:

because ChoiceQuestion is a special case of Question
The Slicing Problem const int QUIZZES = 2; Question quiz[QUIZZES]; quiz[0].set_text("Who was the inventor of C++?"); quiz[0].set_answer("Bjarne Stroustrup"); ChoiceQuestion cq; cq.set_text("In which country was the inventor of C++ born?"); cq.add_choice("Australia", false); ... quiz[1] = cq; for (int i = 0; i < QUIZZES; i++) { quiz[i].display(); cout << "Your answer: "; getline(cin, response); cout << quiz[i].check_answer(response) << endl; } This works because ChoiceQuestion is a special case of Question

However, is it really working? Here’s a run of the program:
The Slicing Problem However, is it really working? Here’s a run of the program: Who was the inventor of C++? Your answer: Bjarne Stroustrup true In which country was the inventor of C++ born? Your answer: Where are the choices?

When you assign a derived class to a base class memory location,
The Slicing Problem When you assign a derived class to a base class memory location, Slicing Happens! Ah! sharp knives…

The assignment copies text
The Slicing Problem The assignment copies text and answer just fine.

But where does choices go?
The Slicing Problem But where does choices go?

The Slicing Problem

The Slicing Problem Sliced off…

The Slicing Problem

The Slicing Problem SLICED OFF!

The Slicing Problem …and into the stewpot!

The assignment copies only the base portion.
The Slicing Problem The assignment copies only the base portion.

Pointers to Base and Derived Classes
To access objects from different classes in a class hierarchy, use pointers (to avoid slicing). I’m putting the knife away… …forever

To access objects from different classes in a class hierarchy, use pointers (to avoid slicing). (pointers are sharp… hmm…)

Pointers to the various objects all have the same size: the size of a memory address. (convenient)

Pointers to base classes can hold pointers to ANY object publicly derived from it – as far down the inheritance chain as you want to go. (very general)

The opposite will not work: Assigning a base pointer to a derived pointer location will generate a compiler error. (pointer well taken) (make that: point well taken)

Pointers to base and Derived Classes
To manage a set of ANY Questions including any IS-A Questions: Fill-in-the-blank Numeric Free response Choice (single)

To manage a set of ANY Questions and Questions inheriting from IS-A Questions Fill-in-the-blank Numeric Free response Choice (single) Choice (multiple – inherits from Choice (single)

… and Questions that are just a gleam in a programmer’s eye Fill-in-the-blank Numeric Free response Choice (single) Choice (multiple – inherits from Choice (single) Essay Essay written longhand in pomegranate juice

To manage all of these, use a vector<Question*> of an array of Question* and store only pointers to the different kinds of Questions Fill-in-the-blank Numeric Free response Choice (single) Choice (multiple – inherits from Choice (single) Essay Essay written longhand in pomegranate juice

Code for Pointers to base and Derived Classes
Notice the use of new and -> : Question* quiz[2]; quiz[0] = new Question; quiz[0] -> set_text("Who was the inventor of C++?"); quiz[0] -> set_answer("Bjarne Stroustrup"); ChoiceQuestion* cq_pointer = new ChoiceQuestion; cq_pointer -> set_text("In which country… …C++ born?"); cq_pointer -> add_choice("Australia", false); ... quiz[1] = cq_pointer;

Code for Pointers to base and Derived Classes
And the assignment of a derived-class pointer to a base: Question* quiz[2]; quiz[0] = new Question; quiz[0] -> set_text("Who was the inventor of C++?"); quiz[0] -> set_answer("Bjarne Stroustrup"); ChoiceQuestion* cq_pointer = new ChoiceQuestion; cq_pointer -> set_text("In which country… …C++ born?"); cq_pointer -> add_choice("Australia", false); ... quiz[1] = cq_pointer;

Vector of Pointers to Base to Manage Base and Derived
Question* quiz[2]; quiz[0] = new Question; quiz[1] = new ChoiceQuestion;

Using vector<Base*>
The code to present all questions – any kind of Question – is: for (int i = 0; i < QUIZZES; i++) { quiz[i] -> display(); cout << "Your answer: "; getline(cin, response); cout << quiz[i] -> check_answer(response) << endl; }

When you call the display member function on a
Virtual Functions (take a deep breath) When you call the display member function on a Question* pointer that currently contains a pointer to a ChoiceQuestion, you want the choices to be displayed, right? (Whew … yes.)

But that’s not what happens.
Virtual Functions But that’s not what happens. (Oh dear)

quiz[i]->display();
Virtual Functions For reasons of efficiency, by default, the call quiz[i]->display(); always calls Question::display because the type of quiz[i] is Question*. (Do we give up hope now and go home?)

that the function should be the one in the thing pointed to.
Virtual Functions In C++, you must alert the compiler that the function call needs to not be the default, that the function should be the one in the thing pointed to. (How?) You use the virtual reserved word for this purpose.

Notice where virtual is written.
Virtual Functions Notice where virtual is written. The virtual reserved word must be used in the base class. class Question { public: Question(); void set_text(string question_text); void set_answer(string correct_response); virtual bool check_answer(string response) const; virtual void display() const; private: ... };

All functions with the same name and parameter types
Virtual Functions All functions with the same name and parameter types in derived classes are then automatically virtual.

Virtual Functions Although not needed, it is considered good practice to write the virtual reserved word in the derived-class functions. class ChoiceQuestion : public Question { public: ChoiceQuestion(); void add_choice(string choice, bool correct); virtual void display() const; private: ... };

You do not write virtual in the function definition:
Virtual Functions You do not write virtual in the function definition: void Question::display() const { cout << text << endl; }

what you call is what you get!
Virtual Functions With virtual member functions, what you call is what you get! (Got it!) quiz[i]-> display();

The quiz vector collects a mixture of all kinds of Questions.
Polymorphism The quiz vector collects a mixture of all kinds of Questions. Such a collection is called polymorphic (literally, “of multiple shapes”).

Inheritance is used to express this commonality.
Polymorphism Objects in a polymorphic collection have some commonality but are not necessarily of the same type. Inheritance is used to express this commonality. virtual functions enable variations in behavior.

Virtual functions give programs a great deal of flexibility.
Polymorphism Virtual functions give programs a great deal of flexibility. The question presentation loop describes only the general mechanism: “Display the question, get a response, and check it”.

“Display the question”
Polymorphism Each object knows on its own how to carry out its specific version of these general tasks: “Display the question” (my way) and “Check a response” (my way).

Using virtual functions makes programs easily extensible.
Polymorphism Using virtual functions makes programs easily extensible.

Suppose we want to have a new
Polymorphism Suppose we want to have a new kind of question for calculations, where we are willing to accept an approximate answer. All we need to do is to define a new class NumericQuestion, with its own check_answer function.

and these new numeric questions.
Polymorphism Then we can populate any quiz vector with a mixture of plain questions, choice questions, and these new numeric questions. They will fit in just fine because: they IS-A Questions. (That’s so nice.)

The code that presents the questions need not be changed at all!
Polymorphism The code that presents the questions need not be changed at all! The calls to the virtual functions automatically select the correct member functions of the newly defined classes.

The Complete Program with Polymorphism
#ifndef QUESTION_H #define QUESTION_H #include <string> using namespace std; class Question { public: /** Constructs a question with empty question and answer. */ Question(); @param question_text the text of this question void set_text(string question_text); @param correct_response the answer for this question void set_answer(string correct_response);

/** @param response the response to check @return true if the response was correct, false otherwise */ virtual bool check_answer(string response) const; Displays this question. virtual void display() const; private: string text; string answer; }; #endif

#ifndef CHOICEQUESTION_H #define CHOICEQUESTION_H #include <vector> #include "question.h" class ChoiceQuestion : public Question { public: /** Constructs a choice question with no choices. */ ChoiceQuestion(); Adds an answer choice to this question. @param choice the choice to add @param correct true if this is the correct choice, false otherwise void add_choice(string choice, bool correct);

virtual void display() const; private: vector<string> choices; }; #endif

#include <iostream> #include "question.h" #include "choicequestion.h" int main() { string response; cout << boolalpha; // Make a quiz with two questions const int QUIZZES = 2; Question* quiz[QUIZZES]; quiz[0] = new Question; quiz[0]->set_text("Who was the inventor of C++?"); quiz[0]->set_answer("Bjarne Stroustrup");

ChoiceQuestion* cq_pointer = new ChoiceQuestion; cq_pointer->set_text("In which country… …C++ born?"); cq_pointer->add_choice("Australia", false); cq_pointer->add_choice("Denmark", true); cq_pointer->add_choice("Korea", false); cq_pointer->add_choice("United States", false); quiz[1] = cq_pointer; // Check answers for all questions for (int i = 0; i < QUIZZES; i++) { quiz[i]->display(); cout << "Your answer: "; getline(cin, response); cout << quiz[i]->check_answer(response) << endl; } return 0;

CHAPTER SUMMARY

Inheritance.

Similar presentations

Presentation on theme: "Inheritance."— Presentation transcript:

Similar presentations

About project

Feedback

Log in

Auth with social network:

Inheritance.

Similar presentations

Presentation on theme: "Inheritance."— Presentation transcript:

Similar presentations

About project

Feedback