3

我想创建一个类，作为一组专用模板类的接口。例如：

template<typename T>
class ThingDoer {
    public:
        void Method()
        {
            // do something;
        }
};

class ThingDoerInterface {
    public:
        template<typename T>
        void Method()
        {
            // call ThingDoer<T>::Method(); somehow
        }
};

int main()
{
    ThingDoerInterface i;
    i.Method<int>();
    i.Method<char>();
    // etc.
    
    return 0;
}

我对我想要的对象的一般要求如下所示：

  • 用户只需要创建一个对象的非模板化实例。
  • 但是可以存在多个实例，并且应该是独立的。
  • 该对象将派生自类型 A 的（用户定义的）对象的实例与派生自类型 B 的（一个或多个）对象相关联。
  • 用户可以根据A的类型调用对 B 执行某些操作的对象的方法。

我有一个基于std::unordered_multimap.

编辑：

这是一个更具体的例子，我希望能说明我真正想要做的事情。

class ABase {
    public:
        virtual ~ABase() {}
};

class A1 : public ABase {};
class A2 : public ABase {};

class BBase {
    public:
        virtual ~BBase() {}
};
class B1 : public BBase {};
class B2 : public BBase {};


class ThingDoerInterface {
    public:
        template<typename T>
        void Store(BBase* b_ptr)
        {
            // store the B pointer with the type of T as a key
            // (T will be A1 or A2)
        }
        
        template<typename T>
        void Recall()
        {
            // call all the stored B pointers associated with the type of T
        }
};

int main()
{
    ThingDoerInterface i;
    
    B1* b_one_ptr = new B1;
    B2* b_two_ptr = new B2;
    
    i.Store<A1>(b_one_ptr);
    i.Store<A1>(b_two_ptr);
    
    i.Store<A2>(b_one_ptr);
    
    i.Recall<A1>(); // do something with b_one_ptr and b_two_ptr
    i.Recall<A2>(); // do something with b_one_ptr
    
    delete b_two_ptr;
    delete b_one_ptr;
    
    return 0;
}

我已经用 . 完成了这个std::unordered_multimap，但我想知道是否可以像这样存储关联：

template<typename T>
class ThingDoer {
    public:
        void Store(BBase* b_ptr)
        {
            b_ptrs.push_back(b_ptr);
        }
        
        void Recall()
        {
            // do something with the b_ptrs associated with the type of T
        }
    private:
        std::vector<BBase*> b_ptrs;
};

但以ThingDoerInterface某种方式这样做。

4

1 回答 1

3

我不一定说它值得复杂，但是......

#include<iostream>
#include<vector>
using namespace std;

class repo {
public:
  repo(){
    id = highestid++;
  }
  template<typename T>
  T& get() {
    vector<T>& vec = data<T>::vec;
    if (vec.size() <= id) {
      vec.resize(id+1);
    }
    return vec[id];
  }
private:
  template<typename T>
  struct data {
    static vector<T> vec;
  };
  int id;
  static int highestid;
};
/*static*/ int repo::highestid = 0;
template<typename T>
/*static*/ vector<T> repo::data<T>::vec;

main(){
  repo a, b;
  a.get<int>() = 42;
  b.get<int>() = 54;
  a.get<float>() = 4.2;
  b.get<float>() = 5.4;
  cout << a.get<int>() << ", " << b.get<int>() << ", " << a.get<float>() << ", " << b.get<float>() << endl;
}

我写它是为了快速查找。第一次为给定的 repo 调用 get 时，会使其他 repo 返回的所有引用无效，并且销毁 repo 不会清理任何东西。但是如果你有少量的 repos，它们的生命周期基本上是整个程序，那应该没问题。

于 2013-01-22T18:37:09.937 回答