Loading...

2.10 The Inheritance Mechanism

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.

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.

查看授课大纲

您将学习的技能

Graph Theory, C++11, Standard Template Library, C++

教学方

Ira Pohl
Professor

脚本

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.

关于 Coursera

课程、专项课程和在线学位均由全世界一流大学和教育机构的顶尖授课教师教授。

Join a community of 40 million learners from around the world

Earn a skill-based course certificate to apply your knowledge

Gain confidence in your skills and further your career

Coursera 致力于普及全世界最好的教育，它与全球一流大学和机构合作提供在线课程。

© 2019 Coursera Inc. 保留所有权利。

通过 App Store 下载

通过 Google Play 获取