Name: 操作員超載 (Operator Overloading)
Uploaded: 2021-01-14T10:15:12.000Z
Duration: 18 min 2 s
Description: 【看影片學英語】數萬部 YouTube 影片，搭配英漢字典即點即查，輕鬆掌握單字發音與用法，長久累積看電影不必再看字幕。

In this video, I'm going to have a brief look.

Att OPERATOR Overloading and show you how you can use it to simplify your programs.

Now, in many of my videos about graphics and physics, the first thing I usually do is create some sort of structure that represents a to D point.

So in this case factor floating point to D on, I would give it to member variables Float X, and I'll initialize it and float.

And somewhere in my main program, I'll create some of these vectors.

So let's take Victor a here, and I'll initialize that to 1.0 on dhe 2.5, for example, on Dhe, really, I work with just one vector.

We may have a bunch of them, so I'll create A B and C.

And when I want to operate on these directors, I would do it on a component by component basis.

So a dot X equals b dot x plus seed attacks on whatever you do for X, you typically want to do for white.

So in this case, I'm adding the two factors together.

I could also do it using initialize the lists.

I could say a equals b dot x plus c dot x comma be dot war II plus C Don't why, and that would be equally valid.

And so far, my programs have been simply enough that this is a completely fine way to do things.

However, with working on the top down city based car crime game, I'm doing a lot of things using physics and to de vectors, and after a while it gets a little cumbersome to keep splitting of the code into two lines.

I also mentioned in my coat yourself feed the engine Siri's that one day I'll do a video about operator overloading to simplify the nature of the back to type.

Well, surely it would be much more convenience to just write a equals.

B Plus C on the system knows how to go on Adam.

You can see it gives you a little red wiggly here because it doesn't know how to out these two types of the moment.

So let's make a basic two D vector type that, to all intents and purposes, can be treated like any other basic primitive in the program.

Firstly, the only two members I want my type to contain are the X and Y variables, and I want everything within this type to remain public.

So I'm just going to keep it as a structure lets out a simple constructor to start with, and I'm going to use member initialization syntax.

I don't really need a body for my constructor, but I've got to include the brackets anyway.

I've got to constructed for initializing the struck.

Except this time I'm going to pass in the values zero zero again, an empty body.

And simply because I want to show various interesting things in this video, I'm also going to add a copy constructor, which takes a reference to an object of the same type and constructs with it again, an empty body.

Since we're creating a vector type, it may also be useful to include some utility functions normally associated with vectors, for example, getting the magnitude or the length of the vector, which is simply the high Potter news.

I never know why video studio doesn't put spaces there another common thing to do if actors is to normalize them.

So create a function called norm, which returns anew.

Vector, which is the normalized form of this vector.

So first we want to create a temporal variable cold Oh, which is the inverse of the magnitude.

And I'm going to construct a new vector where I multiply the components by our and that will give me the normal the third year sole function, maybe to get the perpendicular you something at 90 degrees to this factor.

I'm just going to create a new vector and swizzle the components around.

So far, we got nothing out of the ordinary.

We've just added utility functions to a stroke, But how do we make it behave like a primitive?

It's time to start overloading some operators.

I think the first operator I'm going to add is going to be simply addition Aunt.

To specify the overriding an operator we need to use the operator keyword and then the symbol that we wish to override.

Now I find to the syntax of operator overloading little bit clumsy, but it say it does make sense once you get used to it.

And the intention of this addition, if we will take what's on the right hand side and add it to the left hand side and will assume that this particular stroked is on the left hand side and so will pass into this operator overload the right hand side or at least a reference to it.

Now we don't want to in any way modify this structure.

Simply adding two vectors together shouldn't change either of those vectors.

I'm going to construct it with a mechanism that facilitates this addition.

I'm going to use this key word, which is a pointer to this particular struck.

We stick its experiments, and I'm going to add it to the right hand sides experimenter.

And, of course, do exactly the same for the why it goes without saying that the other basic operators are exactly the same, so subtraction.

We just need to change the mathematical operator used in the constructor.

Multiplication and division don't really make much sense to do a similar pattern.

Instead, what we want to do is is passing a floating point scaler.

So change this to float right and so I can stay the same.

But this time we're just multiplying this structure's X and Y coordinates by the scale of values.

Let's try the mouth we can see on this third line.

The compiler no longer has an issue with it.

The red wig Lee has gone, but let's see if it actually works.

We'll change these values to something different just so we could follow along.

I'll zoom in here and we can clearly see the De Burger is quite happy representing our vectors.

So I just perform the addition when we can see that the values have changed appropriately.

III, in this one little operation, we've performed additional code.

I know that I'm using the constant e word and this is used to reinforce the point that the right hand side should not be in any way modified.

So if you do try to modify it, the compiler will catch it for you.

But what if we wanted to self modify the vector.

We've not defined what happens for this operation.

Let's consider what happened when we did just the regular edition.

The addition operator was identified, and so we performed the calculation.

We had dot exe and dot exe dot Why plus dot why?

And we created a new object using that result, let's just call that D.

We then returned D, which was copied into the location of A.

However, this time we want to directly change the values of a based on whatever is going on on the right hand side.

Effectively want X plus equals be dot Exe and why plus equals bead up.

Roy, I know that this time we're not copying anything over to a, However, we do want to return something just in case.

The result of all of this, it's used in some other equation, for example, C minus all of that.

So when the operator insists that we're going to modify the structure itself, we don't really want to move things around.

If we can help it so goingto work with references, operate a keyword plus equals is the operator.

Overriding the right hand side is the same as the previous edition and will perform the operation manually.

But we're going to use this key word again just to make sure we know what we're operating on.

So this objects X value Plus equals the right hand side dot x value on the same for why, but I want to return a reference to this object, just in case it's used by other things.

I don't want to return a pointer to this object, so I'm going to grab the value off it.

Now we can see the compiler is quite happy with that.

Syntax, multiplication and division are similar, but again, we can't multiply two vectors sensibly, so I'm going to change it to a scale of value.

Instead, we'll just do the same for devoid.

So now we've got the facility to do quite complicated operations, and we can see here.

字幕列表影片播放

操作員超載 (Operator Overloading)

sophisticated

access

scale

structure