C++ selektives Überladen []?

Question

Gegeben:

class example 
{ 
    public: 
     std::vector<std::vector<int>> a; 
     int b; 
} 

func() 
{ 
    example e; 
    ... // populate e 

ich dann Beispiele Mitglieder wie so nutzen könnten.

int n = e.b; 
    int n2 = e.a[2][3]; 

Allerdings könnte ich alternativ den Operator [] so übersteuern, dass.

int n = e.b; 
    int n2 = e[2][3]; 
} 

?

bearbeiten: Sorry, das Beispiel ist jetzt behoben.

Answer 1

Was Sie tun können, ist es, den Zugang Betreiber überlasten und sie an den Vektor delegieren:

class example 
{ 
    public: 
     std::vector<std::vector<int>> a; 
     int b; 

     const std::vector<int>& operator[](std::size_t i) const 
     { 
      return a[i]; 
     } 
     std::vector<int>& operator[](std::size_t i) 
     { 
      return a[i]; 
     } 
}; 

Die erste [] kehrt dann einen Verweis auf a ‚s jeweiligen Element, auf dem die zweite [] verwendet werden .

Answer 2

Eine naive Lösung wäre, definieren Sie Ihre eigene operator[]:

class example 
{ 
    std::vector<std::vector<int>> v; 
public: 
    std::vector<int> const & operator[](std::size_t i) const { return v[i]; } 
    std::vector<int>  & operator[](std::size_t i)  { return v[i]; } 

    // ... 
}; 

Nun, wenn Sie example e; haben, dann e[1] ist ein Vektor von Ints usw.

Es sieht aus wie Sie einige schreiben wollen Matrixklasse, obwohl. Dafür ist es effizienter, nur einen einzigen Vektor zu haben und darauf zuzugreifen in Schritten:

class Matrix 
{ 
    std::size_t cols; 
    std::size_t rows; 
    std::vector<int> v; 

public: 
    explicit Matrix(std::size_t r, std::size_t c) : cols(c), rows(r), v(r*c) { } 

    int operator()(std::size_t i, std::size_t j) const { return v[i * cols + j]; } 
    int & operator()(std::size_t i, std::size_t j) { return v[i * cols + j]; } 
}; 

Jetzt können Sie sagen: Matrix m(4, 7); m(1, 3) = 8;. Sie müssen dazu den runden Klammeroperator verwenden, da der eckige Klammeroperator immer exakt ein Argument nehmen muss und somit hier nicht geeignet ist.