返回類型的重載運算符[]返回類型

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];不會編譯（模糊過載）。