Name: 禁断のC++ (Forbidden C++)
Uploaded: 2021-01-14T10:13:58.000Z
Duration: 33 min 7 s
Description: VoiceTubeの動画で発音を聞きながら英語表現を覚えよう！学べる英語：

there exists a place that you so secret that 1,000,000 thinking about it's guaranteed to upset somebody.

程度の副詞

Embracing these ideas is so dangerous that simply suggesting you ever heard of them will cause immediate outrage on the Internet.

Joining me on a journey to this frightening location.

I was just reading a story about processes from the eighties.

I don't think anybody is going to be interested in those.

If you like stories, I have a good story for you.

I've recently become the owner of a box, the boxes labeled Forbidden C++ on Within Lies the most heinous and evil forms of C plus plus code ever known.

Did my hand into the box and see what it yields?

I'm sure everybody watching this is quite familiar with variable.

A of type Interview on this variable exists within the scope of this main function.

The scope is defined by these curly brackets, and we should be familiar with the idea that nothing outside of this scope concede the variable a that have just created.

But what happens when we create a variable that isn't inside any scope?

It is within all of the scopes within this file.

Now, for a simple one file programs such as this.

There's nothing wrong, a tall with that approach, and indeed it's quite convenient to operate this way.

And to all intents and purposes, it behaves like a regular horrible.

So here I am, out putting the value of that variable from the main function.

Global variables start to become more tricky when you've got multiple files in your project here.

I've added three very similar classes to my project on They all have a function called some method on that some method is going to print the global variable.

I'll include these at the top of my main program, but straightaway, we've a problem because these classes can't see.

My global variable on, the compiler warns, is a such So what happens if in the global name space here for all of the classes, I also declare my global variable.

It's now saying there are multiple instances off this global variable and that's quite right.

Instead, why don't we create a head of file called Global Header and declare our variable in that on include our global head of file in each class?

Well, that's not really changed anything.

There's still a redefinition on that makes sense, because hash include is effectively just couldn't paste the same bit of code into each class.

We've not really changed anything there, so I need to indicate to the compiler that I want this to be the same variable.

No matter where it's called on in my main program, I'm going to create an instance of each one of my classes and call the method.

And here we see the result perhaps somewhat expected.

They all display 666 They've access that global variable under displaying its value, except that's incorrect because I didn't mention this.

But Class B changes the global variable value, so that's the first thing to worry about.

But secondly, even though we changed the global variables value when we output from Class C, its output, it's 666 again so clearly even though the compiler hasn't complained, the program isn't functioning in any way like I intended, so why don't we try throwing some of the buzzwords at it?

This is what people usually do when they're trying to make global variables work across files.

Now it's compiled it, saying It's got unresolved external.

So now I need to go and add on implementation for this variable.

Oh, well, at least now it's behaving in a somewhat expected way, but this seems a little bit of a mess.

I don't like having to have this implementation somewhere in my code.

I wanted somewhere tied to where have declared it, because I could effectively put this anywhere, and I might put it in the wrong place.

Well, modern sea has a solution for that.

We can now declare this as being in line onset.

Aunt behaves as expected, This in line keyword has sort of mutated over the last 20 years or so, But one way to think about it now is that when it sees a symbol like this is part of a compile unit.

Then it's the same across all of the Compile a ble units, so that's made implementing global variables a little easier.

But let's not just bypassed the big problem we have.

They're one of our classes, did something unexpected to the global variable, and that's affected the subsequent behavior of the program.

And that's the really big problem with global variables is nothing is protecting them, and nothing is guarding them on this.

Convicts squashing certain bugs very, very difficult indeed, particularly in large code basis, with lots of variables on many files.

As programmers, we should always aim to write functions where the end user can anticipate what the expected result is going to be.

On the whole, the c++ language allows us to do that very well because it has scope variable, so any variables inside a function somewhere can only really be changed by that function.

The fact that a function can change a global variable and therefore alter the state of the entire system without any warning or hint that it has done that to the user means that we get unpredictable behavior from call in that function so just be aware of these things when using global variables for simple applications where you're in full control.

Firstly, there always a pain to get set up properly.

Secondly, they may not always behave the way you expect them to do.

And thirdly, they are accessible from absolutely anything and anywhere in your program.

Therefore, you have no guarantee what this state of the global variable will be after you've executed some code.

Well, let's not stop the shall we see what's next.

Oh, I hope you've got a strong stomach, Mac Rose.

Here is a deliberately simplified program.

It has a loop which it rates 20 times on outputs, the result of the max function between a random number drawn between zero and 10 on Fight.

So what we should expect to see is that the smallest number ever displayed is five.

I've got five got a four and five and another four men and eight.

55550 And then a a one and then another five.

Okay, clearly not working, and this is because in a rather evil way, Max is not a function.

It's a macro that I've defined appear, and it's a fairly standard implementation off a maximum macro on just a little side point.

This is also considered really evil, for some reason, the turn every operator.

But hey, and so to all intents and purposes, it looks and feels like a function, and even in most cases it behaves correctly.

But the thing with Mac Rose is they are not executed at runtime there, purely a pre process er glorified cut copy and paste tool for the compiler, which undeniably can also be very, very powerful.

You just need to wield this power rather carefully.

So why was a result in correct macros are just a copy and paste tool.

So even though they can take in arguments in this case A and B, let's copy and paste this manually.

Other two arguments that I supplied to the macro wherever we see the argument a we're going to copy and paste in the corresponding argument on will do the same for B.

Let's just tidy up this turner, a operator, so we can understand what decision it's making.

So this is the equivalent of saying if this is true, then returned.

Five ehlz return our first argument, and here we can see the problem.

The original test is fine, but one of the possible answers is to call the random function again when in reality, what that should be returning is the result of the argument we passed in in the first place.

Don't forget, this has happened at compile time.

So this code appear hasn't been executed at any point.

字幕リスト動画再生

禁断のC++ (Forbidden C++)

sophisticated

potentially

structure

instance