C++ final specifier

C++ final specifier

Cast all your worries on him,
because he cares for you.
1 Peter 5: 7 (Bible)
In Java, we can use final for a function to make sure that it cannot be overridden. We can also use final in Java to make sure that a class cannot be inherited. Similarly, the latest C++ standard C++ 11 added final.
Use of final specifier in C++ 11:
Sometimes you don’t want to allow derived class to override the base class’ virtual function. C++ 11 allows built-in facility to prevent overriding of virtual function using final specifier.
Consider the following example which shows use of final specifier. This program fails in compilation.
#include <iostream>
using namespace std;

class Base
{
public:
    virtual void myfun() final
    {
        cout << "myfun() in Base";
    }
};
class Derived : public Base
{
    void myfun()
    {
        cout << "myfun() in Derived\n";
    }
};

int main()
{
    Derived d;
    Base &b = d;
    b.myfun();
    return 0;
}
Output:
prog.cpp:14:10: error: virtual function ‘virtual void Derived::myfun()’
     void myfun()
          ^
prog.cpp:7:18: error: overriding final function ‘virtual void Base::myfun()’
     virtual void myfun() final
2nd use of final specifier:
final specifier in C++ 11 can also be used to prevent inheritance of class / struct. If a class or struct is marked as final then it becomes non inheritable and it cannot be used as base class/struct.
The following program shows use of final specifier to make class non inheritable:
#include <iostream>
class Base final
{
};

class Derived : public Base
{
};

int main()
{
    Derived d;
    return 0;
}
Output:
error: cannot derive from ‘final’ base ‘Base’ in derived type ‘Derived’
 class Derived : public Base

Comments

Post a Comment

Popular posts from this blog

Smart Pointers in C++ and How to Use Them

Image
  Smart Pointers in C++ and How to Use Them In this article, we will be discussing smart pointers in C++. What are Smart Pointers, why, and how to use them properly? Pointers are used for accessing the resources which are external to the program – like heap memory. So, for accessing the heap memory (if anything is created inside heap memory), pointers are used. When accessing any external resource we just use a copy of the resource. If we make any change to it, we just change it in the copied version. But, if we use a pointer to the resource, we’ll be able to change the original resource. Play Video Click here for the Complete Course! Problems with Normal Pointers Take a look at the code below. C++ #include <iostream> using namespace std;   class Rectangle { private :      int length;      int breadth; };   void fun() {      // By taking a pointer p and      // dynamically creating...
Read more

BFS Binary Search tree

// BST.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include <iostream> class BST { struct Node { int data; struct Node *leftchild; struct Node *rightchild; }*root; public: BST() { root = NULL; } void insertion(int data); // Insert operation Node* serach(int data); }; void BST::insertion(int data) { Node *tempNode = (Node*)malloc(sizeof(struct Node)); struct Node *current; struct Node *parent; tempNode->data = data; tempNode->leftchild = NULL; tempNode->rightchild = NULL; if(root == NULL) { root = tempNode; return; } else { current = root; parent = NULL; } while(1) { parent = current; if(tempNode->data > parent->data) { current = current->rightchild; if(current == NULL) { parent->rightchild = tempNode; return; } } if(tempNode->data < parent->data) { current = current->le...
Read more

Virtual Functions

Introduction            A virtual function is a member function that is declared within a base class and redefined by a derived class. To create a virtual function, precede the function's declaration in the base class with the keyword virtual. When a class containing a virtual function is inherited,the derived class redefines the virtual function to fit its own needs. In essence, virtual functions implement the "one interface, multiple methods" philosophy that underlies polymorphism. The virtual function within the base class defines the form of the interface to that function. Each redefinition of the virtual function by a derived class plements its operation as it relates specifically to the derived class. That is, the redefinition creates a specific method. // Virtual.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include <iostream> using namespace std; class base { public:...
Read more