Est-il possible de surcharger [] opérateur deux fois ? Pour permettre, quelque chose comme ça : function[3][3] (comme dans un tableau à deux dimensions).
Si cela est possible, j'aimerais voir un exemple de code.
Vous pouvez surcharger operator[] pour retourner un objet sur lequel vous pouvez utiliser operator[] encore une fois pour obtenir un résultat.
class ArrayOfArrays {
public:
ArrayOfArrays() {
_arrayofarrays = new int*[10];
for(int i = 0; i < 10; ++i)
_arrayofarrays[i] = new int[10];
}
class Proxy {
public:
Proxy(int* _array) : _array(_array) { }
int operator[](int index) {
return _array[index];
}
private:
int* _array;
};
Proxy operator[](int index) {
return Proxy(_arrayofarrays[index]);
}
private:
int** _arrayofarrays;
};Ensuite, vous pouvez l'utiliser comme :
ArrayOfArrays aoa;
aoa[3][5];Il s'agit juste d'un exemple simple, vous voudrez ajouter un tas de vérifications de limites et autres, mais vous avez compris l'idée.
Pourrait utiliser un destructeur. Et Proxy::operator[] devrait retourner int& pas seulement int
Mieux vaut utiliser std::vector<std::vector<int>> pour éviter les fuites de mémoire et les comportements étranges lors de la copie.
Les deux Boost's multi_array y extent_gen sont de bons exemples de cette technique. boost.org/doc/libs/1_57_0/libs/multi_array/doc/
Une expression x[y][z] exige que x[y] évalue un objet d qui soutient d[z] .
Cela signifie que x[y] doit être un objet avec un operator[] qui s'évalue en un "objet proxy" qui également soutient un operator[] .
C'est la seule façon de les enchaîner.
Alternativement, la surcharge operator() pour prendre plusieurs arguments, de sorte que vous pourriez invoquer myObject(x,y) .
Pourquoi la surcharge des parenthèses permet-elle d'obtenir deux entrées alors que l'on ne peut pas faire de même avec les crochets ?
Vous pouvez utiliser un objet proxy, quelque chose comme ceci :
#include <iostream>
struct Object
{
struct Proxy
{
Object *mObj;
int mI;
Proxy(Object *obj, int i)
: mObj(obj), mI(i)
{
}
int operator[](int j)
{
return mI * j;
}
};
Proxy operator[](int i)
{
return Proxy(this, i);
}
};
int main()
{
Object o;
std::cout << o[2][3] << std::endl;
} Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.
27 votes
En fait, il est beaucoup plus simple et plus courant de surcharger
operator()(int, int)au lieu de...2 votes
Pourquoi recréer la roue ? Il suffit d'utiliser
std::vectoravec un constructeur de plage : stackoverflow.com/a/25405865/6103510 votes
Ou vous pouvez simplement utiliser quelque chose comme
using array2d = std::array<std::array<int, 3>, 3>;