[Newbie]How to implement type inheritance?

An Animal can be a Dog, Fish, Bird, etc

A Dog can be a Shepherd, Terrier, etc
A Fish can be a Guppy, Salmon, etc


getAnimal(InputStream) reads some input from the input stream and returns an object of type Animal.
A checking function repeatedly calls getAnimal and checks what kind of Animal is returned(Dog, Fish, etc), then checks the specific type of animal(Guppy, Salmon, etc), and does some computation.

How should the datatype Animal be implemented? An enum/struct/typedef/class? How then would I go about implementing the checking function? I was thinking of something like the following:

Code:

---

Animal a = getAnimal(inputStream);
switch (a) {
        case DOG:
                do something
                case SHEPERD:
                        do something:
                case TERRIER:
                        do something:
        case FISH:
                do something
                case GUPPY:
                        do something:
                case SALMON:
                        do something:
        ....
}

---

The syntax and case construct is slightly broken but I hope you get the idea.

You're doing this completely wrong.

If you don't have enough input to construct an animal (or Dog or whatever), then don't construct one. Constructors aren't supposed to fail.

So either:
1. Write constructors that never fail.
2. Or throw an exception when they do fail.

For the other part of this question, dynamic binding can remove the problem of run time type identification in a number of cases. This is when you take a pointer of the parent type and cast it to the type you're working with.

Animal *pet = getAnimal(cin);
Dog *myDog = dynamic_cast<Dog *>(pet);

or

Fish *myFish = dynamic_cast<Fish *>(pet);

Naturally, dynamic_cast can fail and will fail if A* is not controvertible to B*, so you still need to make sure it works.

If you want to use polymorphism then you're doing it wrong. I should look something like this:

Code:

---

class Animal{
  virtural void do_something() = 0;
  virtual ~Animal();
}

class Dog: public Animal{
  void do_something(){
    //stuff...
    do_something_else();
  }
  virtual void do_something_else() = 0;
  virtual ~Dog();
}

class Shepard: public Dog{
  void do_something_else();
}

//then you use it like
Animal *animal = getAnimal(inputStream);
animal->do_something();

---

On a different note, don't call the function getAnimal(). Functions beginning with get are generally used as accessors to get a class's data, and that's not what you are doing here.

Quote:

---

Originally Posted by whiteflags

You're doing this completely wrong.

If you don't have enough input to construct an animal (or Dog or whatever), then don't construct one. Constructors aren't supposed to fail.

So either:
1. Write constructors that never fail.
2. Or throw an exception when they do fail.

---

getAnimal is not a constructor. That not a problem here.

Quote:

---

For the other part of this question, dynamic binding can remove the problem of run time type identification in a number of cases. This is when you take a pointer of the parent type and cast it to the type you're working with.

Animal *pet = getAnimal(cin);
Dog *myDog = dynamic_cast<Dog *>(pet);

or

Fish *myFish = dynamic_cast<Fish *>(pet);

Naturally, dynamic_cast can fail and will fail if A* is not controvertible to B*, so you still need to make sure it works.

---

This undermines the entire purpose of making Dog and fish a subclass of animal. Don't use dynamic cast for something like this. If you think you need dynamic cast, think again, cause your probably wrong.

Quote:

---

Originally Posted by King Mir

getAnimal is not a constructor. That not a problem here.

This undermines the entire purpose of making Dog and fish a subclass of animal. Don't use dynamic cast for something like this. If you think you need dynamic cast, think again, cause your probably wrong.

---

Uh huh but I think you are wrong, too. If animal is an abstract base class, then stack objects of it should not compile (because they're abstract). So your code doesn't work either. OTOH pointers to animal, being a different type than animal, are OK. But some type of cast is necessary between animal* and any of its' children, perhaps I picked the wrong one.

If dynamic_cast is really wrong here, please explain why. Anyone.

Quote:

---

Originally Posted by whiteflags

But some type of cast is necessary between animal* and any of its' children, perhaps I picked the wrong one.

---

Why would a cast be necessary? The king at 12:28 gave a perfectly good example with no casting whatsoever. That's the point of virtual, after all, is to pick the right function based on type....

Quote:

---

Originally Posted by tabstop

The king at 12:28 gave a perfectly good example with no casting whatsoever. That's the point of virtual, after all, is to pick the right function based on type....

---

The problem is that King Mir's example is wrong, precisely because of the point that whiteflags raised: animal is of type Animal, which is an abstract base class, instead of type Animal& or (smart) pointer to Animal. Consequently, there will be a compile error, and if we change the type to a concrete base class, there would be no polymorphism.

Quote:

---

Originally Posted by laserlight

The problem is that King Mir's example is wrong, precisely because of the point that whiteflags raised: animal is of type Animal, which is an abstract base class, instead of type Animal& or (smart) pointer to Animal. Consequently, there will be a compile error, and if we change the type to a concrete base class, there would be no polymorphism.

---

Man man man. Of course that's what I wanted to see, so that's what I saw.

All right, try again. The OP says "getAnimal(InputStream) reads some input from the input stream and returns an object of type Animal." If that function returns an echte Animal object, then I think we're sunk no matter what if we try to be polymorphic, so we would have to store the type and have some unnecessary class variables (or, if we're feeling rambunctious, maybe a union). If that function returns by reference, then we can assign to a reference and everybody's happy (I think).

Well change it to return a pointer then. I did not compile or extensively check the example I wrote. But yeah, getAnimal() needs to return a pointer or reference for it to work. I fixed it above.

If getAnimal() must return an Animal by value, then there is no point in making subclasses of it. Instead you would have to use a member enum to determine what type of animal you are dealing with.

If the function returns by value, you are screwed because the objected will be sliced.
Then you'd have to make a big monolithic class of all the different types of animals and some sort of identifier to know which type it is. Tedious and just ... wrong.