使用模板和指针重载数组运算符

Question

以下代码在 clang++-2.9 和 g++-4.6 上编译（没有警告）。但是，g++ 二进制文件出现段错误，而 clang++ 二进制文件按预期运行。

重载 [] 时通过指针访问模板类数据成员的正确方法是什么？

这是代码：

#include <iostream>
template <typename T>
    class A {
    private:
    T val1;
    T val2;

    public:
    T& getVal1() { return val1; }
    void setVal1(T aVal) { val1 = aVal; }
    T& getVal2() { return val2; }
    void setVal2(T aVal) { val2 = aVal; }
};

template <typename T>
    class B {
    private:
    A<T>* aPtr;

    public:
    A<T>* getAPtr() { return aPtr; }
    T& operator[](const int& key) {
    if(key == 0) { T& res = getAPtr()->getVal1();
        return res; }
    else { T& res = getAPtr()->getVal2();
        return res; }
    }
};

int main()
{
    B<int> foo;
    foo[0] = 1;
    int x = foo[0];
    std::cout << foo[0] << " " << x << std::endl; // 1 1
}

Answer 1

您正在返回对局部变量 (res) 的引用。从操作符[]返回后，引用将无效。它可能会被其他东西覆盖。真正发生的是未定义：这就是为什么编译器被允许吃掉你的孩子或长胡子：未定义的行为

你可能想按值返回。

编辑

由于您有设置器，因此不需要参考：请在http://ideone.com/oxslQ

注意：还有一个问题是 aPtr 未初始化。我为此提出了一个简单的构造函数。 _您可能想从其他地方初始化它或者您需要

• 赋值和复制构造函数
• 或使用shared_ptr作为aPtr

。

#include <iostream>

template <typename T>
class A
{
private:
    T val1;
    T val2;

public:
    T getVal1()
    {
        return val1;
    }
    void setVal1(T aVal)
    {
        val1 = aVal;
    }
    T getVal2()
    {
        return val2;
    }
    void setVal2(T aVal)
    {
        val2 = aVal;
    }
};

template <typename T>
class B
{
private:
    A<T>* aPtr;
    B(const B&);            // TODO , disallow for now
    B& operator=(const B&); // TODO , disallow for now

public:
    B() : aPtr(new A<T>()) {}
    ~B() { delete aPtr; }

    A<T>* getAPtr()
    {
        return aPtr;
    }
    T operator[](const int& key)
    {
        if(key == 0)
        {
            T res = getAPtr()->getVal1();
            return res;
        }
        else
        {
            T res = getAPtr()->getVal2();
            return res;
        }
    }
};

int main()
{
    B<int> foo;
    foo.getAPtr()->setVal1(1);
    int x = foo[0];
    std::cout << foo[0] << " " << x << std::endl; // 1 1
}

Answer 2

如果你想通过 ref 返回，那么你的 A::getValX() 函数也应该通过 ref 返回，并且 B::operator 中的 res 变量也应该是 T& 。而不是 T:

#include <iostream>
template <typename T>
    class A {
    private:
    T val1;
    T val2;

    public:
    T& getVal1() { return val1; }
    void setVal1(T aVal) { val1 = aVal; }
    T& getVal2() { return val2; }
    void setVal2(T aVal) { val2 = aVal; }
};

template <typename T>
    class B {
    private:
    A<T>* aPtr;

    public:
    A<T>* getAPtr() { return aPtr; }
    T& operator[](const int& key) {
        if(key == 0) { T& res = getAPtr()->getVal1();
            return res; }
        else { T& res = getAPtr()->getVal2();
            return res; }
    }
};

int main()
{
    B<int> foo;
    foo[0] = 1;
    int x = foo[0];
    std::cout << foo[0] << " " << x << std::endl; // 1 1
}

（请注意，它仍然会在运行时崩溃，因为 aPtr 未在任何地方初始化。）

您的原始代码返回对局部变量 res 的引用，而不是您可能想要的 A::val1 / A::val2 。如果 res 是非引用变量，那么它将是 val1 / val2 值的简单副本，仅在声明它的范围（在本例中为函数）内有效。所以你需要一个参考。