virtual vs pure virtual member function

[sam_cit]

Hi Everyone,

I wanted to know as to what is the exact difference between a virtual
function and a pure virtual function?
Thanks in advance!!!

 

[Jim Langston]

Hi Everyone,

I wanted to know as to what is the exact difference between a virtual
function and a pure virtual function?
Thanks in advance!!!

class MyClass
{
public:
virtual void MyFunction() { }; // Virtual
};

class MyDerived: public MyClass
{
};

That will compile.

class MyClass2
{
public:
virtual void MyFunction() = 0; // Pure Virtual
};

class MyDerived2: pubic MyClass2
{
};

That will not compile. Anything that derives from a class with a pure
virtual must override the method as none is defined.

A method needs to be virtual so the compiler will look for a derived
override in a base class. If a method is pure virtual, a derived class must
override the method.

 

[s_amrollahi]

Hi Everyone,

I wanted to know as to what is the exact difference between a virtual
function and a pure virtual function?
Thanks in advance!!!

If you declare a virtual function in a class say for example B, you
actually say: The function may be redefined in derived classes.

class B {
public:
virtual void f() { /* ... */ }
};

You define the f() for B and you usually redefine the function in
derived class:
class D : public B {
public:
void f() {/* another defintion */ }
};
virtual function is a primary tool for polymorphic bevaviour. If you
offer no defintion for D::f(), you will use the definition of B::f(),
because as an Inheritance principle, D inherited the public members of
B. Also you can declare f() in D as a virtual function, and the
redefinition process is continued in the classes that derived form D.
pure virtual function is a kind of virtual functions with a specific
syntax:
class B {
public:
virtual void f() =0; // =0 means pure virtual
};
if a class has at least one pure virtual function, it will be abstract
class, so instance creation is impossible. B::f() says you should
implement f() in derived classes:
class D : public B {
void f() { /* ... */ }
};
If you do not implement f() in D, the D is abstract class by default,
because it inherits all the pure virtual functions of class B.
for more detailed (and of course better) description, please see the
following references:
. C++ Standard Draft: Chapter 10
. The C++ Programming Language (3rd edition) by Bjarne Stroustrup:
Chapter 12.
. Design and Evolution of C++ by Bjarne Stroustrup: Chapter under
the title of "Class Concepts Refinements"

Regards,

 

[James Kanze]

I wanted to know as to what is the exact difference between a virtual
function and a pure virtual function?

A class which contains a pure virtual function is abstract, and
cannot be instantiated. A function call using dynamic
resolution results in undefined behavior if it would resolve to
a pure virtual function, and a pure virtual function is not
automatically considered "used", and so doesn't have to be
implemented unless it is actually called (e.g. by means of a
scope resolution operator, or implicitly from the destructor of
a derived class, if it is the destructor).

Thus:

class Base
{
public:
virtual void f() ; // Must be defined...
virtual void g() = 0 ;
virtual void h() = 0 ;

Base()
{
f() ; // calls Base::f()...
g() ; // undefined behavior...
Base::h() ; // calls Base::h, which
// must be defined.
}
} ;

Note that it is not necessary to defined Base::g() unless some
derived class calls Base::g().

 

[Prashanth]

class MyClass

{
public:
virtual void MyFunction() { }; // Virtual

};

class MyDerived: public MyClass
{

};

That will compile.

class MyClass2
{
public:
virtual void MyFunction() = 0; // Pure Virtual

};

class MyDerived2: pubic MyClass2
{

};

That will not compile. Anything that derives from a class with a pure
virtual must override the method as none is defined.

No. It will compile. MyDerived2 will be an abstract class and you
cannot create an instance of it.

If a method is pure virtual, a derived class must
override the method.

Not necessarily, unless one wants to create an instance of the derived
class.

 

[red floyd]

Hi Everyone,

I wanted to know as to what is the exact difference between a virtual
function and a pure virtual function?

Your question is actually a FAQ. You can find the answer at
http://www.parashift.com/c++-faq-lite/how-to-post.html#faq-5.2

 

[anon]

No. It will compile. MyDerived2 will be an abstract class and you
cannot create an instance of it.

If it compiles for you, it means your compiler is broken. This is what I
get with gcc 4.1.2:

[zzz@cherry data_create]$ g++ jj.cpp -o jj
jj.cpp: In function ‘int main()’:
jj.cpp:13: error: cannot declare variable ‘a’ to be of abstract type
‘MyDerived2’
jj.cpp:8: note: because the following virtual functions are pure
within ‘MyDerived2’:
jj.cpp:4: note: virtual void MyClass2::MyFunction()

BTW there is a typo in the example. This is correct:

class MyClass2
{
public:
virtual void MyFunction() = 0;
};

class MyDerived2 : public MyClass2
{
};

int main()
{
MyDerived2 a;
}

Not necessarily, unless one wants to create an instance of the derived
class.

What is a point of a class, if it is not used??

 

[James Kanze]

If it compiles for you, it means your compiler is broken.

The standard requires that it compile. It compiles with every
compiler I've ever used.

This is what I
get with gcc 4.1.2:

[zzz@cherry data_create]$ g++ jj.cpp -o jj
jj.cpp: In function ?int main()?:
jj.cpp:13: error: cannot declare variable ?a? to be of abstract type
?MyDerived2?
jj.cpp:8: note: because the following virtual functions are pure
within ?MyDerived2?:
jj.cpp:4: note: virtual void MyClass2::MyFunction()

Obviously, you've added some code which is illegal.

BTW there is a typo in the example. This is correct:

class MyClass2
{
public:
virtual void MyFunction() = 0;
};

class MyDerived2 : public MyClass2
{
};

int main()
{
MyDerived2 a;

Mainly, this. That wasn't in Prashanth's example, and in fact,
he explicitly said that it wasn't legal.

}

What is a point of a class, if it is not used??

Who said you cannot use it? You cannot create an instance of it
(as a full object, at any rate). You can still use it as a base
class, for further derivation, or use it in any context that
doesn't require an instance.