Hey coders! In this video, I’m diving into CGDB, a powerful curses layer on top of GDB that makes terminal debugging a breeze. See your source code and breakpoints side-by-side in one clean interface. I’ll walk you through setup, breakpoints, and why CGDB rocks for C++, C, and assembly projects. Watch my GDB video first for the basics (link in comments)! If you dig this, subscribe and drop a comment for more coding tips. Let’s debug smarter! #CGDB #GDB #Debugging #Coding

Introduction to CGDB 00:00:00
Recommendation to Watch GDB Video 00:00:05
Explanation of CGDB and Curses 00:00:23
Building and Running CGDB 00:01:03
CGDB Interface Overview 00:01:56
Setting Breakpoints in CGDB 00:02:18
Managing Breakpoints 00:02:53
Benefits of CGDB 00:03:47
Closing Remarks and Subscription Request 00:04:00
Call for Comments and Suggestions 00:05:30

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social

Please help support us!

• Subscribing + Sharing on Social Media
• Leaving a comment or suggestion
• Subscribing to our Blog
• Watching the main “pinned” video of this channel for offers and extras

Hey everybody! In this video I’m going to talk about CGDB which is just a debugging program.

If you haven’t seen my other video on GDB please watch that first because

I go over all the concepts of debugging an assembly program, a C++ program, a C program

and it’ll be much more useful than this video.

This video is just about CGDB which is really a curses layer on top of GDB.

on top of GDB. Curses is a library that allows programmers to kind of make

graphical interfaces in the terminal so the point of this video is just to show

you a slightly different way to use GDB that’s why I’m saying go check out the

previous GDB video first but you know I think you know sometimes people like CG

to be so what am I talking about for starters pretend that I have a program

I’ve got an assembly module a C++ module and a make file you don’t know

or C++, see my other videos.

This video is only about CGDB.

But I can do, you know, make build,

just to build my objects and my executable.

And then normally, if you know GDB,

you can go GDB main and just enter the GDB terminal, right?

This is great, you can do a lot of commands from here,

but it’s not very graphical.

It does have a graphical mode, to be honest,

but it seems to be kind of glitchy,

so I’m not really gonna talk about it.

going to talk about it anyway so instead of launching your program inside of gdb you can

launch your program with c gdb c standing for curses i don’t think this is installed on the

current system so i’ll probably have to install it right okay so you can go sudo apt install c gdb

and then just enter your password

Let me do clear and then we’ll do CGDB main.

And I just want you to see that it’s got two windows.

This is the whole point for me anyway.

The bottom window is actually GDB.

So anything you’ve learned there is going to apply here.

But the difference is that there’s a top panel that shows your source code.

So I don’t know.

Let’s suppose for the sake of argument, I’m going to hit escape so I can go up to the top panel and kind of scroll my source code.

Let’s suppose for the sake of argument, I want to break every time I hit line 36.

time I hit line 36 okay I’m kind of scrolling I just hit escape to get into the top panel

I’m gonna hit I for interactive mode which lets me go back down to the bottom panel

and then I’ll just say B for breakpoints main.cpp line 36 and then just double check that I entered

my breakpoints correctly and then I’ll run the program again if you don’t know GDB see my other

video but notice how I started to run the program and then it immediately hit a breakpoint and then

the top pointed to that line where it broke if you don’t believe me i’ll do another breakpoint

at line let’s see main.cpp line maybe uh 32 and then another one at uh 39 well maybe i should

have done 40. yeah i should have done 40 and then 33 so that means i probably want to uh

delete that one at 32 so i’m gonna delete whichever one shows up at 32 that’s number two

and then info breakpoints again okay so now if i continue the program also by the way notice how

the top panel is showing red line numbers for my breakpoints if i hit c for continue

and it hits the same breakpoint again if i hit enter to continue one more time it’ll do that

eventually it hits a different breakpoint and notice how the source code

moves down to the appropriate breakpoint so for me personally i kind of like to just regularly you

and then go back and forth between that and my code window.

But some people really love having both their code and GDB in the same terminal

so they don’t have to go back and forth between windows.

So if that’s you, then maybe CGDB is for you.

My little doggy wants to go pee.

Okay, that’s all I have for this video.

Thank you so much for watching,

and I hope you learned a little bit of stuff and had a little bit of fun.

I’ll see you in the next video.

Hey, everybody.

Hey everybody!

Thanks for watching this video again from the bottom of my heart.

I really appreciate it.

I do hope you did learn something and have some fun.

If you could do me a please, a small little favor,

could you please subscribe and follow this channel or these videos

or whatever it is you do on the current social media website

that you’re looking at right now.

It would really mean the world to me and it’ll help make more videos

and grow this community.

So we’ll be able to do more videos, longer videos, better videos,

or just i’ll be able to keep making videos in general so please do do me a kindness and uh and

subscribe you know sometimes i’m sleeping in the middle of the night and i just wake up because i

know somebody subscribed or followed it just wakes me up and i get filled with joy that’s exactly what

happens every single time so you could do it as a nice favor to me or you could you control me if

you want to just wake me up in the middle of the night just subscribe and then i’ll i’ll just wake

up i promise that’s what will happen also uh if you look at the middle of the screen right now you

of the screen right now you should see a qr code which you can scan in order to go to the website

which i think is also named somewhere at the bottom of this video and it’ll take you to my

main website where you can just kind of like see all the videos i published and the services and

tutorials and things that i offer and all that good stuff and uh if you have a suggestion for uh

clarifications or errata or just future videos that you want to see please leave a comment or

up what’s going on you know just send me a comment whatever i also wake up for those in the middle of

the night i get i wake up in a cold sweat and i’m like it would really it really mean the world to

me i would really appreciate it so again thank you so much for watching this video and um enjoy the

cool music as as i fade into the darkness which is coming for us all

Thank you.

The post Master CGDB: Boost Your Debugging with GDB’s Curses Interface in Terminal appeared first on NeuralLantern.com.

Hey everybody! Ready to crush those pesky bugs in your C++ and assembly programs? In this video, we’re diving deep into the GNU Debugger (GDB) – the ultimate tool for tracking down crashes, inspecting variables, and mastering your code. From setting up debug symbols to navigating call stacks, setting breakpoints, and even debugging assembly registers, this fun and relatable guide has you covered. Whether you’re a beginner coder or a seasoned dev, you’ll learn practical tips to level up your debugging game. We’ll also tackle null pointers, create GDB scripts, and explore why your program might be misbehaving. Stick around for a few laughs and some serious skills! Don’t forget to subscribe, hit that like button, and check out my website for more coding tutorials. Let’s debug like pros together!

Introduction to GNU Debugger 00:00:00
What is a Debugger 00:00:20
Debug Symbols Explanation 00:02:08
Compiling with Debug Symbols 00:03:13
File Size Comparison 00:05:30
Installing and Launching GDB 00:06:21
GDB Console Basics 00:06:55
Attaching GDB to Program 00:08:12
Running Program in GDB 00:09:09
Handling Program Crash 00:13:02
Understanding Call Stack 00:14:05
Navigating Call Stack 00:18:13
Inspecting Variables 00:19:08
Null Pointer Issues 00:21:25
Using GDB Script 00:25:10
Setting Breakpoints 00:27:04
Managing Breakpoints 00:28:37
Continuing Execution 00:30:41
Debugging Assembly 00:33:24
Global Variables in Assembly 00:35:43
Advanced GDB Commands 00:38:31
Conclusion and Call to Action 00:40:22

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social

Please help support us!

• Subscribing + Sharing on Social Media
• Leaving a comment or suggestion
• Subscribing to our Blog
• Watching the main “pinned” video of this channel for offers and extras

Hey everybody! In this video I’m going to show you how to use the GNU Debugger to

debug your C++ and assembly programs.

You can also use it for C and some other stuff but we’re just going to focus on

C++ and assembly. What is the GNU Debugger and what is a debugger in the

first place? So for starters the GNU Debugger it’s like it’s called GDB and

the db you can imagine that stands for debugger something like that and the g stands for gnu i

personally don’t know how to uh pronounce gnu so i just say gnu because it it feels more fun to do

it that way it’s more interesting i think probably some people just say new but i don’t like that

because the gdb debugger is really old and robust and powerful it’s not a new tool it’s it’s an old

new debugger someone’s always going to ask what was the old debugger and then I say this is the

old debugger the new debugger is the old debugger anyway so we’re going to use the GNU debugger

if you haven’t yet watched my video on caveman debugging you probably want to watch that first

just for like some basics of you know why you might want to look at information in your program

but for now we’ll just assume that you already know what’s going on with just like why you would

know how to make make files see my other videos but here i just have a basic make file all it’s

really going to do is just sort of compile a very simple program and add debug symbols into it so

let’s double check that i’m actually doing that here yeah there we go okay so the first thing

that i should probably show you is uh we are compiling a c plus plus source module so i’ve

actually using c but i i have that left over in there anyway and then we’re assembling something

in yasm we’re linking with g plus plus because we want to have a hybrid program and we’ve got

all these flags here those are just variables and so uh so now before i can debug with gdb

i’ve got to talk about something called debug symbols what are debug symbols imagine just a

bunch of extra information explaining all of the design and variables and everything inside of your

about your code stuffed directly into the executable.

So imagine, you know, when we compile a C++ source module

into an object file, usually that’s just, you know,

assembly at that point.

But when we add debug symbols, we’ll have a bunch of information

that can help the debugger figure out where we are in the program,

what the variables look like, you know,

a bunch of extra information to help the debugger pretty much.

The assembler will put debug symbols into the object code

symbols into the object code that you generate the compilers will do that the linker will do that

and so it’s important to understand if you don’t generate debug symbols when you’re compiling and

linking your code then your debugger won’t actually be able to do anything it won’t understand what’s

going on you can debug it but like you’re not going to see anything that’s very uh that’s useful

so let me show you real fast i’m going to do make clean and then i’m going to say make build

that I do not have debug symbols.

All right, okay, if you don’t know how to compile and link from the command line, see

my other videos, but for now it looks like we’re not generating debug symbols.

So if I list the contents of my directory here, just note the size is real fast.

I have an assembly module here that I’m calling ASI.asm, ASI for assembly, and then we’re

assembling it down to an object file.

Notice how it’s just 656 bytes, very small.

plus plus module that I’m creating here is compiling to an object file that is

about four and a half kilobytes so you know not too big the final executable is

called main and it’s about 17 kilobytes so this is without debug symbols when

you’re compiling something on your own you need to add extra switches to enable

debug symbols so you can see here in this make file that I’ve made and again if

you don’t know how to make a make file or compile or link or anything see my

But for now, I’m just going to assume you kind of know your way around to makefile,

or at least you can kind of infer what’s going on.

So I’ve commented out a different version of this variable for the flags of my C++ compiler.

If I uncomment this and then comment out the other one,

you’ll notice the only real difference is this part right here, dash G dwarf 2.

Usually in C++ compilation, it’ll just be dash G to generate debug symbols,

and then the symbol format will default to a format called dwarf2 so I don’t know for these

tutorials I like to just specify the full format but you can just say dash g in your c++ compiler

and linker we do the same thing for the linker down here so I’m going to uncomment this

and comment that and the only difference is just g dwarf2 so I’m just telling my linker that I also

want debug symbols in there too then we do the same thing for the assembler so I’m going to

So I’m going to uncomment that and comment this other one.

And the only difference is that in the assembler,

we kind of have to specify it a little bit differently.

Instead of G dwarf dash two,

it’s just G dwarf two as just one string.

And I think with Yasm, you have to specify the debug symbol format.

So just keep that in mind.

So now I’ve turned on all the debug symbols.

I’m going to do real fast, make clean and make build one more time.

And then if I list everything,

list everything let me just double check that it’s building the symbols now right okay good

notice that the files are bigger so this asio um file is now 1.8 kilobytes instead of you know

half a kilobyte the main.o object file is now 36 kilobytes instead of only 4.5 and the executable

main is 36 kilobytes instead of just 17. so you can feel it already right like there’s a bunch

extra information sitting inside the object files and the binary which allows us to debug our program

okay so now that we’ve generated debug symbols in our program we can actually think about starting

to use gdb so gdb is a program just gdb by the command line if you don’t have it in your system

already you can go sudo apt install gdb or depending on what system you’re on maybe a or

or whatever your package management program is,

but we just need to install GDB.

On Ubuntu and Debian, I think,

there is a meta package called build essential,

which will give you a bunch of compilation tools

and make file stuff and whatever.

So I’m just going to assume at this point

you already have GDB on your system.

To launch GDB and go into its console,

just type GDB by itself.

So now we’re inside of the GDB console or terminal.

console or terminal. We’re no longer inside of a bash terminal. We can’t type normal commands.

Let me show you real fast. Here’s the first command you want to learn on GDB. It’s called

quit. Never quit. Never surrender. So, you know, normally if you’re at the command line,

you can do something like cat, etc. OS release just to see what operating system you’re using.

So you can see for this virtual machine that I’m using right now, I’ve got like Ubuntu 22 on there.

If we go inside of GDB, we can’t use regular bash commands anymore or regular operating

system commands.

We can’t say cat, et cetera, OS release because we can now only use GDB commands.

We’re inside of GDB already.

Notice how it says undefined catch command.

I don’t know what you’re talking about, dude.

Okay.

So remember we do a Q or quit to get out.

You can actually just type Q.

A lot of commands that I’m going to be talking about.

going to be talking about you can abbreviate them with one or two or three letters and it totally

works just for speed so now that we know how to enter gdb and now that we also know that we have

already compiled our program with debug symbols we can attach gdb to our program i mean what’s the

whole point of a debugger we most of the time we will just have our debugger attached to our program

and launch it or i guess launch it while it’s attached you can also attach to a running program

but we’re going to launch a program and stay attached to it.

And then we can sort of catch crashes and see what’s going on.

Or we could also tell the debugger to stop the program at certain points in time,

like when we hit a certain line number or when a variable changes or something like that.

And then we can look around.

We can look at all the variables, look at the state of the program,

even change things if we wanted to.

We can look at all the registers if you’re coding in assembly.

So it’s pretty useful.

Anyway, I’m going to go gdb and the next command we’re going to learn is file, which just tells

gdb to attach to a program so that we can run it.

So, you know, the name of our program here that we compiled is just called main.

And so if I type file main, then gdb should load up that file and try to parse its debug

symbols so it can begin debugging for you.

Notice how it says reading symbols from main.

you know if we did a typo or we had something with no debug symbols it will give us some sort

of an error message so for now i’m just going to quit and then go back in just to make sure that

it’s all clean and we’re going to do file main now it attaches once it’s attached that’s not i guess

it’s not technically attached because the program’s not running but once it has loaded the debug

symbols for that program we can run the program with the run command in gdb also kind of interesting

If you have debug symbols that are generated separately from your executable,

you could tell GDB to load the symbols file and then run your program.

That happens a lot in Linux where people release the non-debug friendly version of a program

and then they’ll release the debug symbols separately if you’re interested.

Anyway, so I’m going to type run and it’ll run the program.

Notice how GDB kind of tells us that it’s starting up now.

here’s like a thread debugger that’s being enabled and it says we’re using this library to do it and

then it says hello you know here’s the hello message so the program is actually running that’s

not my name i wish it was and then it prints the final result and then gdb says your program exited

normally on newer versions of gdb there’s a setting i think by default where it’ll ask you

if you want to start a debug daemon a debug info daemon or something yes or no you can usually just

without actually having to type n.

It’s a little bit faster.

So the whole program ran and finished.

If I type run again, it does the same thing.

In GDB, if you hit enter without typing anything,

it ends up repeating the previous command.

So I’m not going to type run.

If I just hit enter, are you serious?

GDB made me into a liar.

Well, most of the commands will repeat if you hit enter.

I guess not the run command.

So I’ll type run again.

And okay, I mean, the program is pretty good, right?

So if you watched my…

It’s not pretty good.

watched my it’s not pretty good it’s a nonsense program I mean it it doesn’t crash is what I’m

saying if you watched my previous video which you should on caveman debugging I had this uh you know

nonsense portion of code that just sort of updated a variable and we pretended that we were confused

and we didn’t understand what was happening and uh we used gdb to debug it so what I’m going to do

either let’s say we’ll start off with throwing an exception and then we’ll try to use a no pointer

and then we’ll see a crash and then after that I’m going to start using breakpoints where we can stop

automatically inside of our program to print the state of the program print the variables

and then I’m going to do that first in C++ and then hopefully I’ll remember to do that in

assembly right after it’s basically the same thing only with assembly you don’t really have

you know a bunch of variables everywhere you just kind of have registers and maybe some globals

globals but it’s going to be the same deal okay so let’s pretend that uh we are gonna have a crash

okay so this program just kind of runs later on we’ll figure out why the result is wrong we’ll

just pretend that it’s wrong but for now we’ll just say how about we uncomment this line right

here and what will happen is when we’re running the main loop at some point in the loop we get

When F gets called, the input will be looked at here.

And if the input is more than one,

which is definitely gonna happen like right away,

then we’ll call on the G function.

Then the G function will just throw an exception.

We’ll just pretend that something really bad happened.

You crashed or you actually did throw

and you didn’t catch your throw,

or maybe the system threw something at you

or another library threw something at you

and you didn’t catch it.

So just basically a program crash.

Let me run this real fast.

So make run just to show you that the program crashes.

Make run at this point is the same thing as just kind of executing the program.

But you can see that it says terminate called after throwing an instance of runtime error.

And then there’s the message, oh my gosh, and then aborted core dumped.

That’s not good.

So now let’s try to understand why.

Why did that crash?

Pretend you don’t know that it happened in G. You know, you’re trying to investigate.

So we could type GDB and then we could type a file to load the debug symbols, but it’s a little bit faster just to type GDB main and just sort of name the file that you want to load right away.

So if I do that, notice how it automatically tries to load the debug symbols from main.

Then I can just type run and then the program tries to run and notice how it actually catches the crash.

If you look down here, terminate called after throwing an instance of runtime error.

throwing an instance of runtime error so that’s what the program thinks is going on but then the

program is trying to terminate but then down here gdb is like wait wait wait i just caught you know

a termination uh getting invoked here and you can see this is sort of system code like we did not

create this source file p thread kill we didn’t write that that’s the standard library and there’s

a function here called p thread kill implementation with those you know fun c underscore prefixes

prefixes everywhere and so this is like some sort of a c source file and we don’t have that file on

the system so we can’t really debug that file lucky for you most of these standard libraries

work all the time so you don’t really need to debug them you need to debug your code instead

of the standard library code so the question really is how did i get here how did i get to

this crash so the next command we’ll learn in gdb is just the where command the where command will

I’m going to release a video in the future that kind of explains call stacks, but basically

imagine a abstract data type, a data structure called a stack. And every time you want to add

data to the stack, it just sort of stacks up on top of the last piece of data. So like if I add

something, let’s say I want to add the number five, then I would just add the number five on top of

the stack, right? If I wanted to add the number 11, then I would just add the number 11 onto the

off of the stack and the stack is a really good data structure to uh sort of give you a trail of

breadcrumbs to know where you got where did you come from so we call this the call stack because

what’s happening is every single time you call a function then the new scope and then you know the

new function that you’re invoking um it has something called a call frame full of information

current address is and all that stuff.

And we’ll just call that chunk of data that belongs to one instance of a function call.

We’ll just call that a call frame.

And so if you’re stacking call frames one on top of the other,

then we call that whole entire thing the call stack.

And this is what allows us to use recursion and all these complicated call graphs and everything.

It’s really simple, but it’s really powerful.

So you’re looking at the call stack.

Each one of these lines is the call frame or is a call frame.

And so for example, if you just look at number zero here, you’re looking at call frame zero,

which is the closest frame to wherever the crash occurred, which is if you look at it,

that’s exactly what we were looking at when we saw that original message, right? Call frame zero.

So that’s not really useful. You want to go down to higher numbered call frames or I guess

physically lowered number call frames and just kind of scan it until you find some code that

raise no abort no none of this stuff is ours live standard c plus plus no the first frame that

contains code that is ours is call frame number nine or i guess like nine away from our current

position so i guess find the physically highest call frame that is your code or the lowest numbered

call frame that is your code and it’s telling us right here all right we uh we actually seem to

So if I go to 65, right there, it tells you exactly where the crash happened.

If you’re still trying to figure out, well, how did I get to that crash?

I don’t know how that actually happened.

Just keep looking down further in the call frames.

The next one, call frame 10, says, well, we were inside of function f with input equals

three at main.cpb line 46.

So if I just go to 46, I can get another clue.

I can go, all right, so for some reason we called g.

Imagine again, this program is much more complicated.

And then if we’re still confused, we just look down at another one and it’s like, well, this all this whole mess started at CPP main dot CPP line 28.

So if we look at line 28, it’s like, well, we were inside of this loop and we we called the F function and then the F function called the G function.

And then G just kind of did a throw. So that gives us a lot of information.

All right. Next thing we can do is we can sort of move up and down the call stack, because right now we’re sitting at call frame zero, which is just the system code.

which is just the system code, but maybe we don’t understand why the throw actually happened at,

let’s say, line 65, right? So we can use up to go up in the call stack to a different call frame.

So if I hit up, notice how it mentions that we’re now in frame number one instead of zero.

And if I do up again, we’re now in frame two, which is a little bit closer. We can use the

trick finally where we hit the enter key instead of repeating the command. So I’m just going to

and hit enter a couple times until we eventually get to our code,

which I think was supposed to be at frame nine.

So I’m just going to hit it a bunch of times until we get to frame nine.

Now we’re looking sort of back in time at that point

because all these other frames actually did get invoked,

but we don’t really care about what was going on inside of them

because they probably did their job correctly.

We’re looking at our code, so we’re going back in time

right when we were doing this throw.

Oh no, we threw. Why did we throw?

well there’s another command in gdb called info locals

okay the info locals uh there’s there’s really not much to this maybe maybe let me do this again

a equals five and uh then i’ll just say a plus plus just so that we have a local variable

i forgot that gdb doesn’t consider the incoming arguments as locals so there was nothing there

real fast uh gdp oh let’s do make build and then gdp main and then run and then we have a throw

and then i say where and then i go up up up up to a frame you can also use the keyword down if you

go too far if you want to go you know back down in the call stack but i’m just going to use up

okay so now we have it here now finally i think i can do info locals just to see the local variables

notice how the a variable is there now because I just added a local variable a a moment ago

you can also print things directly you can say print the input incoming variable if you’re in

assembly you can also print registers you can say info registers like that and you’ll get a nice

print out of all the registers you could print individual registers you can say let’s print

register r12 you can print register r12 as binary by saying I think it’s p slash t

or print slash t yeah we can probably just do print slash t also

t stands for two because they’re it’s a base two number system

does that mean there’s a p slash h or a p slash f for 15 or 16 s for 16 i don’t know i haven’t

tried that is it going to work hang on p slash s bar 12 it’s not going to work nope didn’t work

i think it thinks it’s a character point or something but anyway so we can print a lot of

So we can print a lot of stuff.

And like I said before, we can go up and down the call stack.

So I can go down a couple times and then go back up again.

And now we can assume that we’ve kind of debugged, you know, where the source of the error was.

So I’m going to comment that call out to G and run the program again one more time with a different error.

So I’ve commented this code out from before, but just imagine now that we’re going to use some pointers.

We’re going to start off with a pointer called P.

a pointer called p we’re going to set it to null at the beginning and then we’re going to just

kind of allocate it and then we’re going to set you know a value and then we’re going to dereference

it and dereferencing a pointer just kind of sets the first value in an array you can do that and

then we’re going to deallocate the pointer and then how about right after that we do something

really really naughty we say p at some index is equal to a five this should be this should be a

a program crash because we deallocated p already at that point we would be dealing with junk data

if we tried to dereference p but to make it even more clear that it’s naughty we’ll set it to a no

pointer and then we’ll try to actually use it so let me let me just restart the program real fast

i’m gonna do quit yes and then we’ll do make a debug just so you know my make debug is just a

Let’s see, where’s that? Where’s that? Where’s that? Do I not have a debug shortcut yet?

Oh dear. I need to add that before this video is over. You know what? I’ll add it right now.

We’ll do this run and we’ll say debug, make debug, and it needs to build first. And then I’ll say

debugging the program. And then we will do the GDB binary and give it an argument of

the executable and then later we can we can upgrade this to take a little script of commands

because the commands are going to start getting out of control so now if i do make debug if i

didn’t screw it up now it at least goes in there and i’ll do run and then we have a seg fault and

notice how it tells us right away hey you have a seg fault right here you’re accessing invalid

memory let’s do info locals just to see what’s up oh the p is actually a zero that’s a null pointer

explicitly oh whoops you know oh what have I done but it’s a really good idea to set your

pointers to null after you deallocate because if you don’t you might end up with undefined

behavior where sometimes the program doesn’t crash while you’re overriding junk data or reading junk

data but sometimes it does and you’re not really sure like why does it work sometimes and why does

it not work sometimes so let me comment this out and see if it’ll crash uh let’s just let’s just

make debug and then i’ll do run and then if we do info locals oh yeah okay so this is uh

it did seg fault so that’s good uh if we were unlucky then the program wouldn’t have crashed

it would have just started behaving strangely and um when we print out the value of p notice how it

looks like a pointer still like if we were to debug the program and print the pointer value

then it doesn’t really it looks the same it looks the same after we deallocated it right so that

this is called a dangling pointer meaning you deallocated the pointer but you forgot to set

it to null afterwards so then later when you’re trying to debug the program it’s a little confusing

because you’re like that looks like a regular pointer what did i do wrong so um it’s really

good practice to set your pointers to null right after you deallocate them that way when you’re

debugging later because something crashed instead of seeing a memory location on p you’ll see

On P, you’ll see something that looks definitely like a null pointer and print P.

Then it’s way easier to realize, oh, whoops, I was trying to use a dead pointer, a pointer that I deallocated.

Hopefully that makes sense so far.

Next thing I want to do is a small upgrade.

I can’t remember if it’s dash X or dash EX.

I think it’s dash X.

But you can write a little script.

I have a little script here called Good Doggo.

called good doggo you can just make any file name it anything you want i’m so i’m just naming it

good doggo.txt because my dog’s taking a little nap behind me as usual um but you could name this

gdb.txt or whatever it is you want so you can put inside of this script file any command that you

want gdb to execute when it launches so let’s just comment this stuff out real fast and i’ll do

I’ll just do run maybe for starters.

Because whenever I’ve been launching for debug,

I launch with GDB and then I type run manually, right?

So I want to save a little time.

So good doggo is the name of the script.

So when I invoke GDB, I am going to,

where is it right there?

Okay, it’s GDB.

And then I’m going to go dot, I think it’s X.

And then I’m going to say good doggo.txt.

If it’s not dash x, then it’s dash ex.

One of those executes the command that comes after,

and one of those executes the command script that comes after.

Let me just double check that this actually is going to work.

So make debug.

All right, okay, so it was dash x.

Dash x specifies a script that will be run.

Dash ex just specifies a command that you can put right in there.

Like I could have said dash ex run, and it would have ran right away.

But the script is more convenient, right?

Because we can save typing.

So notice how it ran right away and then there’s a seg fault.

Okay, so now let’s go a little bit deeper.

Let’s change this to false again now that we understand like null pointers and all that

stuff.

So we can just basically deal a little bit more with only what the main loop is doing.

Suppose we just still don’t really understand what the loop is doing, why our answer is

you know, good or bad.

So maybe I want to do a breakpoint at the top of that for loop.

loop gets to the top of its iteration, I want the program to pause so I can look around.

So I’m going to set up a breakpoint on line 22. And here’s how you set up breakpoints

in GDB. I’m going to go ahead and maybe do the terminal for now. And then I’ll stick that into

the script next. I will not remember that it’s line 22. That’s okay. I’m going to do quit.

And I’m going to do make build. Then I’m going to go GDB main just to jump in there.

and then i’m going to say break or just the letter b just to make a break point you type the name of

the source code file that you want to break in and then a colon and then the line number where

you want it to break so i think i think it actually was line 22 oh i can see it and then

maybe i want to have it break at line i don’t know maybe right here line 25 right before it increases

And then so I’m going to do an up arrow to just repeat the command so I can edit it real fast.

And then I’ll break again at line 28 and then maybe 30 and then 32.

So I’m going to go 28, 30 and 32.

30 and I’m just making up break points.

I just want to inspect the program and then maybe I’ll break at line 36 so I can see what the final answer is.

So I just have a bunch of break points set up.

Remember when the program is running now under GDB, every time it hits one of those lines,

every time it hits one of those lines the program will pause and i’ll have a chance to look around

at the variables and things so i’m not sure if i’ve set up the breakpoints correctly i can say

info breakpoints and it’ll show me all of my breakpoints notice how you can enable them and

disable them so let’s say for the sake of argument i want to disable the breakpoint at line 30 because

maybe i don’t really need that right now but i kind of want to keep it in the system for later

disable four because it’s number four.

It’s breakpoint number four.

So I can say disable four.

Then if I do info breakpoints again,

notice how there’s a little N on there,

meaning breakpoint four is disabled.

So I could re-enable it with a four

and then go info breakpoints again.

So now they’re all enabled.

I am going to maybe copy this into the script file real fast

so I don’t have to keep typing this over and over and over again.

Imagine if every single time you changed your program and recompiled it you had to type all of the breakpoints from scratch

That’s why I want you to use this little breakpoint script

So we’re going to do B to break at main.cpp line 22 and 25 and

28 and

30 and 32. I should have copy pasted the three dang it 36

And after we’re done setting up all the breakpoints

show me the breakpoints just so I can have a visual reminder. Keep in mind if you change too

much of your source code then you’re probably going to have to update these lines and that’s

okay but it’s a good idea to just at least you know kind of look at them a little bit so that’s

why I’m saying info breakpoints. And so then remember again the makefile all it’s doing when

I type make debug is it’s just launching this command right here it’s just saying gdb with the

with my gdb script so let me quit to get out of this and then i’m going to say clear and make

debug and notice how it did all that stuff for me it added the breakpoints it showed me the break

points and then it ran the program like i told it to and then it already broke on a breakpoint it

already break it break breakened it’s broken i don’t know i don’t think it’s broken uh so we’re

So we’re on breakpoint number one on line 22.

And here’s the for loop.

I can type all of my inspection stuff.

I can say info locals.

I can say print I, I can say print A, I can print whatever I want.

And then when I’m done kind of looking around and inspecting things,

I want to continue the program.

I don’t want to just stop it here.

So I’m just going to use the command continue.

And it goes right to the next breakpoint.

If I want to, you know, continue again, I can hit C.

continue again i can hit c or i can just hit enter you know to just sort of keep continuing as i

inspect and print things let’s see when can i get to break point number one is that what’s going on

here hang on a second what is break point number one oh i know what to do info break points

break point number one is that main.cpp line 22 is that actually going to get hit oh it’s

having issues here with my GUI. Okay. Line 22. Okay. So it’s not really hitting that anymore.

I guess it’s not going to think that it hits the top of the forelip. Okay. So I guess breakpoint

two is where we’re always going to be hitting. So let’s just suppose that I’m continuing until

I hit breakpoint number two. Suppose that the next 10 times I see breakpoint two, I don’t

actually want to stop and break on it. I just want to skip the next 10 iterations for some reason.

some reason you can say continue 10 and it’ll skip the next 10 times that it hits the number two

notice how if i hit continue a bunch of times we’re not really seeing the break point number

two anymore we’re seeing other break points and then eventually if i hit it enough times

we’ll probably see two again oh my god oh my god are we seeing it yet no

Okay, wait, are we seeing I’m freaking myself out.

Okay, so let’s continue 10 times on breakpoint three, then we’ll only see

breakpoint four, I guess.

So we can do continue 10 times on breakpoint four.

What is going on here?

Did I write this program in a weird way?

Hmm.

Well, trust me on this.

Let’s continue 100 on breakpoint three and then continue 100 on breakpoint four.

breakpoint 4. Okay, so now we’re just done with the whole entire program. I guess there must have

been a 2 there that I missed. So now we’re finally on breakpoint 6, which is when everything is

finished. Let me show you real fast that we can add more breakpoints in assembly just to prove

that we can debug assembly real fast. So if I want to debug assembly, I just have to type the name of

that source code file. If it was nested in a folder, like if you had like a complicated hierarchy of

of source code files you would just need to type the relative path but for now I’m just going to

be able to type the name of the file so assy.asm and let’s suppose that I want to break at line

16 just so I can see the registers that I set up so I’m going to do 16 and then I’m going to break

at assy.asm line 16 and then I’m going to run and that actually never gets called does it no no it

called does it no no it gets called I think I have a call up here somewhere

nope I don’t have a call okay let’s make a call this is gonna throw off all of my

C++ breakpoints so I’ll just comment them all out right now comment them all

out so I don’t have to redo them and this is a hybrid program so I’m gonna go

extern what is it extern C make a block where I name the function the reason we

name mangling so the AC symbol is going to show up as just its regular function

name rather than a bunch of extra stuff indicating the prototype so that we can

do overloading so we’re just going to disable that and then at the very top of

the program I’m just going to call it this should hopefully work let me just

do a regular make run just to make sure the whole program compiles okay now

debug script we’re gonna break on line 16 which is going to be letting us see

the registers okay so I’m gonna go make debug notice how it hit the breakpoint

in the assembly just the same as the C++ and we can print whatever we want now so

I’m just gonna say info registers and if we look carefully we can kind of see

that we modified racks REX is 15 so that’s expected RDI is 20 which is

R12 should be a giant number. Where’s R12? Right there. So you can see the state of your program at any point in time just by breaking on it.

I’m breaking on a certain line. So this is tremendously useful for debugging not just for higher level languages but also assembly.

What else can I do? Oh let’s put a global in the data section. So I’m gonna do, I don’t know, my thing or something like that and we’ll call it a byte array and I’ll just go hello.

I’ll say we have a thing one and a thing two.

Something like that.

And maybe thing two is a null terminated string,

whereas thing one is a regular thing.

We should be able to print those symbols.

If that’s not true, I’ll come back at a later time

and show you how to do it.

Anyway, so we’ll do make debug

to just kind of assemble everything again.

And we know how to do info registers.

We can print, you know, one register in particular,

print R12 if we wanted to.

History has not reached.

History has not reached 12.

Oh, I got to put R12.

Yeah, then we can get the, wait a minute, wait a minute.

Oh, I threw off the line numbers because I added the variables up here.

So now we’re going to break at 21.

Let me just fix that.

21.

We’ll do a quit.

Make debug again.

And now we’re at 21.

If I say info registers, we can see R12 is that big value.

you, but we can also print R12 directly. And we should be able to print my thing one, hopefully,

has an unknown type, oh, we have to cast it. So we can do like basic casting in GDB. So I’m going

to say this is a character pointer. Remember, all of the assembly symbols are basically pointers,

unless it’s an EQU, EQU variable. In that case, it’s more of a define. So I’m going to print

and then it says error cannot access the memory add address

what the heck did i do wrong how about that cannot access that all right i’ll come back in

another video because this wasn’t something that i prepared for just to print strings in globals

i’ll come back at some later date in the future like five years from now and i’ll just show you

how to print globals but i hope if you’re in assembly you probably don’t need to worry about

You just have globals, but the real problem for you is going to be what’s inside of your registers and so forth.

You can also deref, I think.

Let me see.

Okay, I’m going to move on from that.

So anyway, we got a script and we got a lot of basic GDB commands.

Is there anything else that I wanted to show you?

Let me just look at my notes real fast here to make sure I’m not forgetting to say anything.

make sure I’m not forgetting to say anything.

So we’re going to do debug symbols, console, quit, attach to binary,

launching the program, uncaught exception, breakpoints, info, delete,

enable, disable, run, continue, end times, info registers, printing.

Oh, we can print a register in binary.

Forgot to show that.

So we are at a breakpoint, I think.

And if we printed R12 with the regular print, we can also do P slash T to just

p slash t to just sort of print it in binary if you want to i think i might have said that already

either that or i said that like a couple days ago to some and then we can do info locals and

then print a variable and then we get the script file and then we can quit okay so i think this is

pretty much everything that i wanted to show you you now have a basic idea of what we can do inside

of gdb but keep in mind there is so much more you can do in gdb than i can fit in one video

can type help and you can see a list of other major you know areas that gdb can handle um you

can do uh let’s see i think it’s help and then like we’ve got information on aliases breakpoints

data you know whatever we can do i think help breakpoints to see more information on breakpoint

commands yeah so all of the things you can do with breakpoints is like all of these commands here

one page we have to enter to see one more page or see to see all of the results without using

paging anymore so i’m just hit c and so there’s like you know we can save trace points we can

try to catch exceptions we can enable disable break points there’s like unwinders which i’ve

never even used we can bookmark things we can you know start tracing memory we can rethrow

variables so just keep in mind gdp is incredibly powerful this video barely scratches the surface

but for a programmer who is new to debugging i think this will be very useful to you i hope it is

anyway thanks for watching this video i hope you learned a little bit of stuff and had a

little bit of fun um i will see you in the next video rest yourself and take a nap and have fun

and hug your your loved ones okay I’m out see you later hey everybody thanks

for watching this video again from the bottom of my heart I really appreciate

it I do hope you did learn something and have some fun if you could do me a

please a small little favor could you please subscribe and follow this channel

channel or these videos or whatever it is you do on the current social media

website that you’re looking at right now it would really mean the world to me

and it’ll help make more videos and grow this community so we’ll be able to do

more videos longer videos better videos or just I’ll be able to keep making

videos in general so please do do me a kindness and and subscribe you know

sometimes I’m sleeping in the middle of the night and I just wake up because I

know somebody subscribed or followed it just wakes me up and I get filled with

That’s exactly what happens every single time.

So you could do it as a nice favor to me,

or you could troll me if you want to just wake me up in the middle of the night.

Just subscribe, and then I’ll just wake up.

I promise that’s what will happen.

Also, if you look at the middle of the screen right now,

you should see a QR code, which you can scan in order to go to the website,

which I think is also named somewhere at the bottom of this video.

And it’ll take you to my main website,

where you can just kind of like see all the videos I published,

and the services and tutorials and things that I offer,

and all that good stuff.

things that I offer and all that good stuff. And, uh, if you have a suggestion for, uh, uh,

clarifications or errata, or just future videos that you want to see, please leave a comment.

Or if you just want to say, Hey, what’s up, what’s going on? You know, just send me a comment,

whatever. I also wake up for those in the middle of the night. I get, I wake up in a cold sweat

and I’m like, it would really, it really mean the world to me. I would really appreciate it. So

watching this video and enjoy the cool music as I fade into the darkness which is coming for us all.

Thank you.

The post Master GNU Debugger: Debug C++ & Assembly Programs with GDB Like a Pro appeared first on NeuralLantern.com.

Hey coders! Ever hit a wall with a program that just won’t work? In this video, I’m spilling the beans on caveman debugging—a super simple, no-fuss way to hunt down bugs in your C++ code (or any language, from assembly to Python)! No need to wrestle with complex debuggers; this method is all about using print statements to trace what your code is doing, step by step.

I’ll show you a real C++ program where things go wrong (think integer overflows and mystery crashes) and walk you through how to sprinkle in cout statements to spot the problem fast. You’ll learn how to label decision points like loops and if-statements, break down complex expressions with temporary variables, and format your debug output so it’s easy to read. Plus, I share a neat trick called short circuiting to toggle your debug prints on or off without deleting them—saving you tons of time!

Whether you’re a beginner just starting out or a pro debugging a massive codebase, caveman debugging is a lifesaver. It’s quick, it’s intuitive, and it fits my “let’s figure this out” vibe perfectly. Stick around to see how I catch a sneaky bug in a for-loop and fix it in minutes.

Why watch?

• Learn a beginner-friendly debugging technique that works in any language.
• See real code examples with clear, relatable explanations.
• Get tips to make your debug output readable and avoid hours of frustration.
• Discover how to short circuit print statements for reusable debugging.

If you’re ready to level up your coding game and squash bugs like a champ, smash that play button! Don’t forget to subscribe and hit the bell for more coding tutorials, from beginner hacks to advanced tricks. Drop a comment if you’ve ever used caveman debugging or have a bug you need help with—I read every one! Check out my next video on using a proper debugger for even more debugging goodness.

Scan the QR code on-screen or visit my website (linked below) for more tutorials, services, and coding resources. Let’s keep the coding community growing—your support means the world! #CavemanDebugging #CodingTips #DebuggingHacks

Hey everybody! In this video I’m gonna try to familiarize you with a concept

called caveman debugging. It’s just as bad as it sounds but it’s really really

really useful. So suppose for the sake of argument you’re writing a program I’m

gonna show a C++ program here but this this concept is not just for C++

debugging it’s also for assembly and any other kind of language that you can come

other kind of language that you can come up with but suppose I have a program and I’m trying to

figure out why it’s not working so if you look at this program right here that I’ve kind of written

up already we have a main function here and we have like a little hello message that’s not my

name I love that name though and we have a variable a and then we just sort of do some nonsense to it

to try and compute a value for a when I say nonsense I mean literally I’m just I just made

I’m just I just made up instructions the point of this video is not to show you some advanced program

It’s just to show you that you know

This is how you can possibly debug a program that has gone awry

So you can imagine at home that this code you’re seeing right here might be your larger project your larger

Code base whatever it is that you’re doing that is not working for some reason and you’re not sure why

So, um, let me run the program real fast

It basically is just like a little for loop and then it just sort of

of you know not randomly but it just kind of increases the value of a for no reason

a bunch of times and then it calls a function that will crash later

so let me show you what happens when we try to run this program okay do do do

okay i want to go clear and make run if you don’t know how to do a make file or compile

or link or anything like that uh then go see my other videos so clear and make run

What did I do wrong?

TempResult was not declared in this scope.

Okay, well, this is now a video on reading compiler errors.

Line 59, I probably left something out.

Oh, because I just changed it.

I forgot to put it back in there.

Return tempResult, we should just return input times two.

And I’m just making this up.

It’s not really like a valid algorithm.

Okay, so we run our program.

We print the final result and we realize for some reason the final result is wrong.

result is wrong. So I don’t, I mean, I just made this up. So I don’t really know what the right

answer is. But just imagine that you are looking at some sort of an output, some sort of a final

state, maybe a crash. And you realize, oh, my program doesn’t work, but it’s too complicated

to figure out. Caveman debugging to the rescue. Caveman debugging kind of is as bad as it sounds.

It’s just really, really simple. But it’s also really useful, especially if you just want to do

on you don’t want to dive deep into a full-on debugger or do something more advanced it literally

is just printing a lot of things while your program is running i do it all the time i usually

don’t even go to a debugger unless i really get in trouble with like some huge mess um okay so

the first thing i’m going to say is in this for loop we uh you know we’re kind of like iterating

And so probably this is a good idea to announce that we’re iterating in the for loop.

So I’m just going to go Cout.

In C++, you know, we have the Cout object that we can use to stream texts to standard output,

which usually goes to the terminal.

So use whatever construct you’re using for your particular language.

So we’re going to do Cout.

And I should say also, if you’re programming in assembly,

if you are programming in assembly,

it’s a little bit more complicated than just writing a Cout.

little bit more complicated than just writing a C out you probably have to have some pre-computed

messages and then you can use a library to print a number to the screen or use printf to print stuff

to the screen but you can do it just takes a little bit longer so anyway conceptually I’m

just going to say this is the first iteration of my loop so I’m going to sort of announce it I’m

going to say main and then I’m going to call it main four or how about primary four or first four

but I want to try to label the for loop.

And maybe instead of leaving those parentheses blank,

I could say iteration number i right there,

or maybe I could do iteration i.

That would be pretty good.

Then I just have to replace the i with the actual variable i

so that the i keeps increasing.

So I’m just going to like do another stream operator here

and I’m going to say i.

Then I’ll print a new line.

we’ve got, you know, one iteration of our loop.

Maybe I should also print what is the current value of A

because the point of this, you know, weird nonsense code

is we’re coming up with a value for A, right?

So I should just print what A is at the top of each iteration of the for loop.

So I’m going to say A is equal to, and then do another A at the end of it.

And then maybe at the bottom of the for loop,

when the for loop is actually ending one of its iterations,

I can just say we’re at the bottom of the iteration so maybe I’ll put to end

iteration and then print the final value of a and then at the top I’ll say begin

iteration at this point you might start to feel like hey aren’t you using too

many words here like why can’t I just print a bunch of numbers I mean you

could but when you’re coding you need all the brainpower you can get to not

just code but to debug coding is already hard enough without making it harder

harder for yourself than you need it to be. So, you know, I see people all the time, they’re

trying to debug their code and they just like start printing numbers. And after not very long

at all, they’re looking at the debug output and they’re just like, what did that number mean?

Where is the number I’m looking for? It’s just a bunch of numbers. It’s harder to debug when you

do it that way. Do it the nice and pretty way. It just costs you a couple of extra keystrokes to do,

you know, nice letters and new lines and things, nice words, labels. Isn’t that still a lot better

Isn’t that still a lot better than debugging for an extra six hours?

Because you can’t really understand what you’re seeing.

Anyway, let me show you what this looks like so far with just those two lines added.

Now we can kind of see, alright, alright, on iteration number 61, where I was 61, then

this was the first value of A and then after that this was the second value of A, you know,

when we were finished with the iteration.

It seems to have gone up by a certain amount.

you know it was like a negative blah blah blah 836 and then negative blah blah blah 708 so it

kind of increased in value all right that’s a little bit helpful now it’s a really good uh

place to uh print our decision points so anytime in your code where you have an if or an else or

a function call or anything where you are kind of like you know making a decision or processing your

data in some way it’s probably a good idea to announce your decisions so i could say up here i

say up here i can go maybe i’ll say uh main first four and then i’ll call it uh maybe i’ll do a

double colon there and i’ll say top if just to make it easy to read that i’m kind of like at

the first if statement um maybe i’ll even put parentheses i’ll say a is more than 20 just to

kind of like name what i’m actually doing and then i could replace the a with the actual value of a

actual value of a so i could say a like that and maybe uh when i’m reading this later i might want

to kind of actually see the variable name so i could say uh you could just like put a as a string

and then maybe its value in parentheses or something like that do a new line um and then

maybe after that top thing i’ll say uh true to indicate that we’re inside of the the if statement

the if statement and then maybe at the bottom of that if statement we’ll just say

a is now true and we’ll say like a is now you know whatever the new value of a was so just

basically we’re announcing that we decided to go into this if block and then we announce what we

ended up changing a to and also you probably anytime you see a compound expression like this

You know B time something or a plus something or just you know a big part of multiple parts of the expression any expression

That’s more than just like one variable or one number. It’s probably a good idea if you break that up into temporary variables, too

and then

Print out each variable and I know that’s a lot of stuff to read but again it beats debugging for an extra six hours

I’m gonna leave that be for now though

leave that be and

I’m just gonna continue adding comments into the rest of the code. So I’m gonna do the second if block here

So I’m going to do the second if block here.

I’m going to say we’re in the first floor.

We’re in the bottom if more than 20 true.

And then we’ll print out what is the value of a after we’re finished.

We’ll say a is now is now whatever value for a.

And then I’ll do the same thing for this function call.

Because, you know, when I call this function, it’s going to change the value somehow.

So we’re going to do cout about to a plus equals f, you know, call to f.

And then inside the arguments, I’m obviously putting i plus 3.

But because i is a variable, we could just print that.

So I’m going to do quote, quote, and then just stick the actual i in there.

And then another new line.

a finished a plus equals f and then I’ll just say you know a is now you know a you know print the

new value of a you could also say a equal equal a and then print the value whatever you want but

the point is I’m just printing everything here so now let’s go down a little bit more because

there is a function call if you look at this function call down here here’s like some nonsense

being used here’s some other like you know disabled code really what i’m doing at the

very end is i’m just taking the input that the function received and i’m just multiplying it by

two and returning it so again imagine that your code is a lot more complicated than this

maybe input times two is actually input times two divided by three and then some other function

call and then some other this and some other that and whatever so a lot of people will just kind of

stuff like a really complicated expression in one line or one assignment or one return statement

And that’s super confusing because you can’t really be sure that every part of the expression is as you thought.

So it’s a really good idea to break it all up into parts and print each part.

So you could imagine that we have like a C out here and we’ll say C out, you know, begin F.

I’ll say like begin for F and then F receives an input of input.

Do an end L.

And then I’ll make a temporary variable here.

variable here I’ll say int temp results equals input times two and then I’ll

print that f and maybe I’ll do the input again

temp result is now and then say temp result so I’m just gonna print what the

temp result actually was and I could print something about I just multiplied

thing about I just multiplied the input by two and then you know the more

complicated your expression is the more temporary variables you want to use and

just kind of print every single one of them and print you know this new

variable is the result of dividing by two this new variable is the result of

calling some other function and so forth

so then we have like a basically you know basically a pretty good idea maybe

at the end though instead of multiplying by two again you want to make it more

want to make it more consistent with your debug output so like here temp result is obviously going

to be the result that i return why would you do the expression all over again for the return part

when you could easily get it wrong why not instead just return the temp result that you made right so

then that way your output completely matches what you’re actually returning and for now i think

that’s all we need to do let me run it one more time and then you’ll see a bunch of stuff now uh

Now, we have a lot of information that we can use to trace how our program was thinking and hopefully find the problem.

But isn’t this like a little bit starting to get a little bit hard to read, right?

You can see that there are kind of blocks happening whenever we iterate.

So, you know, for me, I always try to keep in mind you need all the brainpower you can get.

Why not just format it a little bit better so it’s really easy to just quickly look at one block and see, you know,

the couts kind of like belong together so i’m just going to add one more cout in the main for loop

here just at the very bottom i’m going to go couts and l just so that i get a new line and if i run

the program again notice how it’s easier to see the blocks like oh that’s clearly one iteration

right here you know your mind just grabs onto it faster and that increases your brain power and

makes it easier to debug and read the debug output so i can go all right all right okay so

all right okay so we’re right up here oh around uh iteration um number 83 uh a was this number

and then it got increased by uh this other number and the reason that that happened is because the

function returned 172 so it basically increased it by 172 and then it ended up being that number

oh okay i think i see what went wrong oh no right in this particular program if we scroll up just a

little bit we can probably see that the integer is overflowing right the integer was getting bigger

right the integer was getting bigger and bigger and bigger here and then eventually

it jumped into the negative at some point so right here we can see oh okay when did this

number become negative suppose we didn’t want it to be negative um what was this this is like

a million this is a billion no wait wait wait this is uh no that’s a million right there so it’s like

299 million and then it overflowed oh no no it didn’t it didn’t overflow it started at 299

it started at 299 then at the bottom it was sitting at 899 million that’s kind of close to a billion

and it did jump up from 300 million to 900 million so that’s a jump up of like 600 million

oh you know it’s like kind of jumping up faster with each iteration oh and i’m using a 32-bit

signed integer which has a maximum value of around 2 billion so now i could possibly realize at this

the number is just like it became too big and I need to change my data type or I need to change

my algorithm for some reason right so you can kind of get to the bottom of things pretty quickly

so here’s another problem that people encounter when they’re using caveman debugging

basically you you add all these cout statements or print statements or whatever you’re doing in

whatever language you have and then when you’re finished you’re kind of like well I guess uh

I need to delete all of these Couts because I don’t want all this you know

Junk being printed in my program after I fix the problem or maybe you’re trying to debug a different part of your program

So then you start commenting out all the print statements or you start

You know deleting them or whatever and then whoops later on you realize maybe that part of my program

Was not actually fixed and I have to add all the Couts all over again from scratch that costs time

So that’s not fun. So here’s a trick that I like to use. It’s called a short circuit

it’s called a short circuit it’s a sort of like a beginning C++ thing or just

when you’re first learning how to use logical operators for boolean

expressions so I’m gonna do a boolean and I’m just gonna name it after what

problem I’m trying to solve so we could just call this you know main C outs or

something like that let’s I don’t know primary problem I’ll call it primary

the boolean as true because then what will happen is uh we can then short circuit all of the cout

statements we can say primary problem couts and cout like that and the way the short circuit works

works is if you have a logical and expression you can see right here we have two sides

of that statement now one’s on the left which is just the boolean and one’s on the right which is

have a logical and then you know one and zero is equal to zero true and false is equal to false so

both things have to be true for the expression to evaluate to true which means if the first thing

is false there’s no point in even looking at the second thing at all because if i if i set that to

false then the second part the c out is it doesn’t matter the whole expression is going to evaluate

to false anyway so uh the logical operator itself will just you know block out the rest of the

you know, block out the rest of the statement.

That’s called a short circuit.

So I’m going to copy the short circuiting to all of my C out statements like this.

Okay.

And do that.

And then the C out there.

And I guess I’ll leave the final result there.

And for the moment, you know, this is just a regular function.

apply the short circuiting to this other f unless I do a separate boolean but

keep in mind if this was a class and you had two different methods that you

wanted to short circuit see outs inside of at the same time you could just use a

member variable and name it after the problem you’re currently trying to solve

and then just short circuit each see out in the appropriate method with that

boolean so I guess in this regular program that doesn’t have a class I

could move the boolean into the global if I wanted to but I’m not going to right

if I wanted to, but I’m not going to right now.

And if you’re writing assembly or some simpler language

and you’re thinking, hey, I can’t short circuit an assembly

or some other language, well, you could write a function

that just takes a couple arguments.

You could write a function that takes a string to print

and maybe a number to print or just, you know,

something simple like that.

And then in the function itself that prints,

you could call it debug print if you want.

Have it look at a global variable or define

that you’ve set up at the top of the assembly module.

set up at the top of the assembly module, which you can just turn on and off,

like just do a data byte and set it to a zero or set it to a one.

And then the function debug print will just look at that variable to decide

whether or not it’s going to actually print or not.

So, you know, it’s a little more complicated in assembly,

but you can do it basically the same concept.

Let’s run this again just to make sure it still works.

Okay, so it still works.

So now suppose I want to turn off all the Cout statements.

If I just change the true to false,

the true to false notice how it’s all gone except for the stuff inside of f which i told you i

wasn’t going to touch but notice how easy it was to mute it and then if i want to bring it back

later i just go true to unmute it of course if you want to do a little bit more typing you can

also do if statements like if this condition is true and that condition is true then print the

debug statement so then you can have a more complicated way of muting and not muting but

I’m going to leave it as is right now.

Let’s see, what else do we got here?

I think actually at this point, this is the basic idea of caveman debugging.

Just basically print everything.

Print all of your decision points.

Use pretty labels that are really, really easy for you to understand.

Use formatting so that your brain doesn’t have to struggle to understand what you’re seeing.

If you just print a bunch of numbers, you’re going to be shooting yourself in the foot.

you’re going to be shooting yourself in the foot and use short circuiting or if statements to

selectively mute them so you can do less typing and and debugging the debugging and so forth but

yeah i think i think this is all i really wanted to show you in this particular video

i hope you feel like an expert in caveman debugging i certainly am and it you know it

kind of fits my personality a little bit i’m like what’s going on um and like i said before

debugger it’s probably a better idea but I usually don’t unless I’m in big trouble

and I have a huge mess on my hands I usually just go directly to caveman

debugging we’ll look at the same piece of code in my next video that I’m going

to publish which is going to talk about using a proper debugger so watch the

next one also but for now I hope you’ve enjoyed this video thank you for

watching I hope you learned a little bit and had a little bit of fun see you in

video

whoops what the heck

hey everybody thanks for watching this video again from the bottom of my heart

i really appreciate it i do hope you did learn something and have

some fun uh if you could do me a please a small little favor could you please

subscribe and follow this channel or these videos

or whatever it is you do on the current social media website that you’re looking

at right now it would really mean the world to me and

more videos and grow this community so we’ll be able to do more videos longer

videos better videos or just I’ll be able to keep making videos in general so

please do do me a kindness and and subscribe you know sometimes I’m

sleeping in the middle of the night and I just wake up because I know somebody

subscribed or followed it just wakes me up and I get filled with joy that’s

exactly what happens every single time so you could do it as a nice favor to me

or you could you control me if you want to just wake me up in the middle of the

and then i’ll i’ll just wake up i promise that’s what will happen also uh if you look at the middle

of the screen right now you should see a qr code which you can scan in order to go to the website

which i think is also named somewhere at the bottom of this video and it’ll take you to my

main website where you can just kind of like see all the videos i published and the services and

tutorials and things that i offer and all that good stuff and uh if you have a suggestion for

clarifications or errata or just future videos that you want to see please leave a comment or

if you just want to say hey what’s up what’s going on you know just send me a comment whatever i also

wake up for those in the middle of the night i get i wake up in a cold sweat and i’m like

it would really it really mean the world to me i would really appreciate it so again thank you so

much for watching this video and um enjoy the cool music as as i fade into the darkness which is

us all.

Thank you.

The post Caveman Debugging: Simple Trick to Debug C++ Code Like a Pro! appeared first on NeuralLantern.com.