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

Question

Puis-je définir en C ++ un opérateur de tableau qui accepte plusieurs arguments? Je l'ai essayé comme ça:

 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
 

Answer 1

Non, vous ne pouvez pas surcharger operator[] pour accepter plusieurs arguments. Vous pouvez à la place surcharger operator() . Voir [13.10] Comment créer un opérateur d'indice pour une classe Matrix? de la FAQ comp.lang.c ++.

Answer 2

Il n'est pas possible de surcharger l' [] de l'opérateur pour qu'il accepte plusieurs arguments, mais une alternative est d'utiliser le modèle de proxy.

En deux mots: a[x][y], la première expression (a[x]) serait de retour d'un autre type, nommé type de proxy, ce qui aurait un autre operator[]. Il appelle quelque chose comme _storedReferenceToOriginalObject->At(x,y) de la classe d'origine.

Vous ne serez pas en mesure de le faire a[x,y], mais je suppose que vous avez voulu surcharger l'habitude C++-style de tableau 2D de la syntaxe, de toute façon.

Answer 3

N-dimensions des tableaux de type arbitraire et de la taille en C++:

Cette réponse est inspiré par la réponse de Pavel Radzivilovsky, merci pour ça. J'ai eu un peu de mal à réaliser la mise en œuvre, comme c'était mon premier coup de couteau à récursive modèles. J'aimerais partager ce que j'ai fait ce que les autres peuvent comprendre plus rapidement que je l'ai fait.

J'ai écrit en c++ une classe de modèle pour créer un n-dimensions tableau de l'arbitraire du type et de la taille. Il doit être instancié avec le type du tableau et le nombre de dimensions. La taille peut être modifiée dynamiquement. J'ai donné ci-dessous à nu (stripped) version de travail de façon à créer un tableau multidimensionnel dont les éléments peuvent être accessibles par application successive de l' opérateur[] (par exemple, tableau[x][y][z]). Cette version ne peut gérer que des matrices de dimension n>1. La fonction principale montre comment créer un à 4 dimensions tableau d'entiers par exemple.

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

Profitez de.