neath@solar-1.stars.flab.Fujitsu.JUNET (05/15/89)
I am trying to determine what support there is in C++ for multi-dimensional
arrays within a class. For example, the following class definition attempts to
implement an array of pointers to vectors. Now, I know that I can overload
operator[], but what I would really like to be able to do is overload the
ficticious operator[][]. How can I achieve this functionality? Am I missing
something very obvious?
typedef int Type
class C {
private:
int r, c;
Type** data;
public:
X (int row, int col) {
this->r = row; this->c = col;
this->data = new Type* [row];
for (int i = 0; i < col; i++)
this->data[i] = new Type [col];
}
~X () {
for (int i = 0; i < r; i++)
delete this->data[i];
delete this->data;
}
inline Type* operator[] (int row) {
return this->data[row];
}
inline Type& operator[][] (int row, int col) {
return this->data[row][col];
}
};
Regards
Martin Neath <neath@dsg.ti.com>
------------------------------------------------------------------------
DISCLAIMER: As always, the opinions expressed above are strictly my own
and do not reflect those of my employer, Texas Instruments.
------------------------------------------------------------------------daniel@saturn.ucsc.edu (Daniel Edelson) (05/17/89)
In article <NEATH.89May15154230@solar-1.stars.flab.Fujitsu.JUNET> neath@solar-1.stars.flab.Fujitsu.JUNET writes: >I am trying to determine what support there is in C++ for multi-dimensional >arrays within a class. For example, the following class definition attempts to >implement an array of pointers to vectors. Now, I know that I can overload >operator[], but what I would really like to be able to do is overload the >ficticious operator[][]. How can I achieve this functionality? Am I missing >something very obvious? >Martin Neath <neath@dsg.ti.com> You need the type of A to be different from the type of A[i] so that the [] operator applied to expressions of each type works correctly. Example: class Element { /* stuff */ }; class Vector { private: Element * col; // an array of elements ... public: Element & operator[](int index2); ... }; class Array{ private: Vector * rows; // an array of vectors ... public: Vector & operator[](int index1); ... }; Let A be of type Array, A[i] is of type Vector and A[i][j] is of type Element. The two instances of the subscripting operator in the expression A[i][j] are not the same implementation, but are both [] operators. daniel edelson daniel@saturn.ucsc.edu
heimir@rhi.hi.is (Heimir Thor Sverrisson) (06/20/91)
Hi fellow Netlanders,
is there anyone out there that can help me understand why the following
code works! I'm trying to build a class that contains integer data
that should be organized as a two-dimensional array (of fixed dimensions).
I was trying to implement an operator that would allow me to use code like:
Status st;
st[TOTAL][COD]=123;
where Status is the name of my class and the [][] notation would allow me
to manipulate that element in my private array. On top of the well known
problem of not being able to detect if I'm being used as an l- or r-value
I also ran into trouble defining the operator(s) involved to do this.
What I ended up with were two operator[]'s and the code did actually work
in g++ 1.39. The implementation is :
int* Status::operator[](int index)
{
return stat[index]; // private: int stat[i][j]
}
int& Status::operator[](int* iarr)
{
return *iarr;
}
And I'm asking you why does this work?
If it is not a compiler bug/feature, how can I access the latter index (COD)
from within the second member function above (i.e. to test it's range)?
Following is the whole code that I used to test this:
---------------------------------------------------------------------------
// Status.h
// Declare the Status-class.
//
#ifndef Status_h
#define Status_h
#define S_LINES 13
#define S_COL 10
class Status {
public:
Status(int num);
int* operator[](int index);
int& operator[](int *iarr);
~Status();
private:
stat[S_LINES][S_COL];
int recalc;
};
#endif
---------------------------------------------------------------------------
// Status.cc
// Implementation of the Status-class.
//
#include "Status.h"
Status::Status(int num)
{
for(int i=0; i < S_LINES; i++)
for(int j=0; j < S_COL; j++)
stat[i][j] = i*S_COL+j; // Set to zero!!
}
int* Status::operator[](int index)
{
return stat[index];
}
int& Status::operator[](int* iarr)
{
return *iarr;
}
---------------------------------------------------------------------------
// tStatus.cc
//
// Test the status class
//
#include <stream.h>
#include "Status.h"
main()
{
Status st(1337);
for(int i=0; i < S_LINES; i++){
for(int j=0; j < S_COL; j++)
cout << st[i][j] << " ";
cout << "\n";
}
}
---------------------------------------------------------------------------
I hope somebody out there can clear up this matter, 'cause in the meantime
I'll have to make the 'stat' array public, and cannot test range, nor
detect potential recalc operation :-(
--
Heimir Thor Sverrisson heimir@plusplus.is
Laugavegi 13
101 Reykjavik
Icelandjuul@diku.dk (Anders Juul Munch) (06/21/91)
heimir@rhi.hi.is (Heimir Thor Sverrisson) writes: HTS>Hi fellow Netlanders, HTS>is there anyone out there that can help me understand why the following HTS>code works! I'm trying to build a class that contains integer data HTS>that should be organized as a two-dimensional array (of fixed dimensions). HTS>I was trying to implement an operator that would allow me to use code like: HTS> Status st; HTS> st[TOTAL][COD]=123; HTS>where Status is the name of my class and the [][] notation would allow me HTS>to manipulate that element in my private array. On top of the well known HTS>problem of not being able to detect if I'm being used as an l- or r-value HTS>I also ran into trouble defining the operator(s) involved to do this. HTS>What I ended up with were two operator[]'s and the code did actually work HTS>in g++ 1.39. The implementation is : HTS> int* Status::operator[](int index) HTS> { HTS> return stat[index]; // private: int stat[i][j] HTS> } HTS> int& Status::operator[](int* iarr) HTS> { HTS> return *iarr; HTS> } HTS>And I'm asking you why does this work? HTS>If it is not a compiler bug/feature, how can I access the latter index (COD) HTS>from within the second member function above (i.e. to test it's range)? HTS>[Remainder omitted.] What is happening is this: First, 'stat[TOTAL]' is evaluated. This is done by 'Status::operator[](int)', because 'stat' is of class 'Status', and the argument matches. 'Status::operator[](int)' returns an 'int*'. This return value is then indexed by '[COD]'. However, as 'int*' is not a class type, no member function is being called this time. Instead, usual C array referencing is performed. Your second member function, 'Status::operator[](int*)' will never get called! Yes, it works, but this way you have no way to range check the second index. To get control of both indices is pretty hard, if you insist on using operator[]. If you don't, there is no problem, you could define an array access member function like this: int& Status::Stat(int firstIndex, int secondIndex) { // Check if indices are valid here. return stat[firstIndex][secondIndex]; } // The brackets aren't square, but what the heck . . . Status st; st(TOTAL,COD) = 123; If you insist on using operator[], it could be done using an intermediate class: class ArrayRow { int* row; public: ArrayRow(int* it) { row = it; } int& operator[](int secondIndex) { // Check range of secondIndex here. return row[secondIndex]; } }; ArrayRow Status::operator[](int firstIndex) { // Check range of firstIndex here. return ArrayRow(stat[i]); } This should work: You get all the range checking you want, and you can still use the usual []-s. The performance penanlty involved in creating the intermediate 'ArrayRow' object is negliable. - A good compiler might even optimize it away entirely. The cost is that the code gets distributed over two classes in a not very intuitive manner. Indeed, the intermediate class is a trick which would make your code a lot more confusing. -- Anders Munch juul@diku.dk University of Copenhagen Denmark