silly question about inheritance

G

Gernot Frisch

Hi,

assume this situation:

class primitive
{
virtual void IsPointInside() =NULL;
};
class sphere : public primitive
{ ... };
class tetrahedron : public primitive
{ ... };

std::vector<sphere > v_sphere;
std::vector<tetrahedron> v_tetrahedron;

// Can I do this:

std::vector<primitive*> v_pPrimitives;
for(i=v_sphere.begin; i!=v_sphere.end(); ++i)
v_pPrimitives.push_back(&*i);
....

// and call the v_pPrimitives.IsPointInside(); ??

<head scratch>

I can't store different types in a single array, but I can store their
pointers, no!?

--
-Gernot
int main(int argc, char** argv) {printf
("%silto%c%cf%cgl%ssic%ccom%c", "ma", 58, 'g', 64, "ba", 46, 10);}

________________________________________
Looking for a good game? Do it yourself!
GLBasic - you can do
www.GLBasic.com
 
J

John Harrison

Gernot Frisch said:
Hi,

assume this situation:

class primitive
{
virtual void IsPointInside() =NULL;
Click to expand...

NULL isn't guaranteed to be 0, so

virtual void IsPointInside() = 0 ;
};
class sphere : public primitive
{ ... };
class tetrahedron : public primitive
{ ... };

std::vector<sphere > v_sphere;
std::vector<tetrahedron> v_tetrahedron;

// Can I do this:

std::vector<primitive*> v_pPrimitives;
for(i=v_sphere.begin; i!=v_sphere.end(); ++i)
v_pPrimitives.push_back(&*i);
...

// and call the v_pPrimitives.IsPointInside(); ??
v_pPrimitives->IsPointInside();


<head scratch>

I can't store different types in a single array, but I can store their
pointers, no!?
Click to expand...


Well I would say that all you are storing is primitive*, but since those
primitive* will be pointing to objects whose type derives from primitive you
can use the usual virtual function mechanism.

It's really no different to this

primitive* p = new sphere();
p->IsPointInside();

john
 
S

Sharad Kala

Gernot Frisch said:
Hi,

assume this situation:

class primitive
{
virtual void IsPointInside() =NULL;
};
class sphere : public primitive
{ ... };
class tetrahedron : public primitive
{ ... };

std::vector<sphere > v_sphere;
std::vector<tetrahedron> v_tetrahedron;

// Can I do this:

std::vector<primitive*> v_pPrimitives;
for(i=v_sphere.begin; i!=v_sphere.end(); ++i)
i=v_sphere.begin()
v_pPrimitives.push_back(&*i);
Click to expand...
...

// and call the v_pPrimitives.IsPointInside(); ??
Click to expand...


v_pPrimitives->IsPointInside()

I don't see any problem now.

Sharad
 
G

Gernot Frisch

It's really no different to this

primitive* p = new sphere();
p->IsPointInside();
Click to expand...

One second... Then, if I have a
std::vector<primitive> prims;

can I push_back a sphere, which will keep all the additional sphere
specific information?

I get to thinking I never really understood about inheritances...
 
J

John Harrison

Gernot Frisch said:
One second... Then, if I have a
std::vector<primitive> prims;

can I push_back a sphere, which will keep all the additional sphere
specific information?
Click to expand...

No that is called object slicing, any additional information is lost. In
this case it wouldn't even compile because you have a pure virtual function
in primitive.

john
 
G

Gernot Frisch

John Harrison said:
No that is called object slicing, any additional information is
lost. In
this case it wouldn't even compile because you have a pure virtual
function
in primitive.

john
Click to expand...

So, let me put this together. If I write a wrapper that has a vector
of pointers, I can store all different types of objects and use their
common methods regardless of what type they are, right?
 
J

John Harrison

Gernot Frisch said:
So, let me put this together. If I write a wrapper that has a vector
of pointers, I can store all different types of objects and use their
common methods regardless of what type they are, right?
Click to expand...

Only if those methods are virtual but otherwise yes.

john
 
S

Sharad Kala

John Harrison said:
NULL isn't guaranteed to be 0, so
Click to expand...

I do agree that NULL is probably not the right way to declare the pure
virtual function. But I thought there was a guarantee in C++ that NULL
always evaluates to 0.

18.1/4 says -
"The macro NULL is an implementation-defined C++ null pointer constant in
this International Standard". This line refers to footnote 180 which reads -
"Possible definitions include 0 and 0L, but not (void*)0."

4.10/1 reads - "A null pointer constant is an integral constant expression
rvalue of integer type that evaluates to zero."
^^^^^^^^^^^^

btw, Comeau online rejects and VC8 accepts following code -
#define NULL 0L
class primitive
{
virtual void IsPointInside() = NULL;
};
int main(){}

I think probably Comeau is correct.

Sharad
 
G

Gernot Frisch

John Harrison said:
Only if those methods are virtual but otherwise yes.
Click to expand...

Yes, I know. If they are not (pure?) virtual, the base classes method
would be called (since it's a pointer to a base-type). Wow, thank you
so much. Now I can store different object types in a vector. I have to
provide a TypeOf function as well and then can use all common
functions on them. Really great!

Bye,
Gernot
 
J

John Harrison

Sharad Kala said:
I do agree that NULL is probably not the right way to declare the pure
virtual function. But I thought there was a guarantee in C++ that NULL
always evaluates to 0.

18.1/4 says -
"The macro NULL is an implementation-defined C++ null pointer constant in
this International Standard". This line refers to footnote 180 which reads -
"Possible definitions include 0 and 0L, but not (void*)0."

4.10/1 reads - "A null pointer constant is an integral constant expression
rvalue of integer type that evaluates to zero."
^^^^^^^^^^^^
Click to expand...

#define NULL (1 - 1)

I think that is a legal definition of NULL, but I doubt that

virtual void func() = NULL;

would compile. I'm assuming that the syntax of a pure virtual requires the
integer literal 0, not an expression that evaluates to zero.

john
 
A

Andrew Koenig

Gernot Frisch said:
Hi,

assume this situation:

class primitive
{
virtual void IsPointInside() =NULL;
};
class sphere : public primitive
{ ... };
class tetrahedron : public primitive
{ ... };

std::vector<sphere > v_sphere;
std::vector<tetrahedron> v_tetrahedron;

// Can I do this:

std::vector<primitive*> v_pPrimitives;
for(i=v_sphere.begin; i!=v_sphere.end(); ++i)
v_pPrimitives.push_back(&*i);
...

// and call the v_pPrimitives.IsPointInside(); ??
Click to expand...


Almost. v_pPrimitives is a vector of pointers, so you have to say

(*v_pPrimitives).IsPointInside();

or, equivalently,

v_pPrimitives->IsPointInside();

Note that changing the number of elements in v_sphere or v_tetrahedron might
reallocate the objects in those vectors, which would invalidate the pointers
in v_pPrimitives. If you want to use a technique such as this one, you
might be better off using std::deque, which does not move elements after
allocating them as long as new elements are allocated or deleted only at
either end of the deque.
 
S

Sharad Kala

John Harrison said:
#define NULL (1 - 1)

I think that is a legal definition of NULL, but I doubt that

virtual void func() = NULL;

would compile. I'm assuming that the syntax of a pure virtual requires the
integer literal 0, not an expression that evaluates to zero.
Click to expand...

I share your thoughts but VC8 doesn't complain about this code too -

#define NULL (1 - 1)
class primitive
{
virtual void IsPointInside() = NULL;
};

int main(){}

Comeau does crib though.

Sharad
 
J

JKop

I'm assuming that the syntax of a pure virtual requires
the integer literal 0, not an expression that evaluates to zero.
Click to expand...


I myself don't even think of the "= 0" as having any association
whatsoever with the assignment operator, nor with the integral literal
which is zero. "= 0" is just a funky little yoke you stick on the end of
the function declaration to specify that it's "pure".

I myself never write NULL anywhere in my code, I *always* use 0 in its
place; that's another reason why I wouldn't use it as the OP did.


-JKop
 
G

Gernot Frisch

JKop said:
I myself don't even think of the "= 0" as having any association
whatsoever with the assignment operator, nor with the integral
literal
which is zero. "= 0" is just a funky little yoke you stick on the
end of
the function declaration to specify that it's "pure".

I myself never write NULL anywhere in my code, I *always* use 0 in
its
place; that's another reason why I wouldn't use it as the OP did.
Click to expand...

I always use NULL where I set a pointer to 0L. It's bacause my IDE
highlights it in green and I like green... ;)
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Similar Threads

queue where I can delete in the middle? 3
a thread safe stack? 7
operator overloading... 5
a[3} slower than a.x; a.z; a.z 27
style: for(nth_elem_in_list, end_of_list; next) 1
linking to a .so object's functions? 1
pointer to function 4
reference to parent inherritance? 9

Members online

Total: 31 (members: 1, guests: 30)
Robots: 404

Forum statistics

Threads
473,755
Messages
2,569,536
Members
45,020
Latest member
GenesisGai

Latest Threads

Top