C ++模板和继承

Question

My C++ framework has Buttons. A Button derives from Control. So a function accepting a Control can take a Button as its argument. So far so good.

I also have List < T>. However, List < Button> doesn't derive from List < Control>, which means a function accepting a list of Controls can't take a list of Buttons as its argument. This is unfortunate.

Maybe this is a stupid question, but I don't see how can I solve this :( List < Button > should derive from List < Control > , but I don't see a way to make this happen "automatically".

Answer 1

Stroustrup has an item on this in his FAQ:

Why can't I assign a vector<Apple*> to a vector<Fruit*>

You can solve it in two ways:

• Make the List contain pointers to Control . Then accept List<Control*>
• Make your function a template. You can still use List<Button> and List<Control> then, but it's more boilerplate code, and not necassary most of the time.

Here is code for the second alternative. The first alternative is already explained by other answers:

class MyWindow {
    template<typename T>
    void doSomething(List<T> & l) {
        // do something with the list...
        if(boost::is_same<Control, T>::value) {
            // special casing Control

        } else if(boost::is_same<Button, T>::value) {
            // special casing Button

        }

    }
};

To restrict doSomething only for List<derived from Control> , some more code is needed (look for enable_if if you want to know).

Note that this kind of code (looking what type you have) is rather to avoid. You should handle such things with virtual functions. Add a function doSomething to Control, and override it in Button.

Answer 2

How about using pointers? Just have a list of list<Control*> and put whatever Control-derived objects you like into it.

Answer 3

I hate to tell you but if you're using a list of instances to Control instead of pointers to Control, your buttons will be garbage anyway (Google "object slicing"). If they're lists of pointers, then either make the list<button*> into list<control*> as others have suggested, or do a copy to a new list<control*> from the list<button*> and pass that into the function instead. Or rewrite the function as a template.

So if you previously had a function called doSomething that took a list of controls as an argument, you'd rewrite it as:

template <class TControl>
void doSomething( const std::list<TControl*>& myControls ) {
  ... whatever the function is currently doing ...
}

void doSomethingElse() {
   std::list<Button*> buttons;
   std::list<Control*> controls;
   doSomething( buttons );
   doSomething( controls );
}

Answer 4

而不是使用List <Button>，使用List <Control *>，它们指向Buttons。这样，您的函数只需要采用一种类型：List <Control *>。

Answer 5

Generally, the C++ way to write algorithms that perform on a list, sequence, ... is to provide iterators as arguments.

template < class iterator >
doSomething(iterator beg, iterator end);

This solves the List< Button* > is not derived from List< Control* >. (using a template List< T* > would too, but that's kind of making your function generic-but-not-really)

In my experience, making good templatized functions operating on iterators can be a lot of (too much...) work, but it's the "C++ way"...

If you go this route, consider using Boost.ConceptCheck . It'll make your life a lot easier.