返回类型的重载运算符[]返回类型

Question

自从片刻以来，有一件事让我的大脑产生了困扰：我试图根据返回类型重载[]运算符。这是我需要做的：

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 
} 

谢谢。

Answer 1

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

Answer 2

也许你需要类似的东西：

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

运营商也应该是公开的有感觉。

Answer 3

您可以使用相同的“绝招”，您使用的功能，那就是使用代理对象与转换操作符：

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];不会编译（模糊过载）。