包装到另一个类继承的模板类

Question

template <class CollectionItem>
class Collection
{
    void A();
    // Many other utility functions
}

class ICollection
{
   virtual void B() = 0;
}


class Base : public Collection<BaseItem>, public IBase
{
    virtual void B();
}

Is there any way of offering Collection functions via ICollection interface without wrapping all the functions in Base class? ICollection : public Collection<CollectionItem> is not an option.

Bounty Update: OK, so the original idea was to have Interface to all Collection classes. Before we continue, every CollectionItem also has Interface, let's call it ICollectionItem and ICollection only knows about ICollectionItem .

So what I did was create another template class as Interface to Collection template class - ICollection (pure virtual) accepting ICollectionItem(s) . Collection class inherits this interface.

Every Collection class (inheriting Collection<CollectionItem> class) would also inherit it's Interface Collection class. That Interface then virtual inherits ICollection<ICollectionItem> . I'll just post the code :)

Here is the code:

template <class ICollectionItem>
class ICollection
{
public:
    virtual const ICollectionItem* At(const int idx) = 0;
};

template <class CollectionItem, class ICollectionItem>
class Collection
    : public ICollection,
      public virtual ICollection<ICollectionItem>    // Weak point
{
private:
    List<CollectionItem*> fContainer;

public:
    Collection(void) {}
    virtual ~Collection() {}

    virtual const ICollectionItem* At(const int idx);  // Casting GetAt result
    virtual const TCollectionItem& GetAt(const int idx) const 

    virtual ListIterator<TCollectionItem> >* GetIterator(void) const;
    virtual ListIterator<ICollectionItem> >* Iterator(void) const;  // Weak point
}

Example usage:

class IBaseItem
{
public:
    virtual int Number() = 0;
{

class BaseItem
    : public IBaseItem
{
public:
    virtual int Number();
    void SetNumber(int value);
}

class IBase
    : public virtual ICollection<IBaseItem>
{
public:
    virtual IBaseItem* ItemByName(String name) = 0;
    virtual ~IBase() {}
}

class Base
    : public Collection<BaseItem, IBaseItem>,
      public IBase
{
public:
    BaseItem* GetItemByName(String name);
    virtual IBaseItem* ItemByName(String name);
}

Weak points:

First is at using virtual inheritance ... lots written about it, not much to talk about, or is it?

Unable to access Iterator using ICollection interface. See ListIterator function, only first one can be implemented, the second one would require some kind of new List of IBaseItem . I decided to live with that and just use for loop.

Even tho I somehow managed to get what I wanted (With wrapping and casting), I would still like to hear an second opinion. I don't like using virtual inheritance, specially in such delicate situations - using Collections for application Base creation.

Answer 1

I can not see any other solution than calling some Collection method in Base implementation of IBase virtual methods.

class Base : public Collection<BaseItem>, public IBase
{
    virtual void B()
    {
        A();
    }
}

Answer 2

You say, and I quote:

I want to call Collection functions using IBase pointer

I really don't see what is to be done here besides dynamic_cast . It does exactly what you want it to do.

void fun(IBase * base) {
  auto * coll = dynamic_cast<Collection<BaseItem>*>(base);
  if (coll) {
    coll->A();
  }
}

Your Collection class must have a virtual destructor.

You can, of course, offer a templated version, if you'd need different baseitems in different, scenarios for some reasons. This has bad code smell and I think your architecture is bad at this point, but oh well.

template <typename T> void fun(IBase * base) {
   auto * coll = dynamic_cast<Collection<T>*>(base);
   if (coll) {
     coll->A();
   }
 }

void test(IBase * p) {
   fun<BaseItem5>(p);
}

If you have some other specific scenario in mind , please edit your question to say what you mean.

Answer 3

Hmm...So you wanna to reuse the Collection class's utility functions, and you want to design a class which will implement an interface defined by IBase . As you mentioned above,"wrapping all the functions in Base class" is a way to offer Collection functions.

(1) Via inheritance,derived class has a good knowledge of Collection

    class Derived：public Collection<DerivedType>,public IBase{};

or

    template <typename T> 
    class Derived：public Collection<T>,public IBase{};

(2) Via inheritance,derived class knows little about Collection ,but through IBase

class IBase : public Collection<BaseItem>{};
class Derived：public IBase{};

By (1),If you want to call Collection functions using IBase pointer,you have to wrap the functions. By (2), any Derived instance is " a kind of " IBase which is "a kind of " Collection. So you can use IBase pointer to call Collection functions.

---

So,the key point is that the objects pointed by the IBase pointer should have the method you want to call. Wrap it or inherit it. I can not see any other solution than these two ways.

Answer 4

From your comments in another answer, it seems you want a collection of interfaces, and an implementation of this interface. The simplest I can advise you is the following:

template<typename T>
class ICollection
{
public:
    virtual iterator<T>* begin() const = 0;
};

template<typename T, typename TBase>
class Collection : public ICollection<TBase>
{
public:
    iterator_impl<T>* begin() const { return whatever; }
};

Example:

class IItem {};
class Item : public IItem {};

class Base : public Collection<Item, IItem> {};

old answer:

Is there any way of offering Collection functions via IBase interface without wrapping all the functions in Base class ?

If I understood your problem, you want to use it like this:

void myfunc() { // ... IBase* obj = ...; obj->A(); obj->B(); }

I think here is a misunderstanding here: if you want A() to be callable from an IBase , then you have to add it to Ibase declaration.

If you want to use the Collection functions on an object, then you should cast this object to a Collection , via dynamic_cast for example.

Furthermore, if you have such a funcion:

void fun(IBase* base) { /* ... */ }

you cannot cast to a Collection* , since there are no relationship between these two classes, unless you have another way to be sure base is a Collection :

void fun(IBase* base) { if(base && base->isABaseItemCollection()) { // Valid, since the real type was checked before Collection* collection = (Collection*)base; // ... } }

On a side note: you can generate bases almost automatically:

template class Base : public Collection, public U {};

typedef Base BaseCollection;

Answer 5

Edit: the idea is refined based on your example: Here is an idea:

//generic interface can be kept as it is
template <class ICollectionItem>
class ICollection
{
public:
    virtual const ICollectionItem*          At(const int idx) = 0;
};
class Empty
{
};

template <class CollectionItem , class BaseClass = Empty>
class GenericCollection
    : public BaseClass
{
public:
    const CollectionItem*               At(const int idx);  
    // At and ItemByName are standard functions for a collection
    CollectionItem*                     ItemByName(String name);
    //note that here nothing has to be declared as virtual
};

//example usage:

class IBase
    : public virtual ICollection<IBaseItem>
{
public:
    virtual IBaseItem* ItemByName(String name) = 0;
    virtual ~IBase() {}
};

class Base
    : public GenericCollection<BaseItem, IBase >
{
public:
    //nothing to be implemented here, all functions are implemented in GenericCollection and defined as virtual in IBase
    //The definition of the functions has to be the same:
};

In collection you can implement whatever and in the interface you can define what ever you want to be virtual from your collection. The only thing is that you need to have some standard in naming convention for functions.

Hope this helps, Raxvan.

Answer 6

According to comment/chat:

You have something like:

class IAnimal { /*...*/ };
class Cat : public IAnimal { /*...*/ };
class Dog : public IAnimal { /*...*/ };

class Cats
{
    std::vector<Cat*> cats;
public:
    Cat* at(size_t index) { return cats[index]; }
    /*...*/ 
};

class Dogs
{
    std::vector<Dog*> dogs;
public:
    Dog* at(size_t index) { return dogs[index]; }
    /*...*/
};

And you want to factorize some code using something like

class IAnimals
{
public:
    std::vector<IAnimals*> animals; // or getter/setter which works with IAnimals.
    /* some common factorized code */
};

// And so
class Cats : public IAnimals { /**/ };
class Dogs : public IAnimals { /**/ };

I propose, instead of creating class IAnimals , to use template functions as:

template <typename TAnimals>
void foo(TAnimals& animals)
{
    Ianimals* animal = animals.at(42);

    // ...
    animal->eat(food);
    // ...
}

You have to give compatible "interface" (names) to the type used in template.

Answer 7

Maybe you could have an operator() in IBase that would be delegated to Base?

class CollectionBase {};
template <class Item> class Collection: public CollectionBase {};

class IBase
{
public:
     virtual CollectionBase* operator()() = 0;
};

class Base : public Collection<BaseItem>, public IBase
{
public:
   virtual Collection<BaseItem>* operator()() { return this; }
};