「英语」C++继承与多态
This post will introduce inheritance and polymorphism in C++.
Inheritance General Idea
- Inheritance allows us to create new classes from already defined classes
- This creates a Parent->Child relationship with the child gaining everything that is defined in the parent
This is known as an "IS A" relationship
- Chair "IS A" Furniture
Standard Inheritance
- No keywords for inheritance in C++
We simply use the
:
operator- Note: this is a single-colon, not the double colon that makes up the scope-operator.
class student : public person
Inheritance Modifier
- public
- protected
- private (rarely use)
Inheritance Modifier encapsulated the visibility of the things in the parent within the child.
Public Inheritance
- Public members in parent class are inherited as public in the new class
- Protected members in parent class are inherited as protected in the new class
- Private members in parent class remain private and cannot be directly accessed but can be accessed through public and protected members (interface) of the base-class.
When to use?
This is the most common way to do inheritance.
Protected Inheritance
- Public members in parent class are inherited as protected
- Protected members in parent class are inherited as protected
- Private members in parent class remain private.
Note: Since the public interface is now protected, you can not access the interface making it seem like class isn't "is-a".
When to use?
If the child wants to have their own public interface, and it wants other programmers exactly act on this child interface. Not the interface from parent classes.
Private Inheritance
- Every (Public/Protected/Private) members in parent class are inherited as private in the new class.
No longer "IS A" relationship. It now described as "IMPLEMENTED IN TERMS OF" relationship
When to use?
- I want to stop others from inheriting my class. Like a stopping point. You can still do inheritance, and it exists in your child class. However, they are inaccessible directly.
I use some of the interfaces from parent class, but users don't have to use it.
"If you make a class D privately inherit from a class B, you do so because you are interested in taking advantage of some of the features available in c lass B, not because there is any conceptual relationship between objects of types B and D."
Summary
Constructors
class Rectangle: public Polygon
{
public:
Rectangle (int a, int b):Polygon(a,b){}
int area ()
{ return width*height; }
};
Rectangle (child) invokes Polygon (parent) constructor. Be careful about single-colon :
.
Use Super (Parent) Class Methods
void child::print(int x)
{
parent::print(x);
}
We use the scope-operator ::
. ==annoying==
More Inheritance
- Single Inheritance
- Multiple Inheritance
- Multilevel Inheritance
- Hieratical Inheritance
- Hybrid Inheritance
Single Inheritance
Multiple Inheritance
- A class inherits from multiple different parents.
Multilevel Inheritance
- "IS A" relationship through multiple levels of inheritance
Hieratical Inheritance
- One parent class inherits multiple child classes.
- This is usually where Polymorphism is expressed the most.
Hybrid Inheritance
- This combines Multiple, Multilevel and Hierarchal inheritance to create a hybrid child class
Polymorphism
Polymorphism is change at the same level of inheritance
- Automobile -> Car -> Type of Car
Few primary mechanisms for polymorphism:
"IS A" relationship
- one class inherits from the other class
- Objects that "IS A" another objects can be stored in references to the parent object
Overriding **(NOT Overloading)**
- Overriding is when we redefine a method that exists in the parent class with a specialized version in child class
Polymorphism Overriding
In Java, we can use the tag @Override
to override a method. But it basically happens automatically.
In C++...
Virtual
Keyword- It allows us to mark a method as overridable
Virtual
What is Virtual
keyword?
Without the virtual keyword, the execution will default to the parent method’s definition
- This is known as static resolution, static linkage or early binding
The virtual keyword tells the compiler to examine the nature of the object and call the appropriate method instead
- This is known as dynamic resolution or dynamic linkage or late binding
Code Example:
Early binding - without virtual
keyword:
Without virtual
keyword, storing the child object in the parent pointer results in an unsuccessful override.
With virtual
keyword:
Pure Virtual
- We can create a method in the parent class to be default behavior (Some method definition).
We can also create a method with no method definition, also called Abstract Base or Pure Virtual Method
- Pure Virtual method has no definition explicitly.
- It exists only for the child to implement.
- It is still defined in the parent so every child must reliably have this method.
When we declare them, we actually use a special syntax:
virtual int myMethod(<parameters>) = 0;
- The
= 0
portion of the declaration tells the compiler that the method has no body explicitly.
Consequences to using Pure Virtual Method:
- Any class that contains a declaration for a pure virtual method is labeled an Abstract Base Class.
Abstract Base Classes CANNOT be instantiated.
- However, you can instantiate their child class (NOT a abstract base class), and store it into their parent (virtual) class pointer.
// Assume A is an abstract base class
// B is A's child class, and NOT an abstract base class
A* aTest = new A(); // Will cause error
B* bTest = new B(); // OK
A* parent = new B(); //OK
- Any class that inherits from the Abstract Base Class must provide a definition for the Pure Virtual methods.
- If they do not … they are also considered an Abstract Base Class and suffer consequence one
Pure Virtual … with a body
We can mark a method as Pure Virtual (= 0) and provide a body!
- Java interfaces cannot have a body in their methods.
- C++ lets us define a body for default behavior
virtual const char* speak() = 0
// The = 0 means this function is pure virtual
{
return “hello"; // even though it has a body
}
- You cannot explicitly call this method, because you cannot instantiate an abstract base classes.
- But the child class can call the parent class.
virtual const char* speak()
// this class is no longer abstract because we defined this function
{
return Animal::speak(); // use Animal's default implementation
}
Pure Virtual - Interface
- In C++ we can create interfaces through the use of Pure Virtual Methods and multiple inheritance.
- No keyword in C++, unlike Java use
Interface
Keyword.
评论已关闭