模板类的数组特化

模板类的数组特化

   一般地，泛型容器的设计实现大多只是存储了类型的单个对象，而没有存储类型的多个对象，如果有这样特定的需求，容器内的元素要求都是某个类型的多个对象，那么这时就可以考虑用模板类的数组特化来实现了，作为例程，下面C++代码描述了主模板实现

 1  template < typename T >
 2   class  ADT
 3   {
 4 public:
 5     ADT()
 6     {
 7     }
 8     explicit ADT(const T& t)
 9     {
10        m_t = t;    
11    }
12    ADT(const ADT& other)
13    {
14        set(other.m_t);
15    }
16    ADT& operator = (const T& t)
17    {
18        set(t); 
19        return *this;
20    }
21    ADT& operator = (const ADT& other)
22    {
23        if (this != &other)
24            set(other.m_t);
25        return *this;
26    }
27    void set(const T& t)
28    {
29        m_t = t;
30    }
31    void get(T& t) const
32    {
33        t = m_t;
34    }
35    void get(const T*& p_c_t) const
36    {
37        p_c_t = &m_t;
38    }
39    void get(T*& p_t) 
40    {
41        p_t = &m_t;
42    }
43private:
44    T m_t;
45} ;

   下面C++代码描述了ADT模板类的数组特化实现

 1 template < typename T,size_t N >
 2 class  ADT < T[N] >
 3 {
 4public:
 5    ADT()
 6    {
 7    }
 8    explicit ADT(const T (&t)[N])
 9    {
10        set(t);
11    }
12    ADT(const ADT& other)
13    {
14        set(other.m_t);
15    }
16    ADT& operator = (const T (&t)[N])
17    {
18        set(t);
19        return *this;
20    }
21    ADT& operator = (const ADT& other)
22    {
23        if (this != &other) 
24            set(other.m_t);
25        return *this;
26    }
27    //设置整个数组
28    void set(const T(&t)[N])
29    {
30        memcpy(m_t,t,sizeof(t));
31    }
32    //设置数组中某个元素
33    void set(const T& t,size_t n = 0)
34    {
35        if (n < N)  m_t[n] = t;
36    }
37    //读取整个数组
38    void get(T (&t)[N]) const
39    {
40        memcpy(t,m_t,sizeof(m_t));
41    }
42    //只读,获取数组中某个元素的地址
43    void get(const T*& p_c_t,size_t n = 0) const
44    {
45        if (n < N) p_c_t = &m_t[n];
46    }
47    //可写,获取数组中某个元素的地址
48    void get(T*& p_t,size_t n = 0)
49    {
50        if (n < N) p_t = &m_t[n];
51    }
52    //获取数组中某个元素的值
53    void get(T& t,size_t n = 0) const
54    {
55        if (n < N) t = m_t[n];
56    }
57
58private:
59    T m_t[N];
60} ;

   定义ADT数组特化模板类的实例也很方便，如ADT<int[100]> adt1  实质定义了元素数量为100的int数组；ADT<float*[10]> adt2 实质定义了元素数量为10的float*指针数组；还可以嵌套其主模板类的类型，如ADT<ADT<int>[100]> adt3 实质定义了元素数量为100的int数组，之所以能这样，这是因为主模板类和其特化类是两个不同的类型。在此其础上，依次类推，可以定义二维数组、三维数组，如typedef ADT<int[10]> M1；ADT<M1[20]> m2 实质定义了各维分别为10、20的int二维数组；typedef ADT<M1[20]> M2；ADT<M2[30]> m3 实质定义了各维数量分为10、20、30的int三维数组。
   最后，要说明的一点是，本文所描述的数组特化与泛型数组有所不同，虽然两者内部实现一样，但是模板名称不同，要单独实现一个泛型数组，只需将上面ADT<T[N>特化模板类的<T[N]>去掉变成主模板即可，这样一来，实例化也就不同了，如一维数组ADT<int,100> m1；二维数组ADT<ADT<int,10>,20> m2；三维数组ADT<ADT<ADT<int,10>,20>,30> m3。