Re: some abstract base class dont need vtbl?
petke wrote:
Runtime polymorphism isn't what im looking for. I think this other
type of inheritance is the most useful type of all. Just to make clear
what I mean. In java the keyword interface is heavily used. In c++ we
do it by abstract base classes. By publicly inheriting these kinds of
classes we only inherit the interface, and no implementation. (To
reuse any implementation it is considered better to use aggregation or
protected inheritance anyway). We use objects thru their abstract
interface and we only commit to the smallest interface we can. As in;
//Pseudo code..
Class Phil : public WorkerABI, public BeerDrinkerABI {...}
Class Joe : public WorkerABI, public BeerDrinkerABI {...}
...
If(!weekend) {
WorkerAbstarctBase aPtr1 * = new Phil();
aPtr1.work();
aPtr1 = new Joe();
aPtr1.work();
}else {
BeerDrinkerAbstarctBase aPtr1 * = GetRandomBeerDrinker();
aPtr1.drink();
}
Well that might be a bad example but I need it that to answer your
question: "How can you enforce a common interface on a family of
classes by deriving them from an empty base class"
Well any class (Joe or Phil) that want to belong to the family of
workers or beer drinkers has to publicly derive from the abstract base
WorkerABI or BeerDrinkerABI. If it didn't the above code would not
compile. That's because I use the object by an abstract base class
pointer. That is how I can enforce the interface of object of the same
family.
But this *is* runtime polymorphism and conflicts with what you wrote in
your original posting:
The abstract base class is empty as it has no variables or
functions, so it should not take any space.
For the above to work, you need to declare - usually pure - virtual
functions in the abstract base class. Or did you mean to say that these
functions don't have an implementations in the base class?
I still don't see what the problem with the vtable is. Runtime
polymorphism in C++ is usually implemented like this. How do you expect
the virtual function dispatch to work? If you want to decide at runtime
which code to execute, you need a mechanism for it. In procedural
languages such as C, you would typically switch on the type or use
handcrafted tables. Virtual functions are an automated way of doing this
that is built into OO languages, and vtables are an implementation detail.
Typically, vtables exist only once per class. With single inheritance,
the overhead per object is a single pointer to this table. Once you have
declared one virtual function and paid the price, you can add as many
virtual functions as you want without increasing the size of individual
objects. So what are you worried about? Perhaps a complete example would
help us to understand what you are trying to achieve.
--
Gerhard Menzl
#dogma int main ()
Humans may reply by replacing the thermal post part of my e-mail address
with "kapsch" and the top level domain part with "net".
The information contained in this e-mail message is privileged and
confidential and is for the exclusive use of the addressee. The person
who receives this message and who is not the addressee, one of his
employees or an agent entitled to hand it over to the addressee, is
informed that he may not use, disclose or reproduce the contents thereof.
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]