derivation doubts

[josh]

Hi I have the following doubts:

I have 2 class Point and the derived Circle. Point doesn't have
virtual function.

Now can you explain me when came the conversion (compile or run time)
when I do:

Point *pointPtr = 0, p( 30, 50 );
Circle *circlePtr = 0, c( 2.7, 120, 89 );

1
*************** *************** *************** *************** *************** *****
// Treat a Circle as a Point (see only the base class part)
pointPtr = &c; // assign address of Circle to pointPtr
cout << "\nCircle c (via *pointPtr): " ;
pointPtr.print( );

here at compile time pointPtr is always of Point type ???
and at run time it is of Circle type but because there are not a
vritual function is
called the base class print() ???

2
*************** *************** *************** *************** *************** *********
// Treat a Circle as a Circle (with some casting)
// cast base-class pointer to derived-class pointer
circlePtr = static_cast< Circle * >( pointPtr );
cout << "\nCircle c (via *circlePtr):\n"
circlePtr->area();

here pontPtr is at compile time always of Point type but at run-time
it is of Circle
type and than we can make the CAST ??? and than area() is called on
it ???

3
*************** *************** *************** *************** *************** ************
// DANGEROUS: Treat a Point as a Circle
pointPtr = &p; // assign address of Point to pointPtr

// cast base-class pointer to derived-class pointer
circlePtr = static_cast< Circle * >( pointPtr );
cout << "\nPoint p (via *circlePtr):\n"
circlePtr->area();

here that forced cast make at run time circlePtr of Point type
but the area() is not in it defined... and at compile time which is is
type ???????

AAARGHHH confused HELP ME!!!!

[Nick Keighley]

josh wrote:

Hi I have the following doubts:

I have 2 class Point and the derived Circle. Point doesn't have
virtual function.

Now can you explain me when came the conversion (compile or run time)
when I do:

Point *pointPtr = 0, p( 30, 50 );
Circle *circlePtr = 0, c( 2.7, 120, 89 );

it's clearer if you stick to one declaration per line.

Point* pointPtr = 0;
Point p( 30, 50 );
Circle *circlePtr = 0;
Circle c( 2.7, 120, 89 );

1
*************** *************** *************** *************** *************** *****
// Treat a Circle as a Point (see only the base class part)
pointPtr = &c; // assign address of Circle to pointPtr

this should earn you a compiler diagnostic unless a Circle is a Point.
That is Circle is derived from Point. A semantically dubious
proposition
if Circles and Points are supposed to be anything like their geometric
counterparts.

cout << "\nCircle c (via *pointPtr): " ;
pointPtr.print( );

here at compile time pointPtr is always of Point type ???

you declared pointPtr to be a Point*. It can't change.

and at run time it is of Circle type but because there are not a
vritual function is
called the base class print() ???

post a complete compiable program. There's too mach guess work
involved at the moment.

<snip>

AAARGHHH confused HELP ME!!!!

and you can see the code. Think how I feel...
--
Nick Keighley

[Jim Langston]

"josh" <xd********@gma il.comwrote in message
news:11******** **************@ d57g2000hsg.goo glegroups.com.. .

Hi I have the following doubts:

I have 2 class Point and the derived Circle. Point doesn't have
virtual function.

Now can you explain me when came the conversion (compile or run time)
when I do:

Point *pointPtr = 0, p( 30, 50 );
Circle *circlePtr = 0, c( 2.7, 120, 89 );

1
*************** *************** *************** *************** *************** *****
// Treat a Circle as a Point (see only the base class part)
pointPtr = &c; // assign address of Circle to pointPtr
cout << "\nCircle c (via *pointPtr): " ;
pointPtr.print( );

pointPtr is a pointer. You would have to use:
pointPtr->print();
or
(*pointPtr).pri nt();

here at compile time pointPtr is always of Point type ???
and at run time it is of Circle type but because there are not a
vritual function is
called the base class print() ???

Yes. If print is not declared as virtual in your base class, then it would
use the base classes' print method.

2
*************** *************** *************** *************** *************** *********
// Treat a Circle as a Circle (with some casting)
// cast base-class pointer to derived-class pointer
circlePtr = static_cast< Circle * >( pointPtr );
cout << "\nCircle c (via *circlePtr):\n"
circlePtr->area();

here pontPtr is at compile time always of Point type but at run-time
it is of Circle
type and than we can make the CAST ??? and than area() is called on
it ???

Yes. Nothing really magic about this, because your pointPtr was in fact
pointing to an instance of a Circle.

3
*************** *************** *************** *************** *************** ************
// DANGEROUS: Treat a Point as a Circle
pointPtr = &p; // assign address of Point to pointPtr

