Local Static in C++

Key Takeaways

hey what's up guys My Name Is AO and welcome back to my C++ series over the last couple of episodes we took a look at what the static keyword meant in certain contexts and today we're going to have a look at one other context that you might find the static keyword in and that is in a local scope so you can actually use static in a local scope to declare a variable and that has a bit of a different meaning than the other two Statics that we've looked at and the idea behind this meaning makes a lot more sense if you think about the two kind of considerations we have to make when we're declaring a variable and that is the lifetime of the variable and the scope of the variable the lifetime refers to how long that variable will actually stick around for in other words how long it will remain in our memory before it gets deleted and then the scope refers to where we can actually access that variable so of course if we declare a variable inside a function for example we can't just access it in another function because the variable we declared is going to be local to the function we declared it in so a static local variable allows us to declare a variable that has the lifetime of essentially our entire program however its scope is limited to be inside that function and this really has nothing to do with functions in particular I mean you can declare this in any scope really I'm just using function as an example it's not really just limited to being inside a function could be inside an if statement could be anywhere which is why again there's not much of a difference between static in a function scope versus static in a class scope because the lifetime is actually going to be the same the only difference is that the one in the class scope anything in the class can access it anything that has anything that is inside that class scope can access that static variable however of course if you declare one inside a function scope it's going to be local to that function instead of being local to that class let's jump in and take a look at some examples so the simplest example is going to be just to create a function and then declare some kind of static variable inside it so I'll just make static in I equals z what this means is that when I call function for the first time this variable will be initialized to zero and then on subsequent calls to functions it's not actually going to create a brand new variable really easy way to check this out is if I just print the value of I and then I increment it every time I call the function so if we didn't have static here what you would expect is that every time you call this function I gets set to zero then I gets incremented to one and then we print one to the console and in fact we can test that out by just calling function a whole bunch of times here we'll call it five times we'll hit our five to run our program and you can see that we get one printing five times because as I just explained we create a variable every single time and we set it equal to zero we then increment it to one and then we print that to the console now if we were to make this static then it's very very similar to if we had just moved this original declaration out here so if we run this code and it doesn't really matter if this has static or not in our case it's going to be the same if you want to know more about what static does in that sense you can check out the video that's linked somewhere so if I run this code you would expect I to be zero increment Ed five times and so you'll get 1 2 3 4 5 which is exactly what you get however the problem with this approach is that I can access I anywhere I could set I equal to 10 over here in between function calls and suddenly this dramatically changes what my program does so for cases where you want this kind of behavior however you do not want to give everyone access to that variable you can declare static in a local scope so let's get rid of this and move our I variable back into the function scope I'm going to stick static out the front which means that again the first time we we run this function it's going to set it equal to zero and create the variable in the first place then on subsequent times it's just going to refer to that original variable so if I run my code now you can see I get 1 2 3 4 5 and I get the exact same behavior as I did before however that I variable isn't visible in a global scope it's just local to that function now as for uses some people do like to discourage the use of this because of certain reasons that I don't fully understand because I don't really see a problem with this it definitely has its use it's one of those things where yes you can achieve the exact same behavior using other methods however that can also be said for classes you don't necessarily have to use classes at all to write a program however it does make your life easier same with this case it's one of those things that you can just do to keep your code a little bit cleaner another example might be if you had a Singleton class so a Singleton class is a class that should only have one instance in existence if I wanted to create this Singleton class without using this static local scope thing I would have to create some kind of static Singleton instance probably a pointer at this rate I'll set it here I would have to have a if I just wanted to return a normal reference I would have to have a Singleton reference returning get function which was static and returned my instance after dereferencing it of course I would then have to actually declare this instance over here Singleton Singleton as instance and we can probably set it equal to non pointer as a default and now I have the ability let's get rid of this now of course I have my Singleton class in which I can just call Singleton get and then do whatever I want with it so suppose we had a method here called hello don't really know what I'm doing just an example we could call that hello method and everything will be well you can see we've only got one instance of that class that we can use so we can kind of use it statically now this is quite a lot of code you don't necessarily have to do it this way another way to do this with our new found knowledge of this local static thing might be like this we can get rid of this entirely we can get rid of this external definition of s instance as well and then we can just expand our get function to actually create a static Singleton instance and then return that instance and there you go we get the exact same behavior you can see everything here stays the same we can run our code no problem of course the code is not actually going to do anything anything at this point but you can see it run successfully without crashing and we don't really have any problems with this at all and you can see that our code is a lot lot cleaner now of course if you didn't have the static keyword here then this Singleton since it is just created on the stack would get destroyed as soon as you hit this curly bracket and and then the function scope ends so this would be a grave error especially if you're returning it by reference if you're copying it of course you wouldn't really have a problem however since we are returning a reference to it this would would be a huge problem however by adding static where extending the lifetime of this to be essentially forever which means that every time we call get the first time it will actually construct that Singleton instance then on all subsequent times it will just return that existing instance so this is a great example of where you might want to use something like this it doesn't necessarily have to be with Singletons it can help you out a lot by replacing initialization functions where for example you might have to call a static initial where for example you might have to call a static initialization function at some point in your program to create all of your objects so that you could actually use the static get methods and stuff like that you can just kind of simplify that by using this in a lot of cases so you can see there are tons of uses for this and it's really not all that bad so feel free to use it that's my opinion let me know what you guys think of this static in a local scope thing in the comments below and I'll see you guys in the next video [Music] goodbye [Music] he