Question

在尝试将模板参数传递给函数调用时，我一直得到预期的主表达式。

我的错误如下：

In PtrAllocator<T, Pool>::allocate(PtrAllocator<T, Pool>::size_type, const void*)': expected primary-expression before '>' token

In PtrAllocator<T, Pool>::max_size() const': expected primary-expression before '>' token

我的代码如下：

template<typename T, typename Pool>
class PtrAllocator : public BasicAllocator<T>
{
    private:
        Pool pool;

    public:
        typedef typename BasicAllocator<T>::pointer pointer;
        typedef typename BasicAllocator<T>::size_type size_type;
        typedef typename BasicAllocator<T>::value_type value_type;

        template<typename U>
        struct rebind {typedef PtrAllocator<U, Pool> other;};

        PtrAllocator(Pool&& pool) : pool(pool) {}

        pointer allocate(size_type n, const void* hint = 0) {return static_cast<pointer>(pool.allocate<T>(n, hint));}
        void deallocate(void* ptr, size_type n) {pool.deallocate(static_cast<pointer>(ptr), n);}
        size_type max_size() const {return pool.max_size<T>();}
};

class Pool
{
    public:
        template<typename T>
        void* allocate(std::size_t n, const void* hint = 0) {return ::operator new(n * sizeof(T));}

        template<typename T>
        void deallocate(T* ptr, std::size_t n) {::operator delete(ptr);}

        template<typename T>
        std::size_t max_size() const {return std::numeric_limits<std::size_t>::max() / sizeof(T);}
};

int main()
{
    PtrAllocator<int, Pool> alloc = PtrAllocator<int, Pool>(Pool());
    std::vector<int, PtrAllocator<int, Pool>> v(alloc);
    v.resize(1000); //this line is causing the error.
}

PtrAllocator::allocate调用Pool::allocate时发生错误。同样的事情发生在max_size，但不会发生在deallocate。任何想法为什么它不允许我指定模板参数？

Answer 1

你需要告诉编译器allocate是一个模板，否则表达式会不明确：

pool.template allocate<T>(n, hint)

有关说明，请参阅Where and why do I have to put the “template” and “typename” keywords?。

基本问题是没有template告诉编译器allocate是一个模板，表达式可以用不同的方式解释。也就是说，表达方式含糊不清。要了解具体方法，请查看以下示例：

struct my_pool {
    int allocate = 0; // allocate is a data member, not a template!
};

template <typename Pool>
void foo() {
    Pool pool;
    int T = 0, n = 0, hint = 0;
    pool.allocate<T>(n, hint); // *
}

int main() {
    foo<my_pool>();
}

我用星号标记的行与你的表达式完全相同，但它意味着完全不同。它实际上相当于(pool.allocate < T) > (n, hint)。也就是说，<和>不再是模板参数的分隔符 - 它们是关系运算符！我正在将数据成员pool.allocate与T进行比较。

如何用参数调用类模板函数

1 个答案: