Beautiful explanation mike! I had trouble on understanding why people would use Singletons and how static memory worked! Keep up the great work, you are INSANELY underrated! One of the best! :)
18:50 in the for loop, it would be even better to have it as for(const auto &e : m_messages) since the element is accessed only for reading and not for modifying it!
Thank you so much for this. I experimented with "what if I wanted to replace the Logger* with std::unique_ptr". What was interesting is that I had to declare "std::unique_ptr Logger::s_instance;" outside the class and then "Logger::s_instance = std::make_unique();" inside GetInstance(), returning *s_instance. However, when I removed the declaration outside the class and had "std::unique_ptr s_instance = std::make_unique();" inside the GetInstance(), it instantiated new Logger instances. In your implementation, would you have had to delete the *s_instance somewhere or is this taken care of for us because it's static?
Holy smokes, three weeks into learning C++ with only two semester of MATLAB behind me 10 years ago and I guess correctly on static, sort of as I though static_cast would be answer.
Hello Mike, that is a very nice example of it! I have two questions, I understand we need to use mutex to be thread safe specially when we add new text to the log in this case, but why we should use mutex when GetInstance return the address of the object? since static will garantee we only have one copy of it. My second question is about the destructor, I notice it is never called, is this the standard behavior of singleton?, since the object needs to keep availble anytime if needed. Thanks Mike, awesome video!
Hi Carlos, Yes, correct on part one since we have static the variable will only be initialized once, and we'll only have one address returned so no need for a mutex. As for the destructor, static variables last the duration of the program, so the destruction is never called (it's kept available after the first allocation for the lifetime of the program). We could create a helper function to destroy any allocated memory if we truly wanted to, and sometimes folks will write a 'destroy' function, or a 'restart' type of function to reallocate.
@@MikeShah Would shared_ptr be the suitable choices for the 'restart' functions? If not, what would be the recommended patterns for resoure management in the singleton pattern? Thanks.
@@_w62_Depends on what you are doing with the singleton -- in general we try to use unique_ptr, and in your restart() you could 'move' to a newly allocated pointer in 'restart'
Good explanation. One doubt since "s_instance" is created with "new" keyword. How and where to use the "delete" in this case? Also since the destructor is private will it ever be used in this class?
Once initialized it can effectively live forever an the operating system will reclaim the object. That said, you could add a member function (e.g. void DestroyInstance() or ResetSingleton()) if you wanted to reclaim the memory at some other time.
Couple of videos coming up on 'static' here: czcams.com/video/hIsE0HiP1E8/video.html and here czcams.com/video/IPCEBHWgRr8/video.html (to be released shortly) that I think will help clarify how 'static' variables in classes are shared amongst all instances of a class.
That is also fine -- there's a variety of ways to setup singletons with some subtle trade-offs. If you use a pointer, then you only allocate if you use the Singleton for example. This may or may not matter depending on the size of the object.
Hi Mike I have a doubt , if we define a class member variable, then we need to allocate the memory by declaring the same variable outside class scope. But if we have a static variable in member function of a class we need not to declare the variable out side class for memory allocation. I could not understand how memory gets allocated for it, can you please explain. You have used static variable class function in singleton class design pattern video. Please explain this.
I believe the static variables inside of functions are allocated already -- the issue with the static class member variables is they need a concrete instantiation defined somewhere in a file (so the generated .object file knows where to store them).
@@pedrolobo9835 I should probably delete the pointer, you're right. The trade-off is that. by using the pointer I don't have to allocate ever if I never use the class -- though of course I might cause a memory leak :)
@@MikeShah Hi mike thanks for the video link.. I just saw full video. I am known to behavior of static , so only thing new is "static variables are stored in binary",...Now back to the main thing, in the singleton video, What I didnt understood is that --------> you are making a static instance of the class itself, that too inside the class.. This is really confusing..
@@user-ql7pw7ld1n Constructor is private, so cannot be made. The way to get around that is to have a single 'static' (stored in the binary as you said) and you can instantiate that value at compile-time, or otherwise instantiate it in a public member function.
Understood it fully today, after learning about static objects, everything is clear now.. :)
Great!
Best explanation of Singleton ever!
Thanks Mike!!
Thank you for the kind words!
Beautiful explanation mike! I had trouble on understanding why people would use Singletons and how static memory worked! Keep up the great work, you are INSANELY underrated! One of the best! :)
Cheers, thank you for the kind words!
18:50 in the for loop, it would be even better to have it as
for(const auto &e : m_messages)
since the element is accessed only for reading and not for modifying it!
Thank you so much for this. I experimented with "what if I wanted to replace the Logger* with std::unique_ptr". What was interesting is that I had to declare "std::unique_ptr Logger::s_instance;" outside the class and then "Logger::s_instance = std::make_unique();" inside GetInstance(), returning *s_instance. However, when I removed the declaration outside the class and had "std::unique_ptr s_instance = std::make_unique();" inside the GetInstance(), it instantiated new Logger instances. In your implementation, would you have had to delete the *s_instance somewhere or is this taken care of for us because it's static?
Because it is static, it would be cleaned up on program termination :)
@@MikeShah I feel it will clean the pointer not the object of Logger() as we have used a new Logger()
Thanks!
Amazing, thank you for the wonderful and generous donation!
@@MikeShah Generous donation for generous (and thorough) coursework!
@@robertstrickland9722 more to come!
Excellent explanation!
Cheers!
Holy smokes, three weeks into learning C++ with only two semester of MATLAB behind me 10 years ago and I guess correctly on static, sort of as I though static_cast would be answer.
Hello Mike, that is a very nice example of it!
I have two questions, I understand we need to use mutex to be thread safe specially when we add new text to the log in this case, but why we should use mutex when GetInstance return the address of the object? since static will garantee we only have one copy of it. My second question is about the destructor, I notice it is never called, is this the standard behavior of singleton?, since the object needs to keep availble anytime if needed.
Thanks Mike, awesome video!
Hi Carlos,
Yes, correct on part one since we have static the variable will only be initialized once, and we'll only have one address returned so no need for a mutex. As for the destructor, static variables last the duration of the program, so the destruction is never called (it's kept available after the first allocation for the lifetime of the program). We could create a helper function to destroy any allocated memory if we truly wanted to, and sometimes folks will write a 'destroy' function, or a 'restart' type of function to reallocate.
Thanks@@MikeShah for the explanation, Your videos are awesome!!
@@carlosrnardi You are most welcome! Thank you for the kind words!
@@MikeShah Would shared_ptr be the suitable choices for the 'restart' functions? If not, what would be the recommended patterns for resoure management in the singleton pattern? Thanks.
@@_w62_Depends on what you are doing with the singleton -- in general we try to use unique_ptr, and in your restart() you could 'move' to a newly allocated pointer in 'restart'
amazing!!!
Cheers!
you are genius . 🙏
Thank you for the kind words!
Alternatively you can use "inline" to initialize static member objects inside a class, think this makes it more intuitive!
Yes! It actually makes things much more clean :)
Please do a video on proxy and skeleton design pattern
Good explanation. One doubt since "s_instance" is created with "new" keyword. How and where to use the "delete" in this case? Also since the destructor is private will it ever be used in this class?
Once initialized it can effectively live forever an the operating system will reclaim the object. That said, you could add a member function (e.g. void DestroyInstance() or ResetSingleton()) if you wanted to reclaim the memory at some other time.
I'm having a bit of trouble trying to understand how you can initialize the s_instance on a global scale even though it's a private member of a class.
Couple of videos coming up on 'static' here: czcams.com/video/hIsE0HiP1E8/video.html and here czcams.com/video/IPCEBHWgRr8/video.html (to be released shortly) that I think will help clarify how 'static' variables in classes are shared amongst all instances of a class.
Just Loving it 🙏
Cheers!
what if i like to use as below :
#include
#include
#include
using namespace std;
class Singelton
{
private:
vectormessage;
Singelton(){
cout
That is also fine -- there's a variety of ways to setup singletons with some subtle trade-offs. If you use a pointer, then you only allocate if you use the Singleton for example. This may or may not matter depending on the size of the object.
Hi Mike I have a doubt , if we define a class member variable, then we need to allocate the memory by declaring the same variable outside class scope. But if we have a static variable in member function of a class we need not to declare the variable out side class for memory allocation. I could not understand how memory gets allocated for it, can you please explain. You have used static variable class function in singleton class design pattern video. Please explain this.
I believe the static variables inside of functions are allocated already -- the issue with the static class member variables is they need a concrete instantiation defined somewhere in a file (so the generated .object file knows where to store them).
@@MikeShah Great video , thanks for your comments
@@letslearn1703 Cheers!
great video, helps a lot !
Thank you for the kind words!
Hey! Great video, but I think this code might leak memory, because I didn't see the delete operator anywhere.
How about?
static Logger& GetInstance(){
static Logger sInstance;
return sInstance;
}
@@pedrolobo9835 I should probably delete the pointer, you're right. The trade-off is that. by using the pointer I don't have to allocate ever if I never use the class -- though of course I might cause a memory leak :)
Using std::unique_ptr would be the right thing to do in an even better implementation of singleton :)
Do you have courses on udemy?
My courses are all slowly migrating to courses.mshah.io
Understood nothing... after 13:30
This video on the 'static' keyword may be useful, as that is introduced at the 13:30 mark :) czcams.com/video/hIsE0HiP1E8/video.html
@@MikeShah Hi mike thanks for the video link.. I just saw full video. I am known to behavior of static , so only thing new is "static variables are stored in binary",...Now back to the main thing, in the singleton video, What I didnt understood is that --------> you are making a static instance of the class itself, that too inside the class.. This is really confusing..
@@user-ql7pw7ld1n Constructor is private, so cannot be made. The way to get around that is to have a single 'static' (stored in the binary as you said) and you can instantiate that value at compile-time, or otherwise instantiate it in a public member function.
@@MikeShah ok...got an outline..im studying about "static instance" which is core concept of singleton ig...