模板专业化类功能

Question

So I have a class that I use as a data structure, but I want one of the functions in the class to behave differently if the class is storing pointers. What I want to do is instead of returning the pointer I want it to return a reference to the object when the [] operator is called.

This is the class before

template <typename T>
class CollectionTemplate {
    T ** obItems;
    //other code 

    inline T& operator[](int iIndex)
    {
        return * obItems[iIndex];
    }
};

I would like to add this or something like this. This code is out side the class

template<>
ClassA & CollectionTemplate<ClassA*>::operator[](int iIndex)
{
    return *(*obItems[iIndex]);
}

but I get this error when I run the code

E2428 Templates must be classes or functions

from what i have read I have seen people do this with function templates but not class templates any idea on how to do this would be awesome.

Answer 1

You can delegate the type detection (pointer/reference) to a function as shown below.

EDIT: The static before access does not really matter since the access functions are inlined anyway. So I removed it again.

#include <vector>
#include <iostream>

template <class C>
struct Container {

    template <class T>
    T& access(T& x) {
        return x;
    }
    template <class T>
    T& access(T* x) {
        return *x;
    }

    std::vector<C> m_v;

    decltype(access(C)) operator [] (size_t i) {
        return access(m_v[i]);
    }
};

int main() {
    int i1=1, i2=2;

    Container<int*> cp;
    cp.m_v.push_back(&i1);
    cp.m_v.push_back(&i2);

    std::cout << "ip1=" << cp[0]
                        << "\nip2=" << cp[1];

    Container<int> ci;
    ci.m_v.push_back(i1);
    ci.m_v.push_back(i2);

    std::cout << "\ni1=" << ci[0]
                        << "\ni2=" << ci[1];

    return 0;
}

/**
     Local Variables:
     compile-command: "g++ -std=c++11 test.cc -o a.exe && ./a.exe"
     End:
*/

Answer 2

You can't specialize only a single method in your template. You have to specialize the whole template. You can use another level of indirection by introducing a helper.

template <typename T>
class CollectionTemplate {
    T ** obItems;
    //other code 

    template <typename U>
    struct ItemGetter {
        static U& get(U** items, int index) {
            return * items[index];
         }
    };

    template<>
    struct ItemGetter<ClassA*> {
        static U& get(U** items, int index) {
            return *(*items[index]);
         }
    };

    inline T& operator[](int iIndex)
    {
        return ItemGetter<T>::get(objItems, iIndex);
    }
};

Reading some of your comments, maybe you wanted a different return type for the specialized method? The same principle holds:

template <typename T>
class CollectionTemplate {
    T ** obItems;
    //other code 

    template <typename U>
    struct ItemGetter {
        using returnType = U*;
        static U* get(U** items, int index) {
            return * items[index];
         }
    };

    template<>
    struct ItemGetter<ClassA*> {
        using returnType = U&;
        static returnType get(U** items, int index) {
            return *(*items[index]);
         }
    };

    using getter = ItemGetter<T>;

    inline getter::returnType operator[](int iIndex)
    {
        return getter::get(objItems, iIndex);
    }
};

Answer 3

You can put the common code in a base class, then partially specialize a derived class that just implements the index operator. The advantage of this is that if you have a few things that you want to partially specialize, you can just put them all in the derived class, so there's a relatively clean separation between the common part and the specialized part. (Obviously the code below won't run, but it will compile.)

template <typename T>
class CollectionTemplate_base {
    protected:
        T ** obItems;
    //other code
};

template <typename T>
class CollectionTemplate : public CollectionTemplate_base<T> {
    public:
        T& operator[](int iIndex) {
            return *this->obItems[iIndex];
        }
};

template <typename T>
class CollectionTemplate<T *> : public CollectionTemplate_base<T *> {
    public:
        T &operator[](int iIndex) {
            return *(*this->obItems[iIndex]);
        }
};

int main() {
    CollectionTemplate<int> c1;
    int i = c1[1];

    CollectionTemplate<int *> c2;
    int j = c2[1];
}