¿Cómo puedo definir un operador de dobles corchetes/doble iterador, similar al vector de vectores?

Question

Estoy portando código que usa una gran variedad de flotadores, que pueden desencadenar fallas de malloc de c a C++. Hice una pregunta acerca de si debo utilizar vectores o deques y Niki Yoshiuchi generosamente me ofreció este ejemplo de un tipo envuelto con seguridad:

template<typename T> 
class VectorDeque 
{ 
private: 
    enum TYPE { NONE, DEQUE, VECTOR }; 
    std::deque<T> m_d; 
    std::vector<T> m_v; 
    TYPE m_type; 
    ... 
public: 
    void resize(size_t n) 
    { 
    switch(m_type) 
    { 
     case NONE: 
     try 
     { 
     m_v.resize(n); 
     m_type = VECTOR; 
     } 
     catch(std::bad_alloc &ba) 
     { 
     m_d.resize(n); 
     m_type = DEQUE; 
     } 
     break; 
    } 
    } 
}; 

que necesitaba un vector 2D de vectores/deque de deques, por lo que he modificado a la siguiente código:

template<typename T> 
class VectorDeque 
{ 
private: 
    enum STORAGE_CONTAINER { NONE, DEQUE, VECTOR }; 
    std::deque<std::deque<T> > x_d,y_d,z_d; 
    std::vector<std::vector<T> > x_v,y_v,z_v; 
    TYPE my_container; 
public: 
    void resize(size_t num_atoms, size_t num_frames) 
    { 
    switch(m_type) 
    { 
     case NONE: 
     try 
     { 
     x_v.resize(num_atoms); 
for (unsigned int couter=0;couter < num_frames; counter++) 
    x_v[counter].resize(num_frames); 
     y_v.resize(num_atoms); 
for (unsigned int couter=0;couter < num_frames; counter++) 
    y_v[counter].resize(num_frames); 
     z_v.resize(num_atoms); 
for (unsigned int couter=0;couter < num_frames; counter++) 
    z_v[counter].resize(num_frames); 
     my_container = VECTOR; 
     } 
     catch(std::bad_alloc &e) 
     { 
     x_d.resize(num_atoms); 
for (unsigned int couter=0;couter < num_frames; counter++) 
    x_d[counter].resize(num_frames); 
     y_d.resize(num_atoms); 
for (unsigned int couter=0;couter < num_frames; counter++) 
    y_d[counter].resize(num_frames); 
     z_d.resize(num_atoms); 
for (unsigned int couter=0;couter < num_frames; counter++) 
    z_d[counter].resize(num_frames); 
     my_container = DEQUE; 
     } 
     break; 
    } 
    } 
}; 

ahora quiero ser capaz de definir mis operadores del soporte para que pueda tener una declaración como x[1][2] acceder directamente a lo que es el contenedor de memoria verdadera estoy usando (dado por el valor de mi variable enumerada.

He visto un par de tutoriales flotando alrededor de anular el operador de corchetes, pero no tengo ninguna idea de anular los corchetes dobles.

¿Cómo se pueden sobrecargar los soportes dobles?

Además, ¿cómo se sobrecargarían los iteradores dobles (en caso de que quiera usar un iterador, en contraposición a la indexación directa)?

EDIT 1:

Basado en la solución de Martin York/Matteo Italia I ideó la clase siguiente:

template<typename T> 
class VectorDeque2D 
{ 
public: 

    class VectorDeque2D_Inner_Set 
    { 
    VectorDeque2D& parent; 
    int first_index; 
    public: 
    // Just init the temp object 
    VectorDeque2D_Inner_Set(My2D& p, int first_Index) : 
     parent(p), 
     first_Index(first_index) {} 
    // Here we get the value. 
    T& operator[](int second_index) const 
    { return parent.get(first_index,second_index);} 
    }; 

    // Return an object that defines its own operator[] that will access the data. 
    // The temp object is very trivial and just allows access to the data via 
    // operator[] 
    VectorDeque2D_Inner_Set operator[](unsigned int first_index) { 
    return (*this, x); 
    } 


    void resize_first_index(unsigned int first_index) { 
    try { 
     my_vector.resize(first_index); 
     my_container = VECTOR; 
    } 
    catch(std::bad_alloc &e) { 
     my_deque.resize(first_index); 
     my_container = DEQUE; 
    } 
    } 

    void resize_second_index(unsigned int second_index) { 
    try { 
     for (unsigned int couter=0;couter < my_vector.size(); counter++) { 
    my_vector[counter].resize(second_index); 
     } 
     my_container = VECTOR; 
    } 
    catch(std::bad_alloc &e) { 
     for (unsigned int couter=0;couter < my_deque.size(); counter++) { 
    my_deque[counter].resize(second_index); 
     } 
     my_container = DEQUE; 
    } 
    } 
    void resize(unsigned int first_index, 
      unsigned int second_index) { 
    try { 
     my_vector.resize(first_index); 
     for (unsigned int couter=0;couter < my_vector.size(); counter++) { 
    my_vector[counter].resize(second_index); 
     } 
     my_container = VECTOR; 
    } 
    catch(std::bad_alloc &e) { 
     my_deque.resize(first_index); 
     for (unsigned int couter=0;couter < my_deque.size(); counter++) { 
    my_deque[counter].resize(second_index); 
     } 
     my_container = DEQUE; 
    }  
    } 
private: 
    enum STORAGE_CONTAINER { NONE, DEQUE, VECTOR }; 

    friend class VectorDeque2D_Inner_Set; 

    std::vector<std::vector<T> > my_vector; 
    std::deque<std::deque<T> > my_deque; 
    STORAGE_CONTAINER my_container; 

    T& get(int x,int y) { 
    T temp_val; 
    if(my_container == VECTOR) { 
     temp_val = my_vector[first_index][second_index]; 
    } 
    else if(my_container == DEQUE) { 
     temp_val = my_deque[first_index][second_index]; 
    } 

    return temp_val; 
    } 

}; 

Finalmente un recipiente 2D tamaño-safe !! ¡Gracias chicos!

Answer 1

Hay dos técnicas principales:

1) el uso del operador() en lugar de operador [].
Esto es porque el operador() permite múltiples parámetros.

class My2D 
{ 
    public: 
     int& operator()(int x,int y) { return pget(x,y);} 
    private: 
     int& pget(int x,int y) { /* retrieve data from 2D storage */ } 
}; 

2) Utilice el operador [] pero devuelva un objeto intermedio.
A continuación, puede aplicar el segundo operador [] al objeto intermedio.

class My2D 
{ 
    public: 
     class My2DRow 
     { 
      My2D& parent; 
      int x; 
      public: 
       My2DRow(My2D& p, int theX) : parent(p), x(theX) {}  // Just init the temp object 
       int& operator[](int y) const { return parent.pget(x,y);} // Here we get the value. 
     }; 

     // Return an object that defines its own operator[] that will access the data. 
     // The temp object is very trivial and just allows access to the data via operator[] 
     My2DRow operator[](int x)  { return My2DRow(*this, x);} 
    private: 
     friend class My2DRow; 
     int& pget(int x,int y) { /* retrieve data from 2D storage */ } 
}; 

int main() 
{ 
    My2D data; 
    int& val = data[1][2]; // works fine. 

    // This is the same as 
    My2D::My2DRow row = data[1]; 
    int&   val2 = row[2]; 
} 

Prefiero la segunda técnica.
Esto se debe a que deja el código original intacto y es más natural de leer (en un contexto de matriz). Por supuesto, usted paga por la simplicidad en el alto nivel con un código un poco más complejo implementando su matriz 2D.

Answer 2

¿Cómo se pueden sobrecargar los soportes dobles?

No entendí completamente su pregunta, pero debe sobrecargar los paréntesis y hacer que devuelvan un objeto que sobrecargue su propio operador de corchetes. Por ejemplo, si tiene un vector de vectores, el trabajo ya está hecho: vector < vector < something > > sobrecarga operator[], que arroja un vector< something >; esto, a su vez, se ha sobrecargado el operador paréntesis (y que devuelve un objeto something), por lo que se puede hacer simplemente:

vector<vector<something> > vec; 
// ... 
something s = vec[2][3]; 

---

Ejemplo con un objeto proxy:

template <typename T> 
class Container 
{ 
private: 
    // ... 


public: 

    // Proxy object used to provide the second brackets 
    template <typename T> 
    class OperatorBracketHelper 
    { 
     Container<T> & parent; 
     size_t firstIndex; 
    public: 
     OperatorBracketHelper(Container<T> & Parent, size_t FirstIndex) : parent(Parent), firstIndex(FirstIndex) {} 

     // This is the method called for the "second brackets" 
     T & operator[](size_t SecondIndex) 
     { 
      // Call the parent GetElement method which will actually retrieve the element 
      return parent.GetElement(firstIndex, SecondIndex); 
     } 

    } 

    // This is the method called for the "first brackets" 
    OperatorBracketHelper<T> operator[](size_t FirstIndex) 
    { 
     // Return a proxy object that "knows" to which container it has to ask the element 
     // and which is the first index (specified in this call) 
     return OperatorBracketHelper<T>(*this, FirstIndex); 
    } 

    T & GetElement(size_t FirstIndex, size_t SecondIndex) 
    { 
     // Here the actual element retrieval is done 
     // ... 
    } 
} 

(add sobrecargada métodos const cuando sea apropiado :))

Tenga en cuenta que con este método no pierde casi nada con respecto a una implementación operator(), ya que la recuperación todavía se realiza en un solo lugar, sin co nstraints sobre el uso de los dos índices, teniendo ambos índices en el momento de realizar la recuperación, y sin devolver objetos temporales "gordos" (OperatorBracketHelper es tan grande como dos punteros, y el compilador puede optimizarlo fácilmente).

Answer 3

No sobrecargar el operador [], sobrecargar el operador ().

ver este enlace: Overloading Subscript Operator.

le recomiendo la lectura a través de la C++ FAQ Lite al menos una vez antes de la publicación de desbordamiento de pila. Además, la búsqueda de Desbordamiento de pila también puede arrojar información útil.

Answer 4

No hay operadores de "doble paréntesis" en C++. Lo que necesita hacer es definir un único operador [] y hacer que devuelva una referencia a otro objeto, que a su vez puede responder a su propio operador []. Esto se puede anidar tantos niveles profundos como requiera.

Por ejemplo, cuando crea un vector de vectores, el operador [] en el vector externo devuelve una referencia a uno de los vectores internos; el operador [] en ese vector devuelve una referencia a un elemento individual del vector.

std::vector<std::vector<float> > example; 
std::vector<float> & first = example[0]; // the first level returns a reference to a vector 
float & second = example[0][0]; // the same as first[0] 

Answer 5

Cubrí el operador de sobrecarga [] para una matriz multidimensional en un answer to a previous question.

Probablemente trataré con iteradores de forma muy similar: Tengo un iterador que representa un "corte" (fila o columna) de la matriz multidimensional, y luego otro que representa un elemento en esa porción.