overloading the [] operator

[Joseph Paterson]

Hello,

I've created a class to store 2 dimensional matrices, and I've been
trying to overload the [] operator, so access to the elements of the
matrix is easy. I have 3 private variables, _m, _row and _col which are
respectively the array to store the data in, the number of rows and the
number of columns. _m is of type T, and is size _row * _col * sizeof
(T).

I've managed to overload the subscript operator like this:
T & operator [] (int n)
{
return (_m[n * _col]);
}

but I don't understand why you can't do:
T * operator [] (int n)
{
return (&_m[n * _col]);
}

instead. The first one works fine, but with the second one when I try
something like m[0][0] = 100.0, m[0][0] comes up as being an invalid
lvalue.
Could someone help me out here?

Cheers,

- Joseph Paterson

[Kai-Uwe Bux]

Joseph Paterson wrote:

Hello,

I've created a class to store 2 dimensional matrices, and I've been
trying to overload the [] operator, so access to the elements of the
matrix is easy. I have 3 private variables, _m, _row and _col which are
respectively the array to store the data in, the number of rows and the
number of columns. _m is of type T, and is size _row * _col * sizeof
(T).

I've managed to overload the subscript operator like this:
T & operator [] (int n)
{
return (_m[n * _col]);
}

but I don't understand why you can't do:
T * operator [] (int n)
{
return (&_m[n * _col]);
}

instead. The first one works fine, but with the second one when I try
something like m[0][0] = 100.0, m[0][0] comes up as being an invalid
lvalue.

Please, hit the FAQ. This topic has been beaten to death repeatedly in this
group and gives rise to a little bit flaming every once in a while. The
gist of it is:

a) Consider using operator()( row, col ) instead of operartor[][]. It is
easier to implement cleanly: the problem with [][]-syntax is that upon a
first try, you will settle on a quick and dirty solution where operator[]
return something like a vector (just as you indicate in your post). This is
bound to expose implementation details of the matrix class, which is
considered poor design. Details are in the FAQ.

b) If you are hard-headed / strongly-willed and determined to support the
[][]-syntax, overload operator[] to return a proxy object that contains a
reference to your matrix and knows the row. The proxy class itself will
overload operator[] (const) to return a (const) reference to the entry.
This trick allows to separate implementation and interface. Details are in
the FAQ.

c) If your matrix class aims to be more than merely a container, i.e., if
you plan on supporting linear algebra, please consider using one of the
many available libraries. A full-fledged matrix class is a project of
considerable size and difficulty. Don't call that upon yourself without
legitimate need unless you are looking for a character building and highly
educational exercise.
Best

Kai-Uwe Bux

[Joseph Paterson]

I actually am trying to implement a fully fledged matrix class. I'm
starting on a graphics engine, and I want to fully support matrices and
all possible operations you can do on them :) It's fun, and a learning
experience.

I'll have a look at the FAQ - thanks!

- Joseph Paterson

[Kai-Uwe Bux]

Joseph Paterson wrote:

I actually am trying to implement a fully fledged matrix class.
Oh well.
I'm starting on a graphics engine, and I want to fully support matrices
and all possible operations you can do on them :) It's fun, and a learning
experience.
Ok, you asked for it:

a) You may want to read up on expression templates. When it comes to things
like adding vectors / matrices, the introduction of temporaries truly
becomes a performance issue. Expression templates are used in most state of
the art matrix libraries to deal with this problem. If you are really
headed for a graphics engine, performance will become an issue pretty soon.

b) As far as syntactic sugar (like [][]-notation) is concerned, I found that
the most interesting use of proxy classed for column and row vectors is to
support elementary operations like so:

A.row(i) += some_scalar * A.row(j);

or

swap( A.col(i), A.col(j) );

However, to make that work is a little bit challenging.

I'll have a look at the FAQ - thanks!

That is a good point to start. You may also want to pay attention to what it
has to say about floating point arithmetic (given that you are very likely
bound to do numerical linear algebra). Be warned that numerical linear
algebra is difficult and there are many traps (beyond the ones in the FAQ)
that are hard to spot. What looks like a correct algorithm from your Linear
Algebra text can turn out to be numerically unstable.
Have fun

Kai-Uwe Bux

[Noah Roberts]

Kai-Uwe Bux wrote:

Joseph Paterson wrote:

Hello,

I've created a class to store 2 dimensional matrices, and I've been
trying to overload the [] operator, so access to the elements of the
matrix is easy. I have 3 private variables, _m, _row and _col which are
respectively the array to store the data in, the number of rows and the
number of columns. _m is of type T, and is size _row * _col * sizeof
(T).

Please, hit the FAQ. This topic has been beaten to death repeatedly in this
group and gives rise to a little bit flaming every once in a while. The
gist of it is:

Yes, read the FAQ on why matrix shouldn't have [].

Also, I can't find it but it must be in the faq somewhere...all your
variable names are broken. Don't use anything that starts with an
underscore. An undercore *postfix* is now commonly used to identify
member variables...I don't personally see the need but if you do, think
about doing it that way...it won't run into conflicts with the std lib
or implementation.

[Noah Roberts]

Joseph Paterson wrote:

Hello,

I've created a class to store 2 dimensional matrices, and I've been
trying to overload the [] operator, so access to the elements of the
matrix is easy. I have 3 private variables, _m, _row and _col which are
respectively the array to store the data in, the number of rows and the
number of columns. _m is of type T, and is size _row * _col * sizeof
(T).

I've managed to overload the subscript operator like this:
T & operator [] (int n)
{
return (_m[n * _col]);
}

but I don't understand why you can't do:
T * operator [] (int n)
{
return (&_m[n * _col]);
}

instead. The first one works fine, but with the second one when I try
something like m[0][0] = 100.0, m[0][0] comes up as being an invalid
lvalue.
Could someone help me out here?

You are not providing enough information. The first should NOT work
and the second should based on my interpretation of your post. But I
don't know what _m is or what T is so I'm just guessing. At any rate,
I can't answer your question as I obviously don't understand the
problem.

[Kai-Uwe Bux]

Noah Roberts wrote:

Kai-Uwe Bux wrote:

Joseph Paterson wrote:

> Hello,
>
> I've created a class to store 2 dimensional matrices, and I've been
> trying to overload the [] operator, so access to the elements of the
> matrix is easy. I have 3 private variables, _m, _row and _col which are
> respectively the array to store the data in, the number of rows and the
> number of columns. _m is of type T, and is size _row * _col * sizeof
> (T).

[snip]
Also, I can't find it but it must be in the faq somewhere...all your
variable names are broken. Don't use anything that starts with an
underscore.

[reasonable recommendation snipped]

You cannot find it because it should not be there. The reserved identifiers
are [17.4.3.1.2]:

* any identifier that contains a *double* underscore "__".
* any identifier that begins with "_" followed by a *capital* letter.
* any identifier that begins with "_" is reserved in the *global namaspace*.

So, for local variables and parameters, the names are fine.

Best

Kai-Uwe

[Axter]

Kai-Uwe Bux wrote:

Noah Roberts wrote:

Kai-Uwe Bux wrote:

Joseph Paterson wrote:

> Hello,
>
> I've created a class to store 2 dimensional matrices, and I've been
> trying to overload the [] operator, so access to the elements of the
> matrix is easy. I have 3 private variables, _m, _row and _col which are
> respectively the array to store the data in, the number of rows and the
> number of columns. _m is of type T, and is size _row * _col * sizeof
> (T).

[snip]

Also, I can't find it but it must be in the faq somewhere...all your
variable names are broken. Don't use anything that starts with an
underscore.

[reasonable recommendation snipped]

You cannot find it because it should not be there. The reserved identifiers
are [17.4.3.1.2]:

* any identifier that contains a *double* underscore "__".
* any identifier that begins with "_" followed by a *capital* letter.
* any identifier that begins with "_" is reserved in the *global namaspace*.

So, for local variables and parameters, the names are fine.

You should never name a local variable with an underscore followed by
an upper case letter.
IAW C++ standards that you quoted, names that begin with an underscore
and are followed by an uppercase letter, can be used for anything by
the implementation.
That means the implementation can use macros for this.
Example:
#define _T(x) L##x

If you have a local variable with the name _T, it will fail to be
portable to an implementation that uses above macro.
IAW C++ standard, a name that begins with an underscore and then
followed by a lower case letter are reserved for the implementation in
the global namespace.
So technically speaking, IAW C++ standard, you could name a local
variable that begins with an underscore and is followed by a lower case
letter. And your code should be portable.

However, this is not true in practice, because some implementations
also use these types of names with macros, which invade all namespaces,
and not just the global namespace.
IAW with the C++ standard, the following code should be portable:
int foo(int _itot, int _ttoi)
{
return _itot + _ttoi;
}

But the above code is not portable to windows platform that reference
tchar.h, because this header has macros named _itot and _ttoi.

So I recommend that leading undescore not be used at all, even in local
variables.
It doesn't make the code work any better, and it can make your code
non-portable to some common implementations .

[Axter]

Joseph Paterson wrote:

Hello,

I've created a class to store 2 dimensional matrices, and I've been
trying to overload the [] operator, so access to the elements of the
matrix is easy. I have 3 private variables, _m, _row and _col which are
respectively the array to store the data in, the number of rows and the
number of columns. _m is of type T, and is size _row * _col * sizeof
(T).

I've managed to overload the subscript operator like this:
T & operator [] (int n)
{
return (_m[n * _col]);
}

but I don't understand why you can't do:
T * operator [] (int n)
{
return (&_m[n * _col]);
}

instead. The first one works fine, but with the second one when I try
something like m[0][0] = 100.0, m[0][0] comes up as being an invalid
lvalue.
Could someone help me out here?

It should be something like the following:
T* operator[](int n) {return m_ + (col_*n);}

Check out the following link for an example:
http://code.axter.com/dynamic_2d_array.h

[Kai-Uwe Bux]

Axter wrote:

Kai-Uwe Bux wrote:

Noah Roberts wrote:

>
> Kai-Uwe Bux wrote:
>> Joseph Paterson wrote:
>>
>> > Hello,
>> >
>> > I've created a class to store 2 dimensional matrices, and I've been
>> > trying to overload the [] operator, so access to the elements of the
>> > matrix is easy. I have 3 private variables, _m, _row and _col which
>> > are respectively the array to store the data in, the number of rows
>> > and the number of columns. _m is of type T, and is size _row * _col
>> > * sizeof (T). [snip]

>
> Also, I can't find it but it must be in the faq somewhere...all your
> variable names are broken. Don't use anything that starts with an
> underscore.

[reasonable recommendation snipped]

You cannot find it because it should not be there. The reserved
identifiers are [17.4.3.1.2]:

* any identifier that contains a *double* underscore "__".
* any identifier that begins with "_" followed by a *capital* letter.
* any identifier that begins with "_" is reserved in the *global
namaspace*.

So, for local variables and parameters, the names are fine.

You should never name a local variable with an underscore followed by
an upper case letter.

IAW C++ standards that you quoted, names that begin with an underscore
and are followed by an uppercase letter, can be used for anything by
the implementation.
That means the implementation can use macros for this.
Example:
#define _T(x) L##x

If you have a local variable with the name _T, it will fail to be
portable to an implementation that uses above macro.

Note: the names the OP used are not of this form! We are all in agreement
about names like "_T".

IAW C++ standard, a name that begins with an underscore and then
followed by a lower case letter are reserved for the implementation in
the global namespace.
So technically speaking, IAW C++ standard, you could name a local
variable that begins with an underscore and is followed by a lower case
letter. And your code should be portable.
That is why the OP's names are fine.
However, this is not true in practice, because some implementations
also use these types of names with macros, which invade all namespaces,
and not just the global namespace.
Those are broken implementations .
IAW with the C++ standard, the following code should be portable:
int foo(int _itot, int _ttoi)
{
return _itot + _ttoi;
}

But the above code is not portable to windows platform that reference
tchar.h, because this header has macros named _itot and _ttoi.
tchar.h is a not a standard header. If you use third-party libraries, all
sorts of new macros could be defined. No naming scheme will prevent clashes
with certainty.
So I recommend that leading undescore not be used at all, even in local
variables.
Although I would agree that the advice is sound and reasonable from a
practical point of view (and from an aesthetical angle, too: leading
underscores are plain ugly); I would also maintain that workarounds for
problems with tchar.h and other third-party headers are not exactly topical
in this group.
It doesn't make the code work any better, and it can make your code
non-portable to some common implementations .

Best

Kai-Uwe Bux