模板专业化类功能

Question

因此，我有一个用作数据结构的类，但是我希望如果该类存储指针，则该类中的一个函数的行为会有所不同。 我想做的是，而不是返回指针，而是希望它在调用[]运算符时返回对该对象的引用。

这是之前的课程

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

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

我想添加这个或类似的东西。 该代码在类之外

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

但是运行代码时出现此错误

E2428 Templates must be classes or functions

从我阅读的内容中，我已经看到人们使用功能模板来做到这一点，而不是使用类模板来做到这一点。

Answer 1

您可以将类型检测（指针/引用）委托给一个函数，如下所示。

编辑： static access之前并不重要，因为无论如何都access函数。 因此，我再次将其删除。

#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

您不能仅在模板中专门使用一种方法。 您必须专门化整个模板。 您可以通过引入帮助程序来使用另一种间接级别。

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);
    }
};

阅读您的一些评论，也许您想要特殊方法的其他返回类型？ 相同的原则成立：

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

您可以将通用代码放在基类中，然后部分专用于仅实现索引运算符的派生类。 这样做的好处是，如果您有一些要部分专门化的东西，则可以将它们全部放入派生类中，因此在公共部分和专门化部分之间存在相对清晰的分隔。 （显然，下面的代码无法运行，但可以编译。）

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];
}