Name: 使うべきVisual Studioデバッガの8つのBIT! (8-BITs of The Visual Studio Debugger You Should Use!)
Uploaded: 2021-01-14T10:16:28.000Z
Duration: 18 min 9 s
Description: VoiceTubeの動画で発音を聞きながら英語表現を覚えよう！学べる英語：

hello and welcome to another eight bit self video.

未来進行形

This time we're going to be looking at different parts of the visual studio D bugger you should be using.

It doesn't matter how good a programming you think you are.

Eventually, you're gonna need to debug something.

And if you watched any of my videos, you know that I'm quite a fan of the visual studio tools, and they've got some very powerful features that can really help you debug your code.

The eight bits in this video aren't in any particular order this time.

What should be enough to give you a good understanding of the D boogers capabilities so you can experiment for yourself?

I'm sure if you programmed in visual studio, you're quite familiar with how to compile and run your program.

And if you run the d bugger, your program runs and exits and we get some outputs and you might have a little council window or logging facility, which he could have used to captured that what your program is done.

However, sometimes it's a lot more useful to just look your programming running in real time.

Now you may notice I've popped a little keyboard on the screen, and this is to show you some of the keyboard shortcuts that I'll be using in visual studio with any D bugger.

The first and most important part is actually getting to the code, But you want to de book.

You don't want to start from the very beginning of your program every single time.

So I like to press the cursor where I wanted to be on.

And as you can see, the D bugger has started on this yellow arrow here indicates what line of code is about to be executed.

Let's take a minute just to set up the environment to something useful.

If you go to the debug menu, appear in select Windows, the things that you'll want to see are the autos locals, the call stack, possibly the feds on a memory window.

So knowing that Control and F 10 will start and run to a location just pressing F 10 on its own will execute it line by line.

Let's first have a look out to the locals window, the locals window will display all of the variables that are in the current scope of your program.

Now my program only contains in Maine sweaty variables I've defined are all local, and we can see here for this in a it's appear and it's currently not.

That's because, of course, it's not been defined yet.

As soon as I press half 10 we see that a has assumed the value seven on it, recognizes of type end Press F 10 again, and we've executed the next line.

Now where value be has been attributed the value eight and it's a float and so forth we can see as we step through the code.

These update themselves automatically when we use a more complex type, but something well established within the c++ language.

Like a string, the de booger also actually makes it quite useful to see what the contents of this string is.

So we know that behind the scenes of string is effectively a link list, but the D burger is intelligent enough to tell us.

Actually, it's a string on the value of the string in this case is hello.

By selecting the arrow next to the S here on, it's a type string.

It could be expanded to show what the string consists off so we can see its size.

We can see how much memory has been allocated to representing this string, and we can see the individual elements here in the container.

This hierarchical way of looking at data is quite common in the de booger on it will do the same for strokes and classes.

This, of course, is a different way off storing a string.

If we just allocated buffer directly, we can see who appear.

The buff has been allocated as an array, including the ah, the escape character.

This is the D bugger being quite clever, and it recognizes that both is actually a char on.

It will just keep displaying the data associated with this char pointer until it reaches the escape character.

Another powerful, yet potentially dangerous feature of the deep ogre is you can edit the values off the memory.

So if we wanted to change the value of Interview A, which is currently seven to something else, let's say three.

We just double click on it and set the value.

It is now three, even though in our code it's quite clearly seven on.

We haven't done anything to set it, but we have changed it behind the scenes.

Sometimes another useful thing to do is to set this to Hexi decimal display, where we can see the hex equivalents of the values.

This may look untidy at first, but later on, if you're starting to work with bit strings and bitter raise, this could be quite a useful tool leading straight on into bits.

We can see how Pointers Air also handled by the de Booger, using the variables I created earlier.

I'm going to create a couple of pointers to those variables.

So in this first line here, I'm creating an interview pointer to the variable.

If we have a looking at the booking window, we can see that P A.

I'll pop this back into decimal view, and we see here some curly brackets with some question marks in this is the D Boger, telling us what the value is at that point of location and is currently undefined.

So let's define it by stepping to the next line of code we can now see The Pointer has been given a memory address on it contains the value seven and this is we're having a memory window can also be quite useful.

We can just click and drag that address into the memory window and have a look at it directly, and we can see, of course, appear in the first element is our four bites.

Representing the interview on its value is seven.

If we wanted to, we can change the value of this memory by right clicking on selecting added value.

Any memory that changes gets highlighted red, and we'll see a bit more of this later home.

Let's have a look now at the floating point pointer, we can see the deep bugger knows what type it is and displays the data accordingly.

And if we have a look at this in a memory window, this is the hex decimal equivalent of our floating point value, which, of course, doesn't make much sense to mere mortal humans.

So to make this more readable, you can right click and choose a particular data format to display.

In this case, I know my floats are 32 bit floating points, so I will change the memory display to 32 bit floating point on.

We can see the first value is eight, which is the actual value that the pointer is pointing to.

If I press F 10 again, we've now given the P both somethingto look out.

We've given it the value buff, which was our character string before.

And as you might expect, there's little difference between the buffer created here.

And he pointed to the buffer created here because they are one and the same.

But if we drag that over to a memory window and have a look, we see that some hex decimal characters here, which represents our world and actually shows you that in the memory with an asking interpretation.

Off the Hexi decimal characters bit sixes about navigating functions, using the deep Okay, so if I control in f tend to this line, it's executed all the code that we saw before, and we can see where we are in our current call stack.

At the moment we're just in Maine, highlighted by the blue line appear on.

There's a little yellow arrow telling us where we are now.

If I pressed F 10 again, what's going to happen is I'm going to step over that line.

We can verify this by looking at the local variables it says appear.

Function one returned the value 49 which if we go and have a quick look at function one by expanding it, we could say it's just the square of whatever the argument.

Waas, however, what if we wanted to debug function one?

The first is we can select a line in function, one that we want to de book and press control in F 10.

Of course, our program will go on to that line, and if we have a look at our call stack, we can see Mayne was the original function that was cold, which is here on.

Once you're inside this function, we compress F 10 to step through the code as normal.

And when we get to the end of the function, pressing of 10 again will take us to where our program currently is up to.

The second way to debug the function is to control in F 10 to it, and you can now press F 11 to step into the function on back out.

Stepping into an over functions on any other kind of call in your program is vital to debugging as there's pretty much always a 1 to 1 relationship between the nature of how you're stepping on the order off the program execution.

However, this is where things get a little bit daunting.

Let's say I control in F 10 to this string declaration.

Well, of course, we know that string is actually an object is not a primitive type.

So if I pressed F 11 I start to step into the constructor off the string and you can see it gets quite complicated.

We can see how everything works, but I'll be pressing F 11 for a long time here.

So sometimes I need to step out off the code and two step out of a function it shift in F 11 hold down the shift hold on F 11 and Eventually I get back to where I waas.

The code is still executed, even though it's called stepping out.