In article <da****************************@earthlink.vsrv-
sjc.supernews.net>,
da******@earthlink.net says...
[ ... ]
First, pure virtual:
class Base1 {
public:
virtual void pure() = 0;
};
class Derived1 { }; // will not compile
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.
