CareerCup

make the class final

It can be done as follows:

class A
{
private:
A(){}
public:
static A* createObject(){return new A();}
};

main()
{
A* a=A::createObject();
}



This way the class is stopped from being inherited and still can be instantiated.

Define the c-or protected

Define a class with private constructors and a friend class.
Define the friend class inherited from the previous class.
Now this friend class can not be inherited but its objects can be created.
We can call constructor via its objects because it is a friend class object but
inherited class objects can not call the constructor so no inheritance possible.

a class with a private destructor cannot be inherited but its object can be made.

#include<iostream>
using namespace std;

class A
{
public:
static A ACons();
protected:
private:
A();
};


A::A()
{
cout<<"In A constrcutor"<<endl;
}

A A::ACons()
{
new A();
}

class B
{
public:
B();
private:
};

B::B()
{
cout<<"In B constrcutor"<<endl;
}


int main()
{
A a=A::ACons();
cout<<"Address of A is"<<&a<<endl;
// A b=new (A::ACons());
getchar();
return 0;
}

sale DK bose isse acha protected bana leta..farzi dimaag lagata hai...mkl

As I understand we need to make a final class(As in Java), whose object we can create , but cann't be inherited.THis can be achive using virtual inheritence .here the code

// Final class

class final;
class dummy_class  
{
      friend class final;      
      private:
              dummy_class(){};
};

class final :virtual public dummy_class
{
};

int main()
{
 final f;
 return 1;
}

So in above code we are able to create a object of final
now try to inherit it

// Final class

class final;
class dummy_class
{
friend class final;
private:
dummy_class(){};
};


class final :virtual public dummy_class
{
};
class error_class:public final
{
};

int main()
{
final f;
error_class e;
return 1;
}

So when u create a object of inherit class it will throw an error.

If constructor is private, then also can inherit it using public specifier. So DK is correct to make the constructor private.

Sorry, Constructor is protected then it can be inherited.

class NotToBeInherited;
class Base
{
friend class NotToBeInherited;
};

class NotToBeInherited : virtual Base
{

};

Now calss NotToBeInherited is not inheritable but we can construct object of this class. :)

class Base
{
private:
Base();
friend class Final;
};

//Since Final is friend of Base, it can access private Constructor.
//So it can be created on stack.
class Final : public Base
{
public:
Final();
};

class Child : public Final
{
public:
Child(); // You can't do this since it Child don't have access to Base constructor
}

best way is to declare the class as final

final class_name
{
//definition of class
}

now when you inherit it it will give error but you can create its object :-)

Create a sealed class where u can not inherit the class but can create an object for the class

Public sealed class A()
{
private int sum()
{
return a+b;
}
}

make the class as final so we can not create the object to class.

A {
protected:
A();
};

B : A {
}

B cannot be inherited!