Question

Let’s say i have following class:

template <typename T>
class CModule{
public:
  virtual void process( std::multiamp<int, T>)  = 0;
 }

and derived class:

template <typename T>
class CModuleDeriv: public CModule<T>{
public:
  virtual void process( std::multiamp<int, T>){....};

 }

and class where i wan’t to implement this functionality:

class Client{

std::vector<CModule<T>*> oModuleList_; // <--- this is not possible error

public:
  void moduleLoader(){
    oModuleList_.resize(1);
    if( some_condition ){
      oModuleList_[0] = CModuleDeriv<int>();
    }else{
      oModuleList_[0] = CModuleDeriv<double>();
    }
  }
}

is it possible?
is there any other solution ?
I can’t use boost :/

Answer 1

First of all, in the future please post code that almost compiles (or even better one that compiles!), because those “little” details you omit sometimes changes the semantics of your code. So, submitting almost compilable code has almost unambiguous semantics…

Here’s some code that might or might not solve your problem:

#include<map>
#include<vector>

template <class, class>
class TypedMultimap;

class TypeErasedMultimap {
public:
    template <class T1, class T2>
    std::multimap<T1,T2> & getMap() {
        return  static_cast<TypedMultimap<T1,T2> &> (*this); // This is not type safe, it can be made to be, but boost people already did it so I won't bother
    }

    virtual ~TypeErasedMultimap(){}
};

template <class T1, class T2>
class TypedMultimap: public TypeErasedMultimap, public std::multimap<T1,T2> {};

class CModule{

    virtual void process( TypeErasedMultimap &)  = 0;

};

template <typename T>
class CModuleDeriv: public CModule{

    // At his point, please ask yourself, how will you make sure that the right kind
    // of map arrives at this call? I can't answer this, since this is related to
    // the semantics...
    virtual void process( TypeErasedMultimap & map_){
        std::multimap<int,T> &map = map_.getMap<int,T>();
        //...
    };

};

class Client{

// Why are you using raw pointers?!?
std::vector<CModule*> oModuleList_; 

public:
  void moduleLoader(){
    oModuleList_.resize(1);
    if( 1/*some condition*/ ){
      oModuleList_[0] = new CModuleDeriv<int>();
    }else{
      oModuleList_[0] = new CModuleDeriv<double>(); // the types are lost forever...
    }
  }

// ~Client() you MAY OR MAY NOT!!! need a destructor since your vector is holding pointers: use smart pointers!!!
};

int main() {
}

This, by itself is not a solution to your problem, because your not compiling code snipplet would not solve anything even if it compiled. You are pushing things with inherently different types to a common list and losing their type, so how will you know how to use the elements in the future? This is a semantic question.

I’ll have a wild guess that this is probably what you’re trying to do:

#include<boost/variant.hpp>
#include<boost/shared_ptr.hpp>
#include<boost/make_shared.hpp>
#include<map>
#include<vector>

typedef boost::variant<std::multimap<int,int>, std::multimap<int,double> /* possibly some others */ > VariantMap;

class CModule{
public:
    virtual void process( VariantMap &)  = 0;

};

class CModuleDeriv1: public CModule, public boost::static_visitor<> {
public:
    virtual void process( VariantMap & in){
    boost::apply_visitor(*this, in);    
    };

    template < class T>
    void operator()(std::multimap<int,T> & in) {
    // do your type safe processing here
    }
};

class CModuleDeriv2: public CModule, public boost::static_visitor<>{
public:
    virtual void process( VariantMap & in){
    boost::apply_visitor(*this, in);
    };

    template < class T>
    void operator()(std::multimap<int,T> & in) {
    // do other kind of processing here
    }
};


class Client{

// Why are you using raw pointers?!?
std::vector<boost::shared_ptr<CModule> > oModuleList_; 

public:
  void moduleLoader(){
    oModuleList_.resize(1);
    if( 1/*some condition*/ ){
      oModuleList_[0] = boost::make_shared<CModuleDeriv1>();
    }else{
      oModuleList_[0] = boost::make_shared<CModuleDeriv1>(); // the types are safe now, even though not known
    }
  }

// ~Client() you MAY OR MAY NOT!!! need a destructor since your vector is holding pointers: use smart pointers!!!
};

int main() {
}

See, no more commented nags 🙂