This course is for experienced C programmers who want to program in C++. The examples and exercises require a basic understanding of algorithms and object-oriented software.
2.10 The Inheritance Mechanism
Loading...
来自 University of California, Santa Cruz 的课程
C++ For C Programmers, Part B
83 个评分
Explore Related Videos
At Coursera, you will find the best lectures in the world. Here are some of our personalized recommendations for you
从本节课中
Hex as a graph and Inheritance
This module shows how Hex can be played as a game on a graph. This involves its representation as an undirected graph in C++. The module explores the inheritance logic and syntax of C++. A principal example is the base class student and a derived class grad_student.
与讲师见面
Ira PohlProfessor
Computer Science
So now we're going to treat our major topic, in programming
in C++ today, and that's going to be inheritance.
And we're all used to inheritance,
inheritance is one of the foundational ideas.
Fact is the fundamental dogma of biology.
We all inherit. We inherit, and
the replication occurs because of our DNA. We have genes,
we have parents. And this is showing how
some kind of disease gets transmitted. A diseased gene
shown here and showing what the likelihood of transmission is.
It's critical understanding biology.
But it shows up in object oriented programming.
Languages like Java, languages like C++ became the dominant ways to
do programming starting in the late 80s because this was a way to do code
sharing. And this was a way to get a polymorphic
dynamic response.
To behaviors and if you were using
Smalltalk terminology, there would be methods getting messages
and the right methods would be selected
depending on the characteristics of the underlying type.
All of this is part of inheritance. In OOP,
in object oriented languages.
And I am expecting that you already
came to this class knowing these basic concepts.
So what inheritance gets us is a means
of deriving new classes from existing classes.
Terminologically those existing classes are called base classes.
When we get this derivation, it is a way of reusing existing code.
Reusing existing code again in the software world is the magic bullet.
How do you keep software developing costs down?
You keep it down by not using, not having to write unique code.
Anytime you have to write unique code, you produce
a next product or a next implementation, you have to do exhaustive testing.
You have to make sure that that is correct.
if you have pre-existing carefully tested code and then it just
becomes a component, plug-in, a lego component of building a
bigger system, you have great cost saving. So,
error proneness in developing new code has existed,
because this is a critical reuse technology.
Derived code, the, so we have this inheritance relationship.
Parent, descendent, offspring.
The offspring code is generally an extension of the parent code,
where some new stuff has been added to the pre-existing stuff.
If we didn't need anything new, there would be no reason for inheritance.
We would just use the old thing.
So there has to be a reason for the new thing.
And that's usually that some code is altered, some
behavior is changed, or some additional features are added.
In the example we'll show in, in the, in the next few lessons, will
I think give you a good insight into
how this all works.
When you're finished with this data structure, you have a tree.
It's your inheritance tree.
You can go back and, you know, go back to Adam and Eve.
And you can see in the, in the human inheritance structure.
How the different characteristics.
How did things end up being by looking at the previous generations.
So, there's a hierarchy
of related types created that share code and they share interface.
So, what we're going to see is an example in which
we're going to have as a base class a student.
And we're going to think about this in a point of view,
well, course I've been at the University of California for ever.
When you build big data base for something like
university, university has all different categories
of people on the campus.
There are students, there are special kinds of students, so there,
are generic students but then there might be a graduate student.
There might be even further subdivisions of students.
There might be students who are in special categories, like professional
students, like online students that are, have different characteristics.
And, indeed you could even think of something more basic if
you were building some big database for your university such as person.
So, if you had person, then you would have not only student,
but you might have employee, and
among employees you would have different categories.
Again, this would give you a development, model.
For building a system
that would reflect and model, and let you implement stuff you needed for
working with, everybody on the university campus.
So, you'd have employees, some of the employees would be academic.
In the academic employee, there would be.
Possibly tenure track and non-tenure track faculty.
And then on the employee staff there might be professional staff, business
staff.
maybe police and fire department service staff.
Again, you'd have different categories. If the category was significant.
It would require its own class. And that class would inherit
from something more basic. So
here's a class student.
One of its characteristics is, how you can have
a freshman, a sophomore, a junior, a graduate student.
A student would have a name.
There might be a student I.D. Maybe it's like
a social security number, maybe there would be a GPA,
what year the student was in.
So this is again a constructor.
Let's say we want to print out an instance of
students by the way, I'm putting three question marks here.
Just so you know, you should know what const means
in that position, right? That means that the this pointer,
the instance, will not be affected by this method, by this member function.
It won't change it.
And then now we have, when we do inheritance typically
we no longer we generally we stay away from private.
And now stuff that was private is instead made protect it.
And by protected it when you inherit it When the
derived class inherits it, it's visible to the derived class.
Derived class
methods can directly make use of any of this information.
So, the overall, data,
privacy scheme in C++ is
public, that's everyone.
protected, that's derived.
private.
That's the most restrictive.
You can also use the friend logic here, if you want to get at private parts as well.
So with, with inheritance, we now see this important
third class of data hiding, protected. So within the inheritance
hierarchy, within the family, protected is going to have heavy use.
Okay, just recall from what I just said, what is the use of const at that point.
And the, the point of this is, this is a, this is a member function.
Remember, it gets activated with something like a.print().
So this would be its activation. And that means
that the compiler can check
for const correctness,
that means a cannot,
a cannot be mutated,
a cannot be changed.
