sidney@saturn.ucsc.edu (Sidney Markowitz ) (11/10/89)
aihaug@AUSTIN.LOCKHEED.COM (Daniel A Haug) writes (in comp.object): > >On a naive note, does C++ or any other C-based OO extensions support >different types of method combination? I, too, come from a Lisp background. Would someone with more C++ experience please comment on the accuracy of the following? (Note: If you don't know better, please don't assume the following is true - I'm really asking a question): My reading of the spec is that C++ has no method combination. If a derived class has a member function of the same name as a member function of a base class, only the derived class's member function is used when it is called. With multiple inheritance, if there's more than one base class with a member function of a certain name, then either the derived class has to also have a member function defined with that name, or any call to that function for an instance of that class has to be explicitly qualified by the name of one of the base classes. Using the non-C++ terminology I'm more familiar with, I would say it this way: If you have child class CH1 inheriting from parent classes P1 and P2, and V1 is an instance of CH1, then If P1 has a method foo, you can call V1.foo() and it will refer to the method defined on P1, i.e., P1::foo. If P2 also has a method foo, then V1.foo() will generate a compile-time error since it is ambiguous. However if CH1 has a method foo defined then V1.foo() will always be legal and will refer only to CH1::foo. In that case, to refer to the foo methods of the parents, you would have to say things like P1::foo(V1) or P2::foo(V1). -- sidney markowitz <sidney@saturn.ucsc.edu>
sdm@brunix (Scott Meyers) (11/11/89)
In article <44454@sgi.sgi.com> thant@horus.esd.sgi.com (Thant Tessman) writes: >Yes, you can implement generic lists and queues in C++ that don't care >what they contain, but the implementation is either not type safe, or >faked using macros. (See _Programming in C++_ by Dewhurst and Stark for >an interesting way to use macros to create generic container classes.) > >Another trick I (and probably many others) use is to inherit link-listability, >(or queueability) from a base class and then make the iterator function (e.g. >'next' or '++') a virtual and overload it to make it return the correct >type. This solution is easy if you know the things will only be in >one list at a time, and "possible" :-) if the things need to be in multiple >lists or queues at a time. Hmmm, what about using MI so that anything that will ever go on a list inherits from a class "Listable" that defines the appropriate virtual comparison operators? Then your lists would consist of pointers to objects of type Listable. It should be type-safe because only Listable objects can end up on lists, and all Listable objects have the necessary comparison operators appropriately defined. No macros needed, and having a single object on multiple lists is no problem. Am I overlooking something? Scott sdm@cs.brown.edu
dlw@odi.com (Dan Weinreb) (11/13/89)
In article <9707@saturn.ucsc.edu> sidney@saturn.ucsc.edu (Sidney Markowitz ) writes:
My reading of the spec is that C++ has no method combination.
That's right, and everything else in your posting is right as far as
my understanding goes.
Dan Weinreb Object Design, Inc. dlw@odi.comthant@horus.sgi.com (Thant Tessman) (11/14/89)
In article <20481@brunix.UUCP>, sdm@brunix (Scott Meyers) writes: > Hmmm, what about using MI so that anything that will ever go on a list > inherits from a class "Listable" that defines the appropriate virtual > comparison operators? Then your lists would consist of pointers to objects > of type Listable. It should be type-safe because only Listable objects can > end up on lists, and all Listable objects have the necessary comparison > operators appropriately defined. No macros needed, and having a single > object on multiple lists is no problem. Am I overlooking something? > > Scott > sdm@cs.brown.edu I don't know. I think what you describe is fine for doing 'listy' type things on lists. But, in my case, what I really wanted was a list of Goobers that I could do 'goobery' things with as well as 'listy' things. In that case, I needed to overload my iterator to return the correct type. This guarantees that I can't to 'goobery' things to any old list, just to lists of Goobers. Since List was a base class of Goober (I didn't really call it Goober) all the list stuff automatically worked and was type safe. And even this won't solve the problem of allowing a list where each element can be anything. (I don't even think dynamic typing is a solution. What does the program written in a dynamic typing language do when the type is wrong that you couldn't get a c++ program to do just as easily?) thant -------------------------- There are 336 dimples on the standard golf ball.