Re: What's the different betteen pure virtual function and virtual function

In article <daniel_t-0BA75B.06391803062008@earthlink.vsrv-
sjc.supernews.net>, daniel_t@earthlink.net says...

[ ... ]


Of course it will. Right now, the 'Derived' part of the name is a lie --
this isn't derived from anything; it's just an empty class, which will
compile just fine.

Even if Derived1 was derived from Base1, it would still compile:

class Derived1 : public Base1 { }; // will compile

What _won't_ compile is if you attempt to _instantiate_ an object of
this type:

Derived1 x; // will NOT compile.

A pure virtual function does _not_ imply that every derived class must
override that function. Rather, it implies that when/if an object of a
derived class is instantiated, that _some_ class must have overridden
the virtual function. In some cases, it's quite reasonable to have two
(or more) levels of derivation, including an intermediate class that
does NOT override a pure virtual function declared in the base class:

#include <iostream>

class Base2 {
public:
    virtual void pure() = 0;
};

class Derived2 : public Base2 {
public:
    virtual void pure2() = 0;
};

class DoublyDerived2 : public Derived2 {
public:
    void pure() { std::cout << "dd2_pure()\n"; }
    void pure2() { std::cout << "dd2_pure2()\n"; }
};

class DoublyDerived3 : public Derived2 {
public:
    void pure() { std::cout << "dd3_pure()\n"; }
    void pure2() { std::cout << "dd3_pure2()\n"; }
};

As it stands, this probably doesn't make a lot of sense, so let me try
to make the example a bit more concrete:

namespace database {
class generic {
public:
    virtual void open(char const *) = 0;
};

class SQL {
public:
    cursor exec_query(char const *) = 0;
};

class Oracle : public SQL {
public:
    // these two functions actually have to be implemented.
    void open(char const *db_name);
    cursor exec_query(char const *query);
};

class Postgres : public SQL {
/* like Oracle */
};

class MySQL : public SQL {
/* like Oracle */
};

class Paradox : public generic {
    void open(char const *db_name) {
        /* ... */
    }
};

}

We can never (even attempt to) create an object of the SQL class -- but
the SQL class can exist (and provide utility) without overriding the
pure-virtual function in the base class. We can create objects of the
Postgres, Oracle or MySQL classes, and we can have a SQL* point at one,
or a SQL& refer to one.

--
    Later,
    Jerry.

The universe is a figment of its own imagination.