Name: 実用的なポリモーフィズムC++ (Practical Polymorphism C++)
Uploaded: 2021-01-14T10:16:33.000Z
Duration: 41 min 44 s
Description: VoiceTubeの動画で発音を聞きながら英語表現を覚えよう！学べる英語：

In this video, I'm going to look at using polymorphism on object oriented programming to make our application development simpler.

I'm going to demonstrate that through the use of a simple computer aided design like application.

But you may have noticed I'm not in my usual programming place.

Well, it shouldn't be a very surprised you that I'm actually full time employees.

And sometimes my job requires me to go out on the road and stay in delightful hotels such as this one.

Nobody ever said programming was glamorous.

I'm traveling around with work like this has completely ruined my YouTube schedule for the year.

So those of you expecting to see on update to the top down city based car crime game Well, I might take something on at the end of this video if I've got a couple of minutes to spare.

So this video, I thought, be useful to do something to enhance sort of the c++ basics, and we'll look at polymorphism a very useful technique.

Instead of using games to demonstrate polymorphism, I'm going to create a small application, a very simple can't package.

So here I've got a matrix of dots which the cursor can clamp to when we can see we've got some axes on the middle of these axes represents 00 in our world.

Now, if I press a particular key, I could start to draw a shape and we'll see to little red dots that allow me to manipulate the shape so that we've got to box on here.

I can draw some lines just for them around all over the place.

At the moment on, we can draw circles to see the radius is a line surrounding by circle shape.

Now, of course, we've done panning and zooming before, so I won't go into too much detail about how I do that in this video.

And I can also place my cursor over any of the red dots and tweak the shakes positions.

Oh yeah, before I forget, there's one more shape to this is a multiple construction shape that gives us a spine.

We can define curvature very nice, and you might be thinking, Well, what's this got to do with polymorphism?

well, it's difficult to graphically show polymorphism, but here all of these shapes are effectively the same object to the code underneath.

Of course, the shapes a unique in that they are circles and squares and lines and SP lines.

But the code that will handle these shapes doesn't really know about that.

And it doesn't care either, which means making our application can be quite a simple process because instead of trying to handle all of these different shapes, uniquely will let polymorphism do it for us.

Now, some of you not familiar yet with polymorphism may already be thinking of ways to handle this.

We could have lots of objects for all the different types of shape on our applications that interrogates those objects one by one, depending on how it should be manipulated or drawn to the screen.

Perhaps another solution is to create one type of object, which is all of the objects and the object itself in self determined what to do in a given scenario.

Approaches like this are valid, but they can be a bit messy on we may as well use the tools C++ provides for us to do this on dhe the primary tool and what this video is, that is.

Polymorphism will engineer our code in such a way that the compiler can decide at runtime which methods to call, what shapes to draw and how things should look.

Now I will start by saying that Polymorphism is not a beginner topic, although the way I'm going to show it in this video, we're really only going to start looking at it that the most top level, object oriented programming and polymorphism is a really rich and detailed topic in its own right.

But you can achieve quite powerful things just by knowing the very basics for this video, I'm going to assume you do know a little bit about classes already on the low Polymorphism does exist in lots of different languages.

I'm going to be specifically looking at C plus plus.

Let's stop with a simple class in this case called A and A has a function called Do Something.

Something Function does depends entirely on what Class A is.

Now I'm going to assume that we have a set of structures in our program that's all quite similar in nature.

I they have a lot of commonality between them, so I'm going to try and package that commonality up in class A to turn it into a base class.

This, of course, means Aiken derive from my base class, More classes.

In this instance, Class B Class B inherits all of the methods and attributes from class A, assuming that it can do to whatever access specifies we've determined are on those properties off class A.

But let's for now assume that everything is public and easily accessible.

If I create an object of type B and call the do something function, then that do something function is defined by the base class, eh?

I can, of course, override the do something function by simply redefining it in class B.

Now, if I create an object of type B and call the do something function, it will call this one instead.

And it goes without saying that if I create an object of type A and call to do something function, it will call this one.

This too, could have its own do something function.

But we started this with a particular caveat on We said that these classes that derive from Class A were in some way similar on we created Class A as a base class to encapsulate the common functionality between the two divide classes on in applications.

It's useful to group things that are similar together.

And so how can we do this if I create an object of type Class?

It is very clearly defined, was big of type A.

Likewise, if I create an object of Type B, it is very clearly defined as being an object of tight be.

It is not an object of type A, even though be inherits from a it is defined as being be naturally.

The same also applies to an object of Type C.

When we want to group things that a similar in C++, we have several ways of doing this.

One approach is, of course, to use an array.

But whenever we specify an array, all of the elements of the array of the same type, perhaps we could use a vector.

We have to nominate a type for our vector in front.

Any of the standard containers will have the same restriction.

The convenient thing to do is to hint to the compiler that B and C are in fact derived from a on that our vector.

Well, this is quite nice, and we're almost there.

But if I wanted to use a specific element of our vector of Type A and call our do something function as we saw before, it's going to call the do something function defined by Class A.

We've still not got the flexibility implied to look at the divide classes.

That's because all of our objects have Type A.

Instead, I'm going to do something that appears a little strange.

I'm going to create an object of type Class A.

But I'm not just going to create an object.

I'm going to create a pointer to the object.

So this means now when I'm creating a new object, I need to use the new key word or smart point to equivalent.

But now I can do something a bit special because B and C were derived from a on All I'm storing is a pointer to where a might reside in memory.

I can actually create a new object B and of course I can do exactly the same for my Class C type.

So now when I create my vector toe, hold my similar objects together, I'll make it hold some pointers to Class A and threw some smoke and mirrors implemented by the C++ compiler.

What we are implying here is that if classes B or C override a method in class A, then if we were to call such a method in this case, our do something method that it will call the appropriate method related to the class that was constructed.

And that's quite a complex and powerful thing.

I can now store in a single container, a group of similar objects that all have unique functionality but a common interface in effect, we have allowed the base class A to morph into multiple subclass is a polymorphism.

We have eliminated the need to manually check what the type of each object is on.

The required functionality were requesting at that point in time, but it's not quite a simpler is.

I've just made it out to be we need to hint to the compiler which functions were likely to be overriding.

Here is a very simple class definition for type A.

We can see I've got the void do something method.

That's the one we've been trying to override with our sub classes.

If hours before, we just directly called the do something method on the object stored in our vector, regardless of whether that object was of type B or C, it would still call the do something method related to class A.

We need to tell the compiler that do something is a candidate to be overwritten by a base class on.

This hints to the compiler that I may be overwritten if I'm not overridden than any call to the do something function will naturally be implemented by the base class, eh?

Whatever code is written here, so if it is overwritten, it'll executes the overwritten code.

But if no override is provided, it will execute this default code and this one last philosophical thing to think about it, it may be the case that class A on its own doesn't make sense.

Once something has been derived from Class A i e.

We've created classes B and C, in which case Class A is really just an interface to its sub classes on its own.

字幕リスト動画再生

実用的なポリモーフィズムC++ (Practical Polymorphism C++)

access

multiple

scale

structure