Virtual Functions in C++

Key Takeaways

hey what's up guys my name is HMO and welcome back to my syphilis gloss series today I'm going to be talking about virtual functions in c++ over the last two episodes we've been talking about classes and object-oriented programming and inheritance and all that stuff and virtual functions are really really important to that whole concept virtual functions allow up to override methods in subclasses so for example let's say we've got two classes a and B B is derived from K many would be the subclass of a if we create a method in the a class and marketers virtual we have the option of overriding that method in the B class to get it to do something else as always this is best explained by an example so let's take a look and we're to create two clauses here one's going to be called anti Z which is going to be our base class the only thing this empty class is going to have is a public method called get a name which is going to return a string because this is just an entity we're just going to return the word entity next we're going to create another class player which is going to be a subclass of the entity class we're going to add a little bit more of this class firstly we're going to actually store a name then I'm going to provide a constructor which allows us to specify a name and then we're going to give it a method called get name which in this case is going to return this name the name that is the member okay cool so let's take a look at how we might use this set up let's see whether we create an ASCII here and I'm going to try and print the get name from that FC then I'm going to create a player I'll call this player turn on and I'm going to print the player's name as well and I'm not going to bother deleting these objects because this program tonus anyway there's no just no use in doing that let's get at 5 to write our code and if we look at the results alright cool looks pretty good well as you've got show no printing everything seems fine however everything that we've written here so far will crumble if we decide to use a concept of polymorphism if I start referring to the player as if it was an entity that's where we run into problem so for example if I create a variable here called empty which is actually going to be assigned to T which is of course a pointer to a player type right player however now I'm just referring to it as an entity if I print this so I'll do entity get name if I run micro here you can see we get entity printing however we would have course expect player because even though we're referring to this entity as an entity pointer it is actually a player it's an instance of the player class possibly a better example is if we had a prince named function which took in an entity and then here we just called see out and see get name and I'll replace these with print name a and print name P so now we've got seemingly one function which takes in any kind of entity of course so you can see that we don't get any compile errors when we try to pass in P because P is an entity right player is an entity and all we're doing here is calling the entities get name function which we would expect to be this get name for our entity and then this get name for our player however if we run our code you consider to get entity printing twice why is that that's there's incorrect there instances happening is because if we just declare our functions normally our methods normally inside our classes then when it comes time to call a method is going to call whatever method belongs to the type and of course if we look at this print main function it takes in an entity points off meaning that when we call the get name function inside entity it's going to look at entity and just call get name that's it however we want C++ to somehow realize that hang on a minute the entity that I passed into here is actually a player so please call this get name function that is where virtual functions come in virtual functions that reduce something called dynamic dispatch which compile is typically implemented by our V table a V table is basically table which contains a mapping for all the virtual functions but our base class so that we can actually map them to the correct overwritten function at runtime in the future I'm going to do a whole in depth video on how we tabled work and all that so stick around for that if you're interested but to keep it simple all you basically need to know is that if you want to override function you have to mark the base function in the base bar as virtual let's go back to our code and I'm just simply going to add the word virtual to the front of this get name function that is in our base up in our entity class it might not seem like much but this basically tells the compiler hey generate a V table for this function so that if it's overwritten you can point to the correct function with this change let's hit f5 to run our code and look at that we've got NC and shown on printing correctly now another thing that we can do that was introduced in tables of 11 is actually marked this overridden function with the keyword override right over here this isn't required of course you can see that we just ran our code without that and it worked fine however you should still do this it goes first of all it makes it a little bit more readable since we now know this is actually an overridden function but also it just helps us a little bit with preventing bugs tutors like spelling mistakes and all that like for example five types get a name with a lowercase and you can see we get an error because there's no such function in the base but for us to override or if we try an override function that isn't marked as virtual you can see it also gives us an error so it's just something that helps us out okay so that's basically what a virtual function is virtual functions aren't free though unfortunately there are two runtime costs associated with virtual functions firstly we have the additional memory that is required in order for us to store that be table so that we can dispatch to the correct function that includes a member pointer in the actual base path that points to the V table and secondly every time we call a virtual function we have to go through that table to determine which function to actually map to which is an additional performance penalty and because of these costs some people just prefer not to use virtual functions at all honestly in my experience I've never encountered this to be so costly that that it would make any difference if I stopped using virtual functions so personally I use them all the time without any issue maybe if you are on some embedded platform which has absolutely terrible performance and every CPU slice accounts maybe then avoid virtual functions but otherwise I really can't tell you not to use them because of performance because because it's just such a minimal impact that you probably won't notice it at all hope you guys enjoyed this video on virtual functions if you have an expression comment just leave them below and I'll see you guys next time goodbye [Applause] [Music] [Music]