// cast base-class pointer to derived-class pointer
circlePtr = static_cast< Circle * >( pointPtr );
cout << "\nPoint p (via *circlePtr):\n"
circlePtr->area();

here that forced cast make at run time circlePtr of Point type
but the area() is not in it defined... and at compile time which is is
type ???????

Yes, static_cast would in fact treat your Point as a Circle, and as you can
see, bad things happen, because it is not in fact a circle and is missing
information. Safer is to use Dynamic cast, which would return 0 (NULL) if
it's not the right class.

circlePtr = dyanmic_cast< Circle* >( pointPtr );
if ( circlePtr != NULL )
cout << "\nPoint p (via *circlePtr):\n" ;
else
cout << "I'm pointing to nothing, NULL"\n";

>
AAARGHHH confused HELP ME!!!!

[peter koch]

On 30 Mar., 12:01, "josh" <xdevel1...@gma il.comwrote:

Hi I have the following doubts:

I have 2 class Point and the derived Circle. Point doesn't have
virtual function.

To begin with, it is silly to derive a circle from a point. A circle
is not a point and therefore you should not derive.
Secondly, base-classes normally need virtual destructors (if not it
should be protected). A class such as Point most probably should NOT
have any virtual functions - one more indication that your design is
wrong.

>
Now can you explain me when came the conversion (compile or run time)
when I do:

Point *pointPtr = 0, p( 30, 50 );
Circle *circlePtr = 0, c( 2.7, 120, 89 );

1
*************** *************** *************** *************** *************** ******
// Treat a Circle as a Point (see only the base class part)

Well - that comment is misleading. In your design you do not treat a
Circle as a Point. A Circle IS a point.

pointPtr = &c; // assign address of Circle to pointPtr
cout << "\nCircle c (via *pointPtr): " ;
pointPtr.print( );

This will not compile: it should be pointPtr->print(). According to
your design, it should print the point.

>
here at compile time pointPtr is always of Point type ???

Yes. Assuming you have declared pointPtr to be a Point*

and at run time it is of Circle type but because there are not a
vritual function is
called the base class print() ???

Yes.

>
2
*************** *************** *************** *************** *************** **********
// Treat a Circle as a Circle (with some casting)
// cast base-class pointer to derived-class pointer
circlePtr = static_cast< Circle * >( pointPtr );
cout << "\nCircle c (via *circlePtr):\n"
circlePtr->area();

here pontPtr is at compile time always of Point type but at run-time
it is of Circle

There is no pointPtr here. circlePtr is whatever type you have
declared it to (presumably Circle*)

type and than we can make the CAST ??? and than area() is called on
it ???

3
*************** *************** *************** *************** *************** *************
// DANGEROUS: Treat a Point as a Circle
pointPtr = &p; // assign address of Point to pointPtr

// cast base-class pointer to derived-class pointer
circlePtr = static_cast< Circle * >( pointPtr );
cout << "\nPoint p (via *circlePtr):\n"
circlePtr->area();

here that forced cast make at run time circlePtr of Point type
but the area() is not in it defined... and at compile time which is is
type ???????

AAARGHHH confused HELP ME!!!!

It is simple: a pointer is always of the type you declared it to. So
pointPtr is always a pointer to a point, and circlePtr is always a
pointer to a circle. What confuses you is that a pointer might point
to something that is more than a point: a pointer to a baseclass could
point to a base-object but also to any object that derives from base.

/Peter

[Jim Langston]

"Jim Langston" <ta*******@rock etmail.comwrote in message
news:yM******** ********@newsfe 04.lga...

>
"josh" <xd********@gma il.comwrote in message
news:11******** **************@ d57g2000hsg.goo glegroups.com.. .

>Hi I have the following doubts:

I have 2 class Point and the derived Circle. Point doesn't have
virtual function.

Now can you explain me when came the conversion (compile or run time)
when I do:

Point *pointPtr = 0, p( 30, 50 );
Circle *circlePtr = 0, c( 2.7, 120, 89 );

>1
************** *************** *************** *************** *************** ******
// Treat a Circle as a Point (see only the base class part)
pointPtr = &c; // assign address of Circle to pointPtr
cout << "\nCircle c (via *pointPtr): " ;
pointPtr.print ();

pointPtr is a pointer. You would have to use:
pointPtr->print();
or
(*pointPtr).pri nt();

>here at compile time pointPtr is always of Point type ???
and at run time it is of Circle type but because there are not a
vritual function is
called the base class print() ???

Yes. If print is not declared as virtual in your base class, then it
would use the base classes' print method.

>2
************** *************** *************** *************** *************** **********
// Treat a Circle as a Circle (with some casting)
// cast base-class pointer to derived-class pointer
circlePtr = static_cast< Circle * >( pointPtr );
cout << "\nCircle c (via *circlePtr):\n"
circlePtr->area();

here pontPtr is at compile time always of Point type but at run-time
it is of Circle
type and than we can make the CAST ??? and than area() is called on
it ???

Yes. Nothing really magic about this, because your pointPtr was in fact
pointing to an instance of a Circle.

>3
************** *************** *************** *************** *************** *************
// DANGEROUS: Treat a Point as a Circle
pointPtr = &p; // assign address of Point to pointPtr

// cast base-class pointer to derived-class pointer
circlePtr = static_cast< Circle * >( pointPtr );
cout << "\nPoint p (via *circlePtr):\n"
circlePtr->area();

here that forced cast make at run time circlePtr of Point type
but the area() is not in it defined... and at compile time which is is
type ???????

Yes, static_cast would in fact treat your Point as a Circle, and as you
can see, bad things happen, because it is not in fact a circle and is
missing information. Safer is to use Dynamic cast, which would return 0
(NULL) if it's not the right class.

circlePtr = dyanmic_cast< Circle* >( pointPtr );
if ( circlePtr != NULL )
cout << "\nPoint p (via *circlePtr):\n" ;
else
cout << "I'm pointing to nothing, NULL"\n";

>>
AAARGHHH confused HELP ME!!!!

All that being said, Peter is right, a Circle is not a point, so should not
be derived from it. However, a cirle HAS points. Better would be something
like:

class Circle
{
private:
Point Center_;
doouble Radius_;
};

class Rectangle
{
private:
Point Corners[4]; // Some would use std::vector here
};

class Triangle
{
private:
Point Corners[3]; // Some would use std::vector here
};

etc...

If you do need a base, I would use Shape.

class Shape
{
public:
double virtual Area() = 0
double virtual Circumferance() = 0
~Shape() {}
};

class Circle: public Shape
{
public:
Circle( const Point Center, double Radius ): Center_( Center ),
Radius_( Radius ) {}
double Area() { return 3.1415926 * radius_ * radius_; }
double Circumfernace() { return 3.141592 * radius_ * 2; }
private:
Point Center_;
double Radius_;
};

etc...

[josh]

To begin with, it is silly to derive a circle from a point. A circle

is not a point and therefore you should not derive.

yes is better to make Point inside a Circle and sayng
that a Circle has like coords a Point (relationship "has a" and not
"is a")

A Circle IS a point.

because it is to it derived...

pointPtr.print( );

yes I post it wrong!

circlePtr = static_cast< Circle * >( pointPtr );

following the code flow at now at compile time pointPtr is Point* but
at run-time it is pointong to a Circle

It is simple: a pointer is always of the type you declared it to. So
pointPtr is always a pointer to a point, and circlePtr is always a
pointer to a circle. What confuses you is that a pointer might point
to something that is more than a point: a pointer to a baseclass could
point to a base-object but also to any object that derives from base.

yes I make confusion from compile and run time when I make
assignements operation
so what can I ask myself to understand what is happening?

[James Curran]

On Mar 30, 6:38 am, "Jim Langston" <tazmas...@rock etmail.comwrote :

Safer is to use Dynamic cast, which would return 0 (NULL) if
it's not the right class.

Unfortunately, that won't work here, because, as stated in the
original description, our classes don't have virtual functions, which
are needed for dynamic_cast<to work.

[James Curran]

On Mar 30, 7:44 am, "Jim Langston" <tazmas...@rock etmail.comwrote :

class Rectangle
{
private:
Point Corners[4]; // Some would use std::vector here

};

Hmmmm... Now, while I really like std::vector and use it all the time,
I'm completely baffled why anyone would choose to use one there, where
it is assured that we can only ever have exactly four points.

[Jim Langston]

"josh" <xd********@gma il.comwrote in message
news:11******** **************@ d57g2000hsg.goo glegroups.com.. .

>To begin with, it is silly to derive a circle from a point. A circle
is not a point and therefore you should not derive.

yes is better to make Point inside a Circle and sayng
that a Circle has like coords a Point (relationship "has a" and not
"is a")

>A Circle IS a point.

because it is to it derived...

pointPtr.print( );

yes I post it wrong!

circlePtr = static_cast< Circle * >( pointPtr );

following the code flow at now at compile time pointPtr is Point* but
at run-time it is pointong to a Circle

>It is simple: a pointer is always of the type you declared it to. So
pointPtr is always a pointer to a point, and circlePtr is always a
pointer to a circle. What confuses you is that a pointer might point
to something that is more than a point: a pointer to a baseclass could
point to a base-object but also to any object that derives from base.

yes I make confusion from compile and run time when I make
assignements operation
so what can I ask myself to understand what is happening?

What can you ask yourself?

What is this pointer actually pointing to. An instance of what. What it
points to is not changing. Only how you treat the pointer.