1

有一件事一直困扰着我的大脑：我试图根据返回类型重载 [] 运算符。这是我需要做的：

class A {

private:
    double* data_;
    int N_;
public:
    A (N=0):N_(N){
        data_ = new double[N];
    }
    ~A {delete[] data_;}

    double operator[] (const int i) {
        return data_[i];
    }

    double* operator[] (const int i) {
        return &data[i]; // for example; in fact here i need to return some block of data_ 
    }
};

此代码不会编译；这就是我的问题。有人可以帮我解决这个问题吗？

PS：我知道如何在返回类型上重载普通函数，例如：

int foo ();
string foo ();

我使用了我在这个论坛上读到的一些技巧。这样：

struct func {
    operator string() { return "1";}
    operator int() { return 2; }
};

int main( ) {
    int x    = func(); // calls int version
    string y = func(); // calls string version
    double d = func(); // calls int version
    cout << func() << endl; // calls int version
    func(); // calls neither
}

谢谢你。

4

3 回答 3

14

两个方法重载必须有不同的签名。返回类型不是方法签名的一部分。

于 2012-05-30T21:33:39.313 回答
4

您可以使用与函数相同的“技巧”，即使用带有转换运算符的代理对象：

class A
{
  private:
    double* data_;
    int N_;
  public:
    A (int N = 0)
      : N_(N), data_(new double[N])
    {}
    ~A() { delete[] data_; }

    struct proxy
    {
        int i;
        double * data;
        operator double() const
        {
            return data[i];
        }

        operator double*()
        {
            return &data[i];
        }

        operator double const *() const
        {
            return &data[i];
        }
    };

    proxy operator[] (int const i) {
        proxy p { i, data_ };        
        return p;
    }

    proxy const operator[] (int const i) const {
        proxy p { i, data_ };        
        return p;
    }
};

int main()
{
  {
    A a(12);

    double d = a[0];
    double * pd = a[0];
  }

  {
    A const ca(12);

    double d = ca[0];
    //double * pd = ca[0]; // does not compile thanks to overloads on const
    double const * pcd = ca[0];
  }
}

但是，我认为这是一个糟糕的想法。让您operator[]返回一个值或指向该值的指针肯定会使您的类的用户感到困惑，此外还会使其在两种类型都可能的表达式中使用变得不切实际。例如，std::cout << a[0];不会编译（模棱两可的重载）。

于 2012-06-19T08:48:06.270 回答
0

Probably you need something like that:

class A {

private:
    double* data_;
    int N_;
    ... // other stuff
public:
    double operator[] (const int i) const { // note const here
        return data_[i];
    }

    double& operator[] (const int i) { // note reference here
        return data_[i];
    }
};

also operator should be public to have a sense.

于 2012-05-30T21:47:17.987 回答