Things to be taken care of in defination of assignment operator

• Deep copy/shallow copy
• Guard against self assignment in the assignment operator.
• Strong exception safety in the assignment operator. (acquire new resources before deleting old)
• Call base class's assignment operator if needed.

Final Class in C++

A class in Java is said to be final class if it can't be inherited by any other class. In C++, language has no built in feature to implement this. This has to be implemented by the developer.

• By making the destructor private 
• In this case, the object can only be created in heap by some static function defined in the class. Similarly a function must be implemented for destruction of object.

• If we create object on stack, stack unwinding needs the destructor to be accessible. Hence compiler won't allow this.

• Let's look at the following code.

#include <iostream>

using namespace std;

class F
{
public:
        static F* Create()
        {
                return new F();
        }

        static void Destroy(F* ob)
        {
                delete ob;
        }

        void show()
        {
                cout<<"In F Show()"<<endl;
        }

private:
        ~F() {}
};


int main()
{
        F *f_ob ;
        f_ob = F::Create();
        f_ob->show();
        F::Destroy(f_ob);

        return 0;
}

 
• Here no class can inherit F as the destructor is private. During child class object destruction, parent class destructor can't be called. Because parent class destructor is private.

• By friend class
• In this case, the object can be created on stack. 
• Here we will need a dummy class whose destructor is private. The Final class must be a friend of this class and the Final class will inherit from dummy class.
• We can create the object of Final class. As Final class is the friend of dummy class, it will have access to it's destructor. 
• But if any class(Child) inherits Final Class, then it won't compile because destructor of temp is not accessible inside Child class.
• Let's look at the following code

#include <iostream>

using namespace std;

class Final;

class Dummy
{
private:
        ~Dummy() {}
        friend class Final;
};

class Final : public Dummy
{
public:
        Final() {}
        ~Final() {}
        void show()
        {
                cout<<"Show"<<endl;
        }
};


int main()
{
        Final ob;
        ob.show();
        return 0;
}