newbie and polymorphism

[Vincent RICHOMME]

Hi,

I wrote this code and I thinks it's really bad to do it but I would like
a confirmation :

class A
{
public:

void Print()
{
std::cout << "A:rint()" << std::endl;
}
};


class DerivA : public A
{
public:

void Print()
{
std::cout << "derivA:rint()" << std::endl;
}

};


int main()
{
//std::cout << "Hello world!" << std::endl;

A* pA = new A();
DerivA* pDerivA = (DerivA*) pA;

pDerivA->Print();


return 0;
}

Actually I cast tha base class pA to a derived one, and I don't think
it's allowed.

 

[Rolf Magnus]

Hi,

I wrote this code and I thinks it's really bad to do it but I would like
a confirmation :

class A
{
public:

void Print()
{
std::cout << "A:rint()" << std::endl;
}
};


class DerivA : public A
{
public:

void Print()
{
std::cout << "derivA:rint()" << std::endl;
}

};


int main()
{
//std::cout << "Hello world!" << std::endl;

A* pA = new A();
DerivA* pDerivA = (DerivA*) pA;

pDerivA->Print();


return 0;
}

Actually I cast tha base class pA to a derived one, and I don't think
it's allowed.

You are right. You should use polymorphism instead.

Btw: If casting, you should stick with C++ style casts.

 

[Neelesh Bodas]

Hi,

I wrote this code and I thinks it's really bad to do it but I would like
a confirmation :

class A
{
public:

void Print()
{
std::cout << "A:rint()" << std::endl;
}
};


class DerivA : public A
{
public:

void Print()
{
std::cout << "derivA:rint()" << std::endl;
}

};


int main()
{
//std::cout << "Hello world!" << std::endl;

A* pA = new A();
DerivA* pDerivA = (DerivA*) pA;

pDerivA->Print();


return 0;
}

Actually I cast tha base class pA to a derived one, and I don't think
it's allowed.

Well, to be exact, it is _allowed_. Its a different matter that it is a
"bad practice". But there arise situations where one needs to downcast
a base class pointer to a derived class pointer. C++ defines a specific
cast called dynamic_cast for this.

pDerivA = dynamic_cast<DerivA*>(pA);

Note that this code doesnot compile in the current scenario since base
class is not polymorphic (It has no virtual functions). But then it
should not be subclassed at the first place.

Also, the class to Print() is statically bound.

 

[Neelesh Bodas]

Correction.

Also, the class to Print() is statically bound.

Also, the *call* to Print() is statically bound.

 

[Frinos]

Hi,

I wrote this code and I thinks it's really bad to do it but I would like
a confirmation :

class A
{
public:

void Print()
{
std::cout << "A:rint()" << std::endl;
}
};

OK


class DerivA : public A
{
public:

void Print()
{
std::cout << "derivA:rint()" << std::endl;
}

};


OK

int main()
{
//std::cout << "Hello world!" << std::endl;

A* pA = new A();
DerivA* pDerivA = (DerivA*) pA;

pDerivA->Print();


return 0;
}

Actually I cast tha base class pA to a derived one, and I don't think
it's allowed.

It is allowed.... Any type can be cast to any other type and the code
may compile BUT whether it runs correctly is a different story... and
yup it is really bad to do...

 

[Dietmar Kuehl]

It is allowed....

The C++ standard does not speak in terms of permissions, i.e. I'm not
clear what either of you means with "allowed". The standard speaks in
terms of defined behavior and whether a compiler is supposed to issue
a diagnostic.

The code is supposed to be compiled without a diagnostic. In this
sense it is "allowed" C++ code as the compiler is required to compile
it without an error. However, the standard is explicit about whether
the semantics of the resulting program are defined or not: they are
not. In this sense it is "not allowed" C++ code because you cannot
predict the behavior when running the program: it is free to do
whatever the implementer of the C++ compiler thought reasonable or
it may do whatever it just happens to do by pure coincidence.