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

Question

以下代码可在 clang++-2.9 和 g++-4.6 上编译（无警告）。但是，g++ 二进制文件 Seg Faults，而 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) 的引用。从 operator[] 返回后引用将无效。它可能会被其他东西覆盖。真正发生的是未定义：这就是为什么允许编译器吃掉你的孩子或留胡子：未定义的行为

您可能希望按值返回。

编辑

由于您有 setter，因此您不需要参考：通过 http://ideone.com/oxslQ

实时查看解决方案

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

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

.

#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

如果你想通过引用返回，那么你的 A::getValX() 函数也应该通过引用返回，并且你在 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 值的简单副本，仅在声明它的范围内（在本例中为函数）内有效。所以你需要在这里参考。