Question

我正在使用libgc，它是C和C ++的垃圾收集器。要使STL容器可以收集垃圾，必须使用gc_allocator。

而不是写

std::vector<MyType>

一个人必须写

std::vector<MyType,gc_allocator<MyType> >

是否有办法定义类似

的内容

template<class T> typedef std::vector<T,gc_allocator<T> > gc_vector<T>;

我前段时间检查过，发现它不可能。但我可能错了，或者可能有另一种方式。

以这种方式定义地图尤其令人不快。

std::map<Key,Val>

变为

std::map<Key,Val, std::less<Key>, gc_allocator< std::pair<const Key, Val> > >

编辑：尝试使用宏后，我发现以下代码打破了它：

#define gc_vector(T) std::vector<T, gc_allocator<T> >
typedef gc_vector( std::pair< int, float > ) MyVector;

模板化类型定义中的逗号被解释为宏参数分隔符。

所以内部类/结构似乎是最好的解决方案。

这是一个关于如何在C ++ 0X中完成的示例

// standard vector using my allocator
template<class T>
using gc_vector = std::vector<T, gc_allocator<T> >;

// allocates elements using My_alloc
gc_vector <double> fib = { 1, 2, 3, 5, 8, 13 };

// verbose and fib are of the same type
vector<int, gc_vector <int>> verbose = fib;

Answer 1

您可以使用using使用C ++ 11模板化类型别名，例如像这样

template <typename T>
using gc_vector = std::vector<T, gc_allocator<T>>;

_{注意：我知道这是一个老问题，但由于它有很多赞成，因为它出现在搜索结果中，我认为它应该得到更新的答案。}

Answer 2

您不能使用“模板化typedef”，但可以使用具有内部类型的便捷类/结构：

template<typename T>
struct TypeHelper{
    typedef std::vector<T,gc_allocator<T> > Vector;
};

然后在您的代码中使用

TypeHelper<MyType>::Vector v;
TypeHelper<MyType>::Vector::iterator it;

地图上有类似内容：

template<typename K,typename V>
struct MapHelper{
    typedef std::map<K, V, gc_allocator<K,V> > Map;
};

编辑 - @Vijay：我不知道是否还有其他可行的解决方法，我就是这样做的;一个宏可能会给你一个更紧凑的符号，但我个人不喜欢它：

#define GCVECTOR(T) std::vector<T,gc_allocator<T> >

编辑 - @chmike：请注意，TypeHelper解决方案要求您重新定义构造函数！

Answer 3

您可以公开继承：

template<class T>
class gc_vector<T> : public std::vector<T, gc_allocator<T> >
{
    public:
    // You'll have to redeclare all std::vector's constructors here so that
    // they just pass arguments to corresponding constructors of std::vector
};

这完全解决了您的问题。派生类型可以在任何可以使用基类型的地方使用，并且任何体面的编译器都没有实现开销。

如果您尝试通过指向基类变量的指针删除派生类变量，则std :: vector具有非虚拟析构函数的事实可能导致根据C ++标准的未定义行为。

在现实世界中，在这种特殊情况下这应该无关紧要 - 与基类相比，派生类没有添加任何新内容，因此派生类的析构函数只调用基类的析构函数。继续妄想狂，无论如何都要小心。

如果你从未在堆上分配这个类变量（并且通常在堆栈上分配矢量变量并作为其他类的成员），非虚拟析构函数问题不会影响你。

Answer 4

如果您愿意将编译器推向极限，可以使用MACRO完成。我在为Java的“Future”和“Callable”类实现C ++等价物时做到了这一点。我们的库使用引用计数对象，因此“参考＆lt; T＆gt;”本身就是一个模板类，其中“T”派生自“ReferencedObject”。

1. Create your template Classes. Mine are:

    template<typename T>
    class Callable {
    private:

    public:
        virtual T Call() = 0;
    };

    template<typename T> CountedFuture : public ReferencedObject {
    private:
       Callable<T>* theTask;
       T            theResult;

    public:
       T Get() { 
          // Run task if necessary ...
          if(task) {
             theResult = theTask->Call();
             delete theTask;
          }
          return theResult;
       }
    };

2. In the application code I'm using references, so I define the macro:

   #define Future(T) Reference<CountedFuture<T>>

这就是因为Macro完全按照你所要求的“模板typedef”，其缺点是你不能使用“＆lt;＆gt;”对于您的类型参数，没有类型推断。

3. I can now use the Macro wherever I would use a template, like in functions:

   Future(char*) DoSomething() { ... }
   bool          TestSomething(Future(std::string) f) { .... }

模板化的typedef？

4 个答案: