punteros - ¿C++[] operador de matriz con múltiples argumentos?

matriz c++ dinamica

Question

¿Puedo definir en C ++ un operador de matriz que toma múltiples argumentos? Lo intenté así:

const T& operator[](const int i, const int j, const int k) const{ 
    return m_cells[k*m_resSqr+j*m_res+i];
}

T& operator[](const int i, const int j, const int k){ 
    return m_cells[k*m_resSqr+j*m_res+i];       
}

Pero estoy recibiendo este error:

error C2804 binary operator ''['' has too many parameters

Answer 1

En aras de la integridad: hay una manera de utilizar realmente el operador de corchete con múltiples argumentos, si no son tipos de datos básicos, es decir, mediante la sobrecarga del operador de coma y no del operador de corchete, consulte la siguiente publicación acerca de la sobrecarga de coma:

https://stackoverflow.com/a/18136340/5836981

Descargo de responsabilidad: en mi opinión, la sobrecarga del operador de comas es propensa a errores y hace que el código sea más oscuro, y vale la pena considerarlo solo en casos más exóticos. Agregué esta respuesta porque descubrí una instancia de esto en algún código y me tomó un tiempo descubrir que la clave no era el operador [] (que no puede ser sobrecargado con múltiples argumentos) sino el operador,.

Answer 2

Hay un pequeño truco que puedes hacer con la sintaxis de inicialización uniforme disponible en C ++ 11. En lugar de tomar el índice directamente, tomas un POD.

struct indices
{
  std::size_t i, j, k;
};

T& operator[](indices idx)
{
  return m_cells[idx.k * m_resSqr + idx.j * m_res + idx.i];
}

Y luego usa la nueva sintaxis:

my_array<int> arr;
// ...
arr[{1, 2, 3}] = 42;

Answer 3

No es posible sobrecargar al operador [] para aceptar múltiples argumentos, pero una alternativa es usar el patrón proxy .

En dos palabras: a[x][y] , la primera expresión ( a[x] ) devolvería un tipo diferente, denominado tipo proxy, que tendría otro operator[] . _storedReferenceToOriginalObject->At(x,y) algo como _storedReferenceToOriginalObject->At(x,y) de la clase original.

No podrá hacer a[x,y] , pero supongo que de todos modos querría sobrecargar la sintaxis de matriz 2D del estilo C ++ habitual.

Answer 4

No, no puede sobrecargar el operator[] para aceptar múltiples argumentos. En su lugar, puede sobrecargar el operator() . Consulte ¿Cómo creo un operador de subíndice para una clase Matrix? de las preguntas frecuentes de C ++.

Answer 5

Arreglos N-dimensionales de tipo y tamaño arbitrario en C ++:

Esta respuesta está inspirada en la respuesta de Pavel Radzivilovsky, gracias por eso. Me costó un poco darme cuenta de la implementación, ya que fue mi primer intento con las plantillas recursivas. Me gustaría compartir lo que he hecho para que otros puedan entender más rápido que yo.

He escrito una clase de plantilla c ++ para crear una matriz n-dimensional de tipo y tamaño arbitrarios. Se debe crear una instancia con el tipo de matriz y el número de dimensiones. El tamaño se puede cambiar dinámicamente. A continuación, le doy una versión simple (eliminada) de cómo crear una matriz multidimensional a la que se puede acceder a los elementos a través de la aplicación sucesiva del operador [] (por ejemplo, matriz [x] [y] [z]). Esta versión solo puede manejar matrices de dimensión n> 1. La función principal muestra cómo crear una matriz de enteros de 4 dimensiones como ejemplo.

EDITAR : tenga en cuenta que el siguiente ejemplo es mínimo para facilitar la lectura, ya que no desasigna la matriz, ni tampoco verifica los límites de acceso. Agregar esto es trivial, y se lo deja al programador.

#include <stdio.h>
#include <stdlib.h>

template <typename T, int N>
struct array {
    array<T,N>() : data(NULL), offset((int*) malloc(sizeof(int)*N)){}
    array<T,N>(T *data, int *offset) : data(data), offset(offset){}
    array<T,N-1> operator[](int i){return array<T,N-1>(&data[i*offset[N]], offset);}
    bool resize(int *size){
        offset[N-1] = 1;
        int total_size = size[N-1];
        for(int i = N-2; i >= 0; i--){
            total_size *= size[i];
            offset[i] = offset[i+1]*size[i+1];
        }
        return (data = (T*) realloc (data, total_size*sizeof(T)));
    }
    T *data;
    int *offset;
};

template <typename T>
struct array<T,1>{
    array<T,1>(T *data, int *offset) : data(data){}
    T& operator[](int i){return data[i];}
    T *data;
};

int main () {
    array<int, 4> a;

    // create array with dimensions [1][3][3][7]
    int size[4] = { 1, 3, 3, 7 };
    a.resize(size);               

    a[0][1][2][3] = 123;

    return 0;
}

Disfrutar.