CareerCup

Making all the constructors protected is one way to prevent people from instantiating the class without subclassing it first. Of course there have to be no factory static functions, etc. too.

Overload the operator new in the class and throw exception from there. And make the destructor protected so that the object can't be allocated in stack.
If there is a derived class from the above base class then it will redefine the operator new so that the base class new will not be called.
With this case we can't make the object of base class .. the only thing is the compiler will not give any error but at runtime if somebody try to make object of that exception will be thrown.

We can make a class as a abstract without pure virtual function by making constructor and virtual destructor as protected.
Example Code:

#include <iostream>
using namespace std;
class cBaseClass
{
public:
virtual void Print();
protected:
cBaseClass(){cout<<"cBaseClass Constructor"<<endl;};
virtual ~cBaseClass(){cout<<"cBaseClass Destructor\n"<<endl;};

};
void cBaseClass::Print()
{
cout << "cBaseClass Print" << endl;
}
class cDerivedClass:public cBaseClass
{
public:
cDerivedClass(){cout<<"cDerivedClass Constructor\n";};
~cDerivedClass(){cout<<"cDerivedClass Destructor\n";};
void Print();

};

void cDerivedClass::Print()
{
cout << "cDerivedClass Print" <<endl;
}

int main() {
//abstract abc; //If you Try to create an object compiler reports an error message
cBaseClass *lObj=new cDerivedClass();
lObj->Print();
return 0;
}


Output:
cBaseClass Constructor
cDerivedClass Constructor
cDerivedClass Print

We can make the base class by protecting the constructor... this way it can not be instantiated. Now if you derive a class from it, you wont be able to instantiate it as well. To overcome this problem, we can make derived class constructor public. Now everything look fine. isn't it??

We can make the base class destructor as protected .

#include<iostream>
using namespace std;

class Base
{
      int a;
      protected:
                ~Base()
                {
                }
                void BaseClass()
                {
                   cout<<"Base Class";
                }
      public:
                             Base()
                {
                      cout<<"Base Const";
                }

};

class Der : public Base
{
      public:
             Der():Base()
             {
             }
};
int main()
{
    //Base b; //we cant create Base class object , it gives error.
    Der d;
}

We can make destructor pure virtual, there by the base class can't be instantiated , at the same time the destrutor can't be overridden..it need not be implemented in derived class and acts like an abstract class

I was going to make a retort like #define "new MyAbstractClass" screwyou_mwwwahaha_syntax_error, but it doesn't look like there's a way for a macro to do a search and replace on two words at once. Which makes sense, because macros parse things on a token-by-token basis. And it's also possible someone would instantiate the class without using new.

use abstract keyword to make a abstract class.
Eg:
class Test abstract
{

}
Class Test will be an abstract class.