Opérateur de tableau C ++ avec plusieurs arguments?

Puis-je définir en C ++ un opérateur de tableau prenant plusieurs arguments? Je l’ai essayé comme ceci:

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

Mais je reçois cette erreur:

 error C2804 binary operator '[' has too many parameters 

Non, vous ne pouvez pas surcharger l’ operator[] pour accepter plusieurs arguments. Vous pouvez plutôt surcharger l’ operator() . Voir Comment créer un opérateur d’indices pour une classe Masortingx? à partir de la FAQ C ++.

Il n’est pas possible de surcharger l’opérateur [] pour accepter plusieurs arguments, mais une alternative consiste à utiliser le modèle de proxy .

En deux mots: a[x][y] , la première expression ( a[x] ) renverrait un type différent, nommé type proxy, qui aurait un autre operator[] . Il appellerait quelque chose comme _storedReferenceToOriginalObject->At(x,y) de la classe d’origine.

Vous ne pourrez pas faire a[x,y] , mais je suppose que vous vouliez quand même surcharger la syntaxe de tableau 2D de style C ++ habituelle.

Il y a une petite astuce que vous pouvez faire avec la syntaxe d’initialisation uniforme disponible dans C ++ 11. Au lieu de prendre directement l’index, vous prenez 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]; } 

Et puis utilisez la nouvelle syntaxe:

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

Par souci d’exhaustivité: Il existe un moyen d’utiliser réellement l’opérateur avec plusieurs arguments, s’il ne s’agit pas de types de données de base, à savoir en surchargeant l’opérateur de virgule et non l’opérateur parent.

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

Déni de responsabilité: à mon avis, surcharger l’opérateur de virgule est sujet aux erreurs et rend le code plus obscur, et vaut la peine d’être considéré uniquement dans des cas plus exotiques. J’ai ajouté cette réponse car je suis tombé sur une instance de ceci dans un code et il m’a fallu du temps pour comprendre que la clé n’était pas l’opérateur [] qui ne peut pas être surchargé avec plusieurs arguments), mais l’opérateur.

Tableaux à N dimensions de type et taille arbitraires en C ++:

Cette réponse est inspirée par la réponse de Pavel Radzivilovsky, merci pour cela. J’ai eu un peu de mal à réaliser l’implémentation, car c’était la première fois que je cherchais des modèles récursifs. J’aimerais partager ce que j’ai fait pour que les autres puissent comprendre plus rapidement que moi.

J’ai écrit une classe de modèle c ++ pour créer un tableau à n dimensions de type et de taille arbitraires. Il doit être instancié avec le type de tableau et le nombre de dimensions. La taille peut être modifiée dynamicment. J’ai donné ci-dessous une version de travail nue (dépouillée) de la façon de créer un tableau multidimensionnel auquel les éléments sont accessibles via des applications successives de l’ opérateur [] (par exemple, le tableau [x] [y] [z]). Cette version ne peut gérer que les tableaux de dimension n> 1. La fonction principale montre comment créer un tableau à 4 dimensions d’entiers comme exemple.

EDIT : gardez à l’esprit que l’exemple ci-dessous est minimal pour la lisibilité, en ce sens qu’il ne désalloue pas le tableau et ne vérifie pas non plus les limites d’access. L’ajout de ceci est sortingvial et laissé au programmeur.

 #include  #include  template  struct array { array() : data(NULL), offset((int*) malloc(sizeof(int)*N)){} array(T *data, int *offset) : data(data), offset(offset){} array operator[](int i){return array(&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  struct array{ array(T *data, int *offset) : data(data){} T& operator[](int i){return data[i];} T *data; }; int main () { array 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; } 

Prendre plaisir.