Question

我有一些模板类Pool：

template<int a>
class Pool{}

现在，我有另一个类，我将Pool的对象指针作为参数传递：

template<int a, Pool<a> &pool>
class Point{}

或

template<typename PoolT, PoolT &pool>
class Point{}

我可以以某种方式避免第一次争论吗？ E.g：

template<Pool<?> &pool>
class Point{}

这是我正在做的例子：

#include <iostream>
#include <stdlib.h>     /* malloc, free, rand */
using namespace std;

template<int i>
struct Pool{
    int id;
};

struct FE{
    static Pool<1> pool;
};

Pool<1> FE::pool;


template<typename T, T &_p>
struct C{
    int id;
    void* operator new(size_t size){
        std::cout<<"new";
        return malloc(size);
    }

    void test(){
        std::cout << _p.id;
    }
};


int main() {
    FE::pool.id = 120;
    C<Pool<1>, FE::pool> c;
    c.test();
    return 0;
}

http://ideone.com/1BRUos

Answer 1

您不能只使用静态const成员来存储Pool的模板参数吗？

#include <stdio.h>

template<int i>
struct Pool
{
    static const int stored = i;
};

int main(int argc, char* argv[])
{
    printf("%d\n", Pool<5>::stored);
    return 0;
}

Answer 2

部分特化可以从类型1解包参数Pool，但是没有办法声明一个引用任何对象并推断出类型的模板。函数可以推导出给定对象的类型，但是这样的对象不能用作非类型模板参数。

这里最好的因素可能是使客户端类型嵌套在池类型中。

template<int i>
struct Pool{
    int id;

    // i and the Pool type are already defined at least within this context.

    template< Pool & p >
    struct C{
        int id;
        void* operator new(size_t size){
            std::cout<<"new";
            return malloc(size);
        }

        void test(){
            std::cout << _p.id;
        }
    };
};

int main() {
    FE::pool.id = 120;
    Pool<1>::C< FE::pool> c;
    c.test();
    return 0;
}

如图所示，名称Pool<1>::C< FE::pool>仍包含相同的丑陋信息，但此分解更适合typedef，或者将代码添加到分配器类型，其中相关信息可方便地在范围内。

模板类的模板参数

2 个答案: