the pointer this

[Tony Johansson]

Hello experts!

Assume we have the definition of class Matrix below.
Now to my question how is it possible to have this expression (*this = m;)
in the copy constructor part of class Matris.
Isn't this a constant pointer to the current object and can't be changed.
Im I wrong?

class Matrix
{
public:
Matrix(int i=0, int j=0 : r(i), k(j), a(new double[r*k]) {}
Matrix(const Matrix& m) : a(0)
{
*this = m; //?????????????
}
~Matrix()
{ delete [] a; }

int ant_rad()
{ return r; }

int ant_kol()
{ return k; }

Matrix& operator= (const Matris&);
double operator() (int i, int j);

private:
double *a;
int r, k;
};

Many thanks

//Tony

[John Carson]

"Tony Johansson" <jo*****************@telia.com> wrote in message
news:3W*********************@newsc.telia.net

Hello experts!

Assume we have the definition of class Matrix below.
Now to my question how is it possible to have this expression (*this
= m;) in the copy constructor part of class Matris.
Isn't this a constant pointer to the current object and can't be
changed. Im I wrong?

You need to distinguish between a constant pointer and a pointer to a
constant object. this is the former, not the latter, and it is only the
latter that would rule out *this = m; since the pointer is not being
changed, only the contents of the object being pointed to.

--
John Carson

[Richard Herring]

In message <3W*********************@newsc.telia.net>, Tony Johansson
<jo*****************@telia.com> writes

Hello experts!

Assume we have the definition of class Matrix below.
Now to my question how is it possible to have this expression (*this = m;)
in the copy constructor part of class Matris.
Isn't this a constant pointer to the current object and can't be changed.
That's correct. 'this' is a constant pointer to the current Matrix
object. The *pointer* can't be changed, but what it points to can. *this
is a reference to the current object, which can be changed.
Im I wrong?
Matrix * const is not the same thing as Matrix const *.
class Matrix
{ [snip irrelevant details]public:
Matrix(int i=0, int j=0 : r(i), k(j), a(new double[r*k]) {}
Matrix(const Matrix& m) : a(0)
{
*this = m; //?????????????
No problem. That invokes operator= on the current object. It doesn't
change the pointer.
}
~Matrix()
{ delete [] a; }
Matrix& operator= (const Matris&);
You don't show the definition of this function. It's a potential source
of problems (see the following comment)

private:
double *a;
int r, k;
};

Many thanks

As a matter of style, it's often better to write operator= in terms of
the copy constructor using the copy-and-swap idiom, rather than vice
versa. The assignment operator has to deal with the complication of
disposing of the previous state of the object, which the constructor
doesn't.

--
Richard Herring

[Earl Purple]

Richard Herring wrote:

As a matter of style, it's often better to write operator= in terms of
the copy constructor using the copy-and-swap idiom, rather than vice
versa. The assignment operator has to deal with the complication of
disposing of the previous state of the object, which the constructor
doesn't.

Indeed, but in this case, using std::vector instead of an array would
mean you would not have to implement the big 3 at all
(copy-construction, assignment and destruction) as all 3 would work
with their default implementations.

By the way, what does the standard do if you call new[] with a 0
argument? (I wouldn't know because I never do it, I always use vector).

You might also want to make the class a template. Why specify double as
the type?

[Richard Herring]

In message <11*********************@g43g2000cwa.googlegroups. com>, Earl
Purple <ea*********@yahoo.com> writes

Richard Herring wrote:

As a matter of style, it's often better to write operator= in terms of
the copy constructor using the copy-and-swap idiom, rather than vice
versa. The assignment operator has to deal with the complication of
disposing of the previous state of the object, which the constructor
doesn't.
Indeed, but in this case, using std::vector instead of an array would
mean you would not have to implement the big 3 at all
(copy-construction, assignment and destruction) as all 3 would work
with their default implementations.

Indeed indeed. That's a big win: the compiler is far better at keeping
track of proliferating member variables than I am.

By the way, what does the standard do if you call new[] with a 0
argument? (I wouldn't know because I never do it, I always use vector).
It returns a distinct non-null pointer to an array with no elements
(5.3.4/7)

By the way, does it constitute a memory leak if you fail to delete[] it?
You might also want to make the class a template. Why specify double as
the type?

*He* might. I haven't designed yet another 2D matrix class for several
years now ;-)

--
Richard Herring

[msalters]

Richard Herring schreef:

In message <11*********************@g43g2000cwa.googlegroups. com>, Earl
Purple <ea*********@yahoo.com> writes

By the way, what does the standard do if you call new[] with a 0
argument? (I wouldn't know because I never do it, I always use vector).

It returns a distinct non-null pointer to an array with no elements
(5.3.4/7)

By the way, does it constitute a memory leak if you fail to delete[] it?

Yes. There are only a limited number of distinct pointers, so you can
run out of legal return values. That means new[] eventually will throw
a
std::bad_alloc. I call that a memory leak.

HTH,
Michiel Salters

[E. Robert Tisdale]

Tony Johansson wrote:

Assume we have the definition of class Matrix below.

[snip]

Take a look at
The C++ Scalar, Vector, Matrix and Tensor class Library

http://www.netwood.net/~edwin/svmtl/

Also, take a look at
The Object-Oriented Numerics Page

http://www.oonumerics.org/oon/