clearing all members of a class

[lallous]

Hello,

Given:

class X
{
int x, y; // and many many more....
X()
{
memset((void*)this, 0, sizeof(X));
}
};

Is this a good way to clear *all* members of a class?

--
Elias

[Karthik Kumar]

lallous wrote:

Hello,

Given:

class X
{
int x, y; // and many many more....
X()
{
memset((void*)this, 0, sizeof(X));
}
};

Is this a good way to clear *all* members of a class?

This is definitely inviting trouble.

You are making the assumption that -
sizeof (X) = sizeof(x) + sizeof(y) ( sum of individual
variables ), which is not correct .

What if the class got a virtual members ,
and hence a VTBL (virtual table) is constructed.
You are going to overwrite that too .
Let's see this example here.

#include <iostream>

using std::cout;
using std::endl;

class A {
public:
virtual void doNothing() = 0;

void erase() {
memset((void*)this, 0, sizeof(A));
}
private :
int a;
};

class B : public A {

public:
void doNothing() { }
};

int main() {
A * p = new B;
cout << sizeof(A) << " " << sizeof(int) << endl;
p->erase(); //Oops - You are erasing the VTBL here.
//How will I know my type from now on ?

cout << sizeof(A) << " " << sizeof(int) << endl;
p->doNothing(); //Segmentation fault ....
delete p;
}
And this is extremely non-intuitive and buggy.
That explains why you should never use this.

--
Karthik.

[Ioannis Vranos]

lallous wrote:

Hello,

Given:

class X
{
int x, y; // and many many more....
X()
{
memset((void*)this, 0, sizeof(X));
}
};

Is this a good way to clear *all* members of a class?

No. You can do this:

class X
{
int x, y; // and many many more....
X()
{
x=y=0;
}
};


--
Ioannis Vranos

http://www23.brinkster.com/noicys

[Thomas Matthews]

Ioannis Vranos wrote:

lallous wrote:

Hello,

Given:

class X
{
int x, y; // and many many more....
X()
{
memset((void*)this, 0, sizeof(X));
}
};

Is this a good way to clear *all* members of a class?

No. You can do this:

class X
{
int x, y; // and many many more....
X()
{
x=y=0;
}
};

Or using initialization lists:
class X
{
int x;
int y;
X()
: x(0), y(0)
{ ; }
};

--
Thomas Matthews

C++ newsgroup welcome message:
http://www.slack.net/~shiva/welcome.txt
C++ Faq: http://www.parashift.com/c++-faq-lite
C Faq: http://www.eskimo.com/~scs/c-faq/top.html
alt.comp.lang.learn.c-c++ faq:
http://www.comeaucomputing.com/learn/faq/
Other sites:
http://www.josuttis.com -- C++ STL Library book
http://www.sgi.com/tech/stl -- Standard Template Library

[Ioannis Vranos]

Thomas Matthews wrote:

Or using initialization lists:
class X
{
int x;
int y;
X()
: x(0), y(0)
{ ; }
};

Yes, I used that notion because of the comment // and many many more....
(variables). In which case he should use vectors or something, but
anyway. :-)


--
Ioannis Vranos

http://www23.brinkster.com/noicys

[Ioannis Vranos]

Thomas Matthews wrote:

Or using initialization lists:
class X
{
int x;
int y;
X()
: x(0), y(0)
{ ; }
};

';' is not needed inside the X() body. :-)


--
Ioannis Vranos

http://www23.brinkster.com/noicys

[lallous]

"Karthik Kumar" <ka*******************@yahoo.com> wrote in message
news:41e39488$1@darkstar...

lallous wrote:

Hello,

Given:

class X
{
int x, y; // and many many more....
X()
{
memset((void*)this, 0, sizeof(X));
}
};

Is this a good way to clear *all* members of a class?

This is definitely inviting trouble.

You are making the assumption that -
sizeof (X) = sizeof(x) + sizeof(y) ( sum of individual
variables ), which is not correct .

What if the class got a virtual members ,
and hence a VTBL (virtual table) is constructed.
You are going to overwrite that too .
Let's see this example here.

#include <iostream>

using std::cout;
using std::endl;

class A {
public:
virtual void doNothing() = 0;

void erase() {
memset((void*)this, 0, sizeof(A));
}
private :
int a;
};

class B : public A {

public:
void doNothing() { }
};

int main() {
A * p = new B;
cout << sizeof(A) << " " << sizeof(int) << endl;
p->erase(); //Oops - You are erasing the VTBL here.
//How will I know my type from now on ?

cout << sizeof(A) << " " << sizeof(int) << endl;
p->doNothing(); //Segmentation fault ....
delete p;
}
And this is extremely non-intuitive and buggy.
That explains why you should never use this.

What if this was a simple struct that is not to be extended /
subclasses...is memset() healthy?

--
Elias

[lallous]

"Ioannis Vranos" <iv*@remove.this.grad.com> wrote in message
news:1105440058.5756@athnrd02...

lallous wrote:

Hello,

Given:

class X
{
int x, y; // and many many more....
X()
{
memset((void*)this, 0, sizeof(X));
}
};

Is this a good way to clear *all* members of a class?

No. You can do this:

class X
{
int x, y; // and many many more....
X()
{
x=y=0;
}
};

Hello

I am aware of this method, however what if I got lots of member
variables...should I be initializing them individually one by one?
I used memset() to clear all the data members.

--
Elias

[Ioannis Vranos]

lallous wrote:

Hello

I am aware of this method, however what if I got lots of member
variables...should I be initializing them individually one by one?
Yes.
I used memset() to clear all the data members.

You shouldn't. For instance for floating point variables this method is
not safe. If you have the need to use many variables of the same built
in type, then perhaps you should use a vector of them, which also
initialises them to 0.


--
Ioannis Vranos

http://www23.brinkster.com/noicys

[Karl Heinz Buchegger]

lallous wrote:

I am aware of this method, however what if I got lots of member
variables...should I be initializing them individually one by one?
I used memset() to clear all the data members.

Don't.
memset(), memcpy(), ... have their usage even in C++
But those functions are far to dangerous and don't fit very
well in an Object oriented world. Their usage should be
restricted to situations where you deal with bytes on a
very hardware-near level only.

Everything else is asking for troubles in the long run.

--
Karl Heinz Buchegger
kb******@gascad.at