"?? Tiib" <ootiib@hot.ee> wrote in message
news:fd3e7076-47da-40f3-aa05-9a0cf5aeb42d@p11g2000vbq.googlegroups.com...
On Feb 28, 9:45 pm, "Paul" <pchris...@yahoo.co.uk> wrote:
" Tiib" <oot...@hot.ee> wrote in message
news:7e2e42b3-2410-443a-95c2-46f262c8334b@n18g2000vbq.googlegroups.com...
On Feb 25, 11:07 am, "Paul" <pchris...@yahoo.co.uk> wrote:
Please let me know if you still do not understand and I will
re-explain
again.
--Your code does not work. You can not overwrite object 'Dog dog;' in a
--way that Cat's destructor is called for it when that dog leaves
--scope ... Dog's destructor is called for it on all C++ compilers i
--could reach. What destructor will be called is pre-decided and set
--already compile time. So it seems that you do not understand yourself
--what you are talking about.
#include <iostream>
class Animal{};
class Dog: public Animal{};
class Cat: public Animal{};
int main()
{
Cat* p_cat = new Cat;
std::cout<< p_cat << std::endl;
delete p_cat;
Dog* p_dog = reinterpret_cast<Dog*>(p_cat);
p_dog = new Dog;
std::cout << p_dog;
}
--What does this code overwrite?
--Also ... most compilers optimize the two lines:
--Dog* p_dog = reinterpret_cast<Dog*>(p_cat);
--p_dog = new Dog;
--Into something like:
-- Dog* p_dog = new Dog;
It doesn't trully overwrite anything but its the closet example I can
give, using C++ code.
Here is some code that demonstrates a similar thing:
#include <iostream>
class Animal{public:
virtual void eat(){std::cout<< "Animal Eating"<< std::endl;}
virtual int getID()=0;
static int count;
};
class Dog: public Animal{
public:
void eat(){std::cout<< "Dog Eating"<< std::endl;}
int getID(){return 1;}
};
class Cat: public Animal{
public:
void eat(){std::cout<< "Cat Eating"<< std::endl;}
int getID(){return 0;}
};
int Animal::count =10;
Dog* overwriteCat(Animal* ptr){
delete ptr;
Dog* p = reinterpret_cast<Dog*>(ptr);
p = new Dog;
return p;
}
Cat* overwriteDog(Animal* ptr){
delete ptr;
Cat* p = reinterpret_cast<Cat*>(ptr);
p = new Cat;
return p;
}
void ordinary_function(Animal* obj){
Animal::count--;
std::cout<<"Address of obj: " <<obj << " ";
obj->eat();
if(obj->getID()){overwriteDog(obj);}
else {overwriteCat(obj);}
if(Animal::count){
ordinary_function(obj);
}
}
int main()
{
Cat* p_cat = new Cat;
Animal* p_anim = p_cat;
ordinary_function(p_cat);
}
You cannot do this type of recursion with a member function, a member
function belongs to the object with which its called